@oneuptime/common 13.0.8 → 14.0.0

package/Tests/Utils/Monitor/MonitoringIntervalUtil.test.ts

@@ -0,0 +1,304 @@
+import MonitoringIntervalUtil, {
+  MonitoringIntervalNormalization,
+  MonitoringIntervalNormalizationStatus,
+} from "../../../Utils/Monitor/MonitoringIntervalUtil";
+import CronTab from "../../../Utils/CronTab";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * WHAT THIS FILE IS DEFENDING
+ *
+ * Monitor.monitoringInterval is free-text and was never validated. Rows
+ * accumulated holding a human cadence ("5m", "Every 5 minutes") where a cron
+ * expression was expected. cron-parser threw on those, the claim query
+ * caught the throw and fell back to "one minute from now", and a monitor
+ * configured for five minutes was probed every ~75 seconds — four times the
+ * requested rate, silently, for as long as the row existed.
+ *
+ * 103 monitors across 10 projects were in that state. The ten distinct bad
+ * values below are the REAL production census, not invented examples, and
+ * every one of them is asserted individually.
+ */
+
+function normalize(value: string | null | undefined): string | null {
+  return MonitoringIntervalUtil.toCronOrNull(value);
+}
+
+describe("MonitoringIntervalUtil", () => {
+  describe("the production census — every bad value found in the wild", () => {
+    /*
+     * SELECT "monitoringInterval", count(*) FROM "Monitor"
+     *   WHERE "deletedAt" IS NULL AND "monitoringInterval" is not cron
+     * 103 rows, 10 distinct values, 10 projects.
+     */
+    const PRODUCTION_VALUES: Array<[string, string, number]> = [
+      ["Every 5 minutes", "*/5 * * * *", 35],
+      ["5m", "*/5 * * * *", 19],
+      ["1 minute", "* * * * *", 18],
+      ["Every 5 Minutes", "*/5 * * * *", 14],
+      ["Every 1 minute", "* * * * *", 6],
+      ["Every 2 minutes", "*/2 * * * *", 4],
+      ["5 minutes", "*/5 * * * *", 3],
+      ["1 day", "0 0 * * *", 2],
+      ["every-1-min", "* * * * *", 1],
+      ["Every Five Minutes", "*/5 * * * *", 1],
+    ];
+
+    test.each(PRODUCTION_VALUES)(
+      "reads %j as %j (%i monitors in production)",
+      (input: string, expectedCron: string) => {
+        expect(normalize(input)).toBe(expectedCron);
+      },
+    );
+
+    test("every production value now yields a parseable cron", () => {
+      for (const [input] of PRODUCTION_VALUES) {
+        const cron: string | null = normalize(input);
+
+        /*
+         * "Every Five Minutes" spells its number out, which the duration
+         * grammar cannot read. It is covered by the exact-label table; if
+         * that entry is ever dropped this assertion is what catches it.
+         */
+        expect(cron).not.toBeNull();
+        expect(CronTab.isValid(cron as string)).toBe(true);
+      }
+    });
+
+    test("the customer's value is five minutes apart, not one", () => {
+      /*
+       * The regression in one line: "5m" must not mean "every minute".
+       */
+      expect(normalize("5m")).toBe("*/5 * * * *");
+      expect(normalize("5m")).not.toBe("* * * * *");
+    });
+  });
+
+  describe("valid cron is returned untouched", () => {
+    const VALID: Array<string> = [
+      "* * * * *",
+      "*/2 * * * *",
+      "*/5 * * * *",
+      "*/10 * * * *",
+      "*/15 * * * *",
+      "*/30 * * * *",
+      "0 * * * *",
+      "0 */6 * * *",
+      "0 0 * * *",
+      "0 0 * * 0",
+      "0 9 * * 1",
+      "3-59/5 * * * *",
+      "0,15,30,45 * * * *",
+    ];
+
+    test.each(VALID)("%j passes through byte-identical", (cron: string) => {
+      const result: MonitoringIntervalNormalization =
+        MonitoringIntervalUtil.normalize(cron);
+
+      expect(result.status).toBe(
+        MonitoringIntervalNormalizationStatus.AlreadyCanonical,
+      );
+      expect(result.cron).toBe(cron);
+    });
+
+    test("cron-parser shortcuts are never REWRITTEN into something else", () => {
+      /*
+       * "@hourly" is a deliberate seam between the two parsers. The
+       * isomorphic validator here is a hand-rolled 5-field check and does
+       * not know it; cron-parser, which actually schedules the probe, does.
+       *
+       * What matters is that this util never GUESSES: it reports
+       * Unrecognized with a null cron rather than rewriting "@hourly" into
+       * "0 * * * *". The server validator's cron-parser fallback is what
+       * accepts it on write, and resolveNextPingAt's raw-parse-first order
+       * is what honours it at runtime — both covered in their own suites.
+       * If this util ever started rewriting it, a stored value would change
+       * under the customer for no behavioural gain.
+       */
+      const result: MonitoringIntervalNormalization =
+        MonitoringIntervalUtil.normalize("@hourly");
+
+      expect(result.status).toBe(
+        MonitoringIntervalNormalizationStatus.Unrecognized,
+      );
+      expect(result.cron).toBeNull();
+    });
+  });
+
+  describe("empty is a legitimate state, never an error", () => {
+    /*
+     * ~4,177 production rows are NULL or blank. A Manual monitor is never
+     * probed; treating that as invalid would break every one of them.
+     */
+    test.each([null, undefined, "", "   ", "\t\n"])(
+      "%j is Empty with a null cron",
+      (value: string | null | undefined) => {
+        const result: MonitoringIntervalNormalization =
+          MonitoringIntervalUtil.normalize(value);
+
+        expect(result.status).toBe(MonitoringIntervalNormalizationStatus.Empty);
+        expect(result.cron).toBeNull();
+      },
+    );
+  });
+
+  describe("label tolerance", () => {
+    test("is case-insensitive", () => {
+      expect(normalize("EVERY 5 MINUTES")).toBe("*/5 * * * *");
+      expect(normalize("every 5 minutes")).toBe("*/5 * * * *");
+      expect(normalize("Every 5 Minutes")).toBe("*/5 * * * *");
+    });
+
+    test("collapses runs of whitespace, including a non-breaking space", () => {
+      expect(normalize("Every  5   minutes")).toBe("*/5 * * * *");
+      expect(normalize("  Every 5 minutes  ")).toBe("*/5 * * * *");
+      // U+00A0 survives a copy-paste out of rendered docs.
+      expect(normalize("Every 5 minutes")).toBe("*/5 * * * *");
+    });
+
+    test("strips wrapping quotes and a trailing period", () => {
+      expect(normalize('"Every 5 minutes"')).toBe("*/5 * * * *");
+      expect(normalize("'5m'")).toBe("*/5 * * * *");
+      expect(normalize("Every 5 minutes.")).toBe("*/5 * * * *");
+    });
+
+    test("reads hyphenated and underscored forms", () => {
+      expect(normalize("every-1-min")).toBe("* * * * *");
+      expect(normalize("every_5_minutes")).toBe("*/5 * * * *");
+    });
+
+    test("covers every label the shared preset list offers", () => {
+      /*
+       * The table is built by iterating CronTab.PRESETS, so a preset added
+       * there is understood here without anyone editing the util. This
+       * asserts that wiring rather than the individual labels.
+       */
+      for (const preset of CronTab.PRESETS) {
+        expect(normalize(preset.label)).toBe(preset.value);
+      }
+    });
+  });
+
+  describe("duration grammar", () => {
+    test.each([
+      ["1m", "* * * * *"],
+      ["1 min", "* * * * *"],
+      ["minutely", "* * * * *"],
+      ["2m", "*/2 * * * *"],
+      ["10 mins", "*/10 * * * *"],
+      ["15 minutes", "*/15 * * * *"],
+      ["30m", "*/30 * * * *"],
+      ["60m", "0 * * * *"],
+      ["1h", "0 * * * *"],
+      ["hourly", "0 * * * *"],
+      ["2 hours", "0 */2 * * *"],
+      ["6h", "0 */6 * * *"],
+      ["12 hrs", "0 */12 * * *"],
+      ["24h", "0 0 * * *"],
+      ["1d", "0 0 * * *"],
+      ["daily", "0 0 * * *"],
+      ["1 week", "0 0 * * 0"],
+      ["weekly", "0 0 * * 0"],
+    ])("reads %j as %j", (input: string, expected: string) => {
+      expect(normalize(input)).toBe(expected);
+    });
+  });
+
+  describe("refuses to store a lie", () => {
+    /*
+     * "*_/7 * * * *" fires at :00, :07 ... :56 and then :00 — a four-minute
+     * gap at every hour wrap. It is NOT "every 7 minutes", so normalizing
+     * "every 7 minutes" to it would store something false. Better to refuse
+     * and let the caller write the cron they actually mean.
+     */
+    test.each([
+      "7m",
+      "every 7 minutes",
+      "13 minutes",
+      "5 hours",
+      "7h",
+      "2 days",
+      "3 weeks",
+    ])(
+      "%j is Unrecognized rather than silently approximated",
+      (input: string) => {
+        const result: MonitoringIntervalNormalization =
+          MonitoringIntervalUtil.normalize(input);
+
+        expect(result.status).toBe(
+          MonitoringIntervalNormalizationStatus.Unrecognized,
+        );
+        expect(result.cron).toBeNull();
+      },
+    );
+
+    test("sub-minute cadences are not invented", () => {
+      /*
+       * The claim loop ticks once a minute, so a per-second cadence is a
+       * promise the probe fleet cannot keep.
+       */
+      for (const input of ["30s", "1s", "10 seconds", "1 sec"]) {
+        expect(normalize(input)).toBeNull();
+      }
+    });
+  });
+
+  describe("genuine nonsense stays Unrecognized", () => {
+    test.each([
+      "banana",
+      "asap",
+      "not a cron",
+      "soon",
+      "-1m",
+      "0m",
+      "every",
+      "minutes",
+    ])("%j", (input: string) => {
+      expect(normalize(input)).toBeNull();
+    });
+  });
+
+  describe("totality", () => {
+    /*
+     * It runs in a write hook, on the scheduler hot path and inside a
+     * migration. A throw in any of those is worse than a null.
+     */
+    test("never throws, whatever it is handed", () => {
+      const hostile: Array<unknown> = [
+        null,
+        undefined,
+        "",
+        "🙂",
+        "*".repeat(5000),
+        "{{ variable }}",
+        "; DROP TABLE Monitor; --",
+        "",
+        12345,
+        {},
+        [],
+      ];
+
+      for (const value of hostile) {
+        expect(() => {
+          return MonitoringIntervalUtil.normalize(value as string);
+        }).not.toThrow();
+      }
+    });
+
+    test("is idempotent — normalizing its own output changes nothing", () => {
+      const inputs: Array<string> = [
+        "5m",
+        "Every 5 minutes",
+        "1 day",
+        "every-1-min",
+        "*/5 * * * *",
+      ];
+
+      for (const input of inputs) {
+        const once: string | null = normalize(input);
+        expect(once).not.toBeNull();
+        expect(normalize(once)).toBe(once);
+      }
+    });
+  });
+});

package/Tests/Utils/StatusPage/UptimeDailyAggregateUtil.test.ts

@@ -0,0 +1,248 @@
+import ObjectID from "../../../Types/ObjectID";
+import { JSONObject } from "../../../Types/JSON";
+import {
+  UptimeDailyAggregate,
+  UptimeDayBucket,
+} from "../../../Types/StatusPage/UptimeDailyAggregate";
+import UptimeDailyAggregateUtil from "../../../Utils/StatusPage/UptimeDailyAggregateUtil";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * WHAT THIS FILE IS DEFENDING
+ *
+ * The wire format for the uptime aggregate, which replaced shipping raw
+ * MonitorStatusTimeline rows to the status page.
+ *
+ * Two properties matter more than the round trip itself:
+ *
+ * 1. It must be SMALL. The rows it replaces serialize to ~431 bytes each,
+ *    almost entirely typed-JSON envelopes, so one real status page's 254,550
+ *    matching rows came to ~105 MB. If this format ever grows envelopes it
+ *    gives that back.
+ *
+ * 2. Parsing must be TOTAL. A status page that cannot read its aggregate has
+ *    to fall back to "no data", which is honest. What it must never do is
+ *    fall back to something that looks like uptime.
+ */
+
+const MONITOR_A: string = "11111111-1111-4111-8111-111111111111";
+const STATUS_UP: string = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa";
+
+function sample(): UptimeDailyAggregate {
+  return {
+    monitors: [
+      {
+        monitorId: new ObjectID(MONITOR_A),
+        buckets: [
+          {
+            bucketStart: new Date("2026-07-01T00:00:00.000Z"),
+            bucketEnd: new Date("2026-07-02T00:00:00.000Z"),
+            daySeconds: 86400,
+            coveredSeconds: 86400,
+            statusDurations: [
+              {
+                monitorStatusId: new ObjectID(STATUS_UP),
+                seconds: 86400,
+              },
+            ],
+          },
+          {
+            bucketStart: new Date("2026-07-02T00:00:00.000Z"),
+            bucketEnd: new Date("2026-07-03T00:00:00.000Z"),
+            daySeconds: 86400,
+            coveredSeconds: 0,
+            statusDurations: [],
+          },
+        ],
+      },
+    ],
+    isComplete: true,
+    completeFrom: null,
+  };
+}
+
+describe("UptimeDailyAggregateUtil", () => {
+  describe("round trip", () => {
+    test("survives toJSON -> fromJSON unchanged", () => {
+      const parsed: UptimeDailyAggregate = UptimeDailyAggregateUtil.fromJSON(
+        UptimeDailyAggregateUtil.toJSON(sample()),
+      );
+
+      expect(parsed.monitors).toHaveLength(1);
+      expect(parsed.monitors[0]!.monitorId.toString()).toBe(MONITOR_A);
+      expect(parsed.monitors[0]!.buckets).toHaveLength(2);
+
+      const first: UptimeDayBucket = parsed.monitors[0]!.buckets[0]!;
+
+      expect(first.coveredSeconds).toBe(86400);
+      expect(first.daySeconds).toBe(86400);
+      expect(first.bucketStart.toISOString()).toBe("2026-07-01T00:00:00.000Z");
+      expect(first.statusDurations[0]!.monitorStatusId.toString()).toBe(
+        STATUS_UP,
+      );
+    });
+
+    test("a no-data day survives as a no-data day", () => {
+      /*
+       * The single most important thing to preserve. If coverage were lost in
+       * transit the client would treat the day as ordinary and paint it with
+       * the operator's colour - which is the bug this whole change removes.
+       */
+      const parsed: UptimeDailyAggregate = UptimeDailyAggregateUtil.fromJSON(
+        UptimeDailyAggregateUtil.toJSON(sample()),
+      );
+
+      expect(parsed.monitors[0]!.buckets[1]!.coveredSeconds).toBe(0);
+      expect(parsed.monitors[0]!.buckets[1]!.statusDurations).toHaveLength(0);
+    });
+  });
+
+  describe("the wire format stays small", () => {
+    test("dates and ids are plain strings, not typed-JSON envelopes", () => {
+      const json: JSONObject = UptimeDailyAggregateUtil.toJSON(sample());
+      const encoded: string = JSON.stringify(json);
+
+      expect(encoded).not.toContain("_type");
+      expect(encoded).toContain("2026-07-01T00:00:00.000Z");
+      expect(encoded).toContain(MONITOR_A);
+    });
+
+    test("a 90-day, 50-monitor page stays far below the row payload it replaces", () => {
+      /*
+       * The rows this replaces were ~431 bytes each and a real page matched
+       * 254,550 of them (~105 MB). This asserts the replacement is bounded by
+       * structure rather than by how much a monitor flaps.
+       */
+      const aggregate: UptimeDailyAggregate = {
+        monitors: [],
+        isComplete: true,
+        completeFrom: null,
+      };
+
+      for (let m: number = 0; m < 50; m++) {
+        const buckets: Array<UptimeDayBucket> = [];
+
+        for (let d: number = 0; d < 90; d++) {
+          const start: Date = new Date(
+            Date.UTC(2026, 3, 1) + d * 24 * 60 * 60 * 1000,
+          );
+
+          buckets.push({
+            bucketStart: start,
+            bucketEnd: new Date(start.getTime() + 86400000),
+            daySeconds: 86400,
+            coveredSeconds: 86400,
+            statusDurations: [
+              { monitorStatusId: new ObjectID(STATUS_UP), seconds: 86000 },
+              { monitorStatusId: new ObjectID(MONITOR_A), seconds: 400 },
+            ],
+          });
+        }
+
+        aggregate.monitors.push({
+          monitorId: new ObjectID(
+            `${MONITOR_A.slice(0, -2)}${m % 10}${m % 10}`,
+          ),
+          buckets,
+        });
+      }
+
+      const bytes: number = JSON.stringify(
+        UptimeDailyAggregateUtil.toJSON(aggregate),
+      ).length;
+
+      // Comfortably under a megabyte for the largest page the product allows.
+      expect(bytes).toBeLessThan(1_500_000);
+    });
+  });
+
+  describe("parsing is total", () => {
+    test.each([
+      ["null", null],
+      ["undefined", undefined],
+      ["an empty object", {}],
+      ["monitors not an array", { monitors: "nope" }],
+    ])(
+      "%s yields an empty aggregate rather than throwing",
+      (_name: string, input: unknown) => {
+        expect(() => {
+          return UptimeDailyAggregateUtil.fromJSON(input as JSONObject);
+        }).not.toThrow();
+
+        const parsed: UptimeDailyAggregate = UptimeDailyAggregateUtil.fromJSON(
+          input as JSONObject,
+        );
+
+        expect(parsed.monitors).toHaveLength(0);
+      },
+    );
+
+    test("a bucket with an unparseable date is dropped, not turned into coverage", () => {
+      const parsed: UptimeDailyAggregate = UptimeDailyAggregateUtil.fromJSON({
+        monitors: [
+          {
+            monitorId: MONITOR_A,
+            buckets: [
+              {
+                bucketStart: "not-a-date",
+                bucketEnd: "also-not",
+                daySeconds: 1,
+              },
+            ],
+          },
+        ],
+        weird: true,
+      } as unknown as JSONObject);
+
+      expect(parsed.monitors[0]!.buckets).toHaveLength(0);
+    });
+
+    test("a missing isComplete means complete, not incomplete", () => {
+      /*
+       * An older server has no cap in this path either. Defaulting to
+       * incomplete would grey out every bar on a perfectly healthy page.
+       */
+      const parsed: UptimeDailyAggregate = UptimeDailyAggregateUtil.fromJSON({
+        monitors: [],
+      } as unknown as JSONObject);
+
+      expect(parsed.isComplete).toBe(true);
+    });
+
+    test("an explicit isComplete false is honoured", () => {
+      const parsed: UptimeDailyAggregate = UptimeDailyAggregateUtil.fromJSON({
+        monitors: [],
+        isComplete: false,
+        completeFrom: "2026-07-05T00:00:00.000Z",
+      } as unknown as JSONObject);
+
+      expect(parsed.isComplete).toBe(false);
+      expect(parsed.completeFrom?.toISOString()).toBe(
+        "2026-07-05T00:00:00.000Z",
+      );
+    });
+  });
+
+  describe("getBucketsForMonitor", () => {
+    test("returns that monitor's buckets", () => {
+      expect(
+        UptimeDailyAggregateUtil.getBucketsForMonitor(sample(), MONITOR_A),
+      ).toHaveLength(2);
+    });
+
+    test("returns empty for a monitor that is not in the aggregate", () => {
+      expect(
+        UptimeDailyAggregateUtil.getBucketsForMonitor(
+          sample(),
+          "99999999-9999-4999-8999-999999999999",
+        ),
+      ).toHaveLength(0);
+    });
+
+    test("returns empty rather than throwing when there is no aggregate", () => {
+      expect(
+        UptimeDailyAggregateUtil.getBucketsForMonitor(null, MONITOR_A),
+      ).toHaveLength(0);
+    });
+  });
+});

package/Types/API/Hostname.ts

@@ -3,6 +3,8 @@ import BadDataException from "../Exception/BadDataException";
 import { JSONObject, ObjectType } from "../JSON";
 import Port from "../Port";
 import Typeof from "../Typeof";
+import HostAddressUtil from "../../Utils/HostAddressUtil";
+import IP from "../IP/IP";
 import { FindOperator } from "typeorm";
 
 /*
@@ -22,10 +24,26 @@ const HOST_REGEX: RegExp =
  */
 const USER_INFO_REGEX: RegExp = /^[^@/?#\s[\]]*$/;
 
-const IPV6_CHARS_REGEX: RegExp = /^[0-9a-fA-F:.]+$/;
-
 const PORT_REGEX: RegExp = /^\d{1,5}$/;
 
+/*
+ * The authority spellings of an IPv6 host: bracketed ("[::1]", "[::1]:8080")
+ * or bare. Two or more colons cannot be a "host:port", so every colon in a
+ * bare value belongs to the address itself.
+ *
+ * This only decides which SHAPE a value has. Whether what it holds is really
+ * an address is IP.isIP's job, and isValid below asks it -- the old code
+ * settled for a "[0-9a-fA-F:.]+" charset, which called "::::" and
+ * "1.2.3.4.5.6" valid hosts and then handed them to a socket.
+ */
+function isIPv6Authority(authority: string): boolean {
+  return authority.startsWith("[") || (authority.match(/:/g) || []).length > 1;
+}
+
+function isIPv6Address(value: string): boolean {
+  return Boolean(value) && IP.isIP(value) && new IP(value).isIPv6();
+}
+
 export default class Hostname extends DatabaseProperty {
   private _route: string = "";
   public get hostname(): string {
@@ -104,15 +122,15 @@ export default class Hostname extends DatabaseProperty {
       /^\[([0-9a-fA-F:.]+)\](?::(\d{1,5}))?$/,
     );
     if (bracketedIpv6Match) {
-      return true;
+      return isIPv6Address(bracketedIpv6Match[1] as string);
     }
 
     /*
      * Unbracketed IPv6 literal. Two or more colons cannot be a "host:port",
      * so the colons must be part of the address itself.
      */
-    if ((authority.match(/:/g) || []).length > 1) {
-      return IPV6_CHARS_REGEX.test(authority);
+    if (isIPv6Authority(authority)) {
+      return isIPv6Address(authority);
     }
 
     const colonIndex: number = authority.indexOf(":");
@@ -158,28 +176,57 @@ export default class Hostname extends DatabaseProperty {
     throw new BadDataException("Invalid JSON: " + JSON.stringify(json));
   }
 
+  /*
+   * The authority form. An IPv6 host is BRACKETED once a port is appended,
+   * because "2001:db8::1" + ":179" is not an ambiguous-looking string — it is
+   * "2001:db8::1:179", which net.isIP() accepts as a different, perfectly
+   * valid address. Anything that read this back (or showed it to an operator)
+   * was therefore pointed at a host nobody configured.
+   *
+   * Without a port the host is returned exactly as it is held, brackets and
+   * all. A bracketed value came from a URL authority and has to go back into
+   * one — dropping the brackets there would make URL.toString() emit
+   * "https://2001:db8::1/", which no URL parser accepts.
+   */
   public override toString(): string {
-    let hostname: string = this.hostname;
-
-    if (this.port) {
-      hostname += ":" + this.port.toString();
+    if (!this.port) {
+      return this.hostname;
     }
 
-    return hostname;
+    return HostAddressUtil.formatHostAndPort({
+      host: this.hostname,
+      port: this.port.toString(),
+    });
   }
 
+  /*
+   * Reads a stored host, which may carry a ":port".
+   *
+   * IPv6 literals are handed to fromAuthority instead of being split, because
+   * splitting on the first colon is meaningless for an address that is made
+   * of colons: "2001:518:2800:9::2" used to come back as host "2001" with
+   * port 518 — and because 518 is a legal port number NOTHING threw. A
+   * monitor saved from the dashboard therefore silently pointed at a host
+   * called "2001", and the address the operator typed was simply gone.
+   *
+   * DNS names and IPv4 literals keep the original behaviour exactly: neither
+   * can contain two colons, so neither can reach the new branch.
+   */
   public static fromString(hostname: string | Hostname): Hostname {
     if (hostname instanceof Hostname) {
       hostname = hostname.toString();
     }
 
-    if (hostname.includes(":")) {
-      return new Hostname(
-        hostname.split(":")[0] as string,
-        hostname.split(":")[1],
-      );
+    const value: string = (hostname || "").trim();
+
+    if (isIPv6Authority(value)) {
+      return Hostname.fromAuthority(value);
+    }
+
+    if (value.includes(":")) {
+      return new Hostname(value.split(":")[0] as string, value.split(":")[1]);
     }
-    return new Hostname(hostname);
+    return new Hostname(value);
   }
 
   /*