fix: backtrack on invalid Date construction in Time parser

Author: ClaudiuCeia

deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@claudiu-ceia/ts-duckling",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "exports": {
     ".": "./mod.ts"
   },

src/Time.ts

@@ -18,6 +18,7 @@ import {
 import type { Parser } from "@claudiu-ceia/combine";
 import { __, dot, nonWord } from "./common.ts";
 import { ent } from "./Entity.ts";
+import { safe } from "./guard.ts";
 import type { Entity } from "./Entity.ts";
 import { fuzzyCase } from "./parsers.ts";
 import { Quantity, type QuantityEntity } from "./Quantity.ts";
@@ -376,7 +377,7 @@ export const Time: TimeLanguage = createLanguage<TimeLanguage>({
     return any(str("/"), str(" "), str("-"), str("."));
   },
   PartialDateMonthYear(s) {
-    return map(
+    return safe(map(
       any(
         seq(s.NumericMonth, s.DateSeparator, s.Year),
         seq(s.LiteralMonth, s.DateSeparator, s.Year),
@@ -393,7 +394,7 @@ export const Time: TimeLanguage = createLanguage<TimeLanguage>({
           a,
         );
       },
-    );
+    ), "valid date");
   },
   QualifiedDay(s) {
     return map(
@@ -434,7 +435,7 @@ export const Time: TimeLanguage = createLanguage<TimeLanguage>({
     );
   },
   PartialDateDayMonth(s) {
-    return map(
+    return safe(map(
       seq(s.QualifiedDay, optional(__(str("of"))), s.LiteralMonth),
       ([day, _of, month], b, a) => {
         const year = new Date().getFullYear();
@@ -447,28 +448,28 @@ export const Time: TimeLanguage = createLanguage<TimeLanguage>({
           a,
         );
       },
-    );
+    ), "valid date");
   },
   FullDate(s) {
     return any(
-      map(
+      safe(map(
         seq(s.PartialDateDayMonth, space(), s.Year),
         ([partialDayMonth, _sp, year], b, a) => {
           const original = partialDayMonth.value.when;
           if (typeof original !== "string") {
             throw new Error(`
-                  Unexpected partial date match:
-                  ${JSON.stringify(partialDayMonth)}
-                `);
+              Unexpected partial date match:
+              ${JSON.stringify(partialDayMonth)}
+            `);
           }
 
           const date = new Date(original);
           date.setFullYear(year);
 
           return time({ when: date.toISOString(), grain: "day" }, b, a);
         },
-      ),
-      map(
+      ), "valid date"),
+      safe(map(
         any(
           seq(
             s.Day,
@@ -509,7 +510,7 @@ export const Time: TimeLanguage = createLanguage<TimeLanguage>({
             a,
           );
         },
-      ),
+      ), "valid date"),
     );
   },
   PartialDateMonthYearEra(s) {
@@ -581,7 +582,7 @@ export const Time: TimeLanguage = createLanguage<TimeLanguage>({
         s.GrainQuantity,
         s.UnspecifiedGrainAmount,
         s.YearEra,
-        map(s.LiteralMonth, (month, b, a) => {
+        safe(map(s.LiteralMonth, (month, b, a) => {
           const year = new Date().getFullYear();
           return time(
             {
@@ -591,7 +592,7 @@ export const Time: TimeLanguage = createLanguage<TimeLanguage>({
             b,
             a,
           );
-        }),
+        }), "valid date"),
       ),
     );
   },

src/guard.ts

@@ -12,3 +12,17 @@ export const guard = <T>(
     return pred(res.value) ? res : failure(ctx, expected);
   };
 };
+
+// Catch exceptions thrown during parsing and convert them to failures.
+export const safe = <T>(
+  p: Parser<T>,
+  expected = "safe",
+): Parser<T> => {
+  return (ctx) => {
+    try {
+      return p(ctx);
+    } catch {
+      return failure(ctx, expected);
+    }
+  };
+};

tests/Time.test.ts

@@ -411,3 +411,42 @@ Deno.test("Circa time", () => {
     },
   ]);
 });
+Deno.test("FullDate: invalid date backtracks instead of throwing", () => {
+  // 31st of February is not a real date — should not throw
+  const res = Duckling([Time.parser]).extract("On 31/02/2024 something happened");
+  // Should not contain an entity for this invalid date
+  for (const entity of res) {
+    if (entity.kind === "time" && typeof entity.value.when === "string") {
+      assertEquals(entity.value.when !== "Invalid Date", true,
+        `Should not produce Invalid Date, got entity: ${JSON.stringify(entity)}`);
+    }
+  }
+});
+
+Deno.test("FullDate: valid date still parses correctly", () => {
+  const res = Duckling([Time.parser]).extract("On 15/06/2024 we met.");
+  const dates = res.filter((e) => e.kind === "time");
+  assertEquals(dates.length >= 1, true, "Should find at least one time entity");
+  const date = dates[0];
+  assertEquals(typeof date.value.when, "string");
+  assertEquals((date.value.when as string).includes("Invalid"), false);
+});
+
+Deno.test("FullDate: does not crash on nonsense date-like input", () => {
+  // Should not throw, regardless of what entities are produced
+  const inputs = [
+    "99/99/9999 is not a date",
+    "Meeting on 32-13-2025 maybe",
+    "Date: 00.00.0000 test",
+  ];
+  for (const input of inputs) {
+    const res = Duckling([Time.parser]).extract(input);
+    // Just verify it doesn't throw and doesn't produce "Invalid Date"
+    for (const entity of res) {
+      if (entity.kind === "time" && typeof entity.value.when === "string") {
+        assertEquals(entity.value.when !== "Invalid Date", true,
+          `Should not produce Invalid Date for "${input}", got: ${JSON.stringify(entity)}`);
+      }
+    }
+  }
+});

tests/guard.test.ts

@@ -0,0 +1,73 @@
+import { assertEquals } from "@std/assert";
+import { map, str } from "@claudiu-ceia/combine";
+import { guard, safe } from "../src/guard.ts";
+
+Deno.test("guard: passes when predicate returns true", () => {
+  const p = guard(str("abc"), (v) => v === "abc", "expected abc");
+  const res = p({ text: "abc", index: 0 });
+  assertEquals(res.success, true);
+  if (res.success) assertEquals(res.value, "abc");
+});
+
+Deno.test("guard: fails when predicate returns false", () => {
+  const p = guard(str("abc"), () => false, "rejected");
+  const res = p({ text: "abc", index: 0 });
+  assertEquals(res.success, false);
+  if (!res.success) assertEquals(res.expected, "rejected");
+});
+
+Deno.test("guard: propagates inner parser failure", () => {
+  const p = guard(str("abc"), () => true, "guard");
+  const res = p({ text: "xyz", index: 0 });
+  assertEquals(res.success, false);
+});
+
+Deno.test("guard: does not consume input on predicate failure", () => {
+  const p = guard(str("abc"), () => false, "rejected");
+  const res = p({ text: "abcdef", index: 0 });
+  assertEquals(res.success, false);
+  if (!res.success) assertEquals(res.ctx.index, 0);
+});
+
+Deno.test("safe: passes through successful parse", () => {
+  const p = safe(str("ok"), "safe");
+  const res = p({ text: "ok", index: 0 });
+  assertEquals(res.success, true);
+  if (res.success) assertEquals(res.value, "ok");
+});
+
+Deno.test("safe: passes through normal parse failure", () => {
+  const p = safe(str("ok"), "safe");
+  const res = p({ text: "no", index: 0 });
+  assertEquals(res.success, false);
+});
+
+Deno.test("safe: catches thrown exception and returns failure", () => {
+  const throwing = map(str("boom"), () => {
+    throw new Error("kaboom");
+  });
+  const p = safe(throwing, "caught");
+  const res = p({ text: "boom", index: 0 });
+  assertEquals(res.success, false);
+  if (!res.success) assertEquals(res.expected, "caught");
+});
+
+Deno.test("safe: does not consume input when exception is caught", () => {
+  const throwing = map(str("boom"), () => {
+    throw new Error("kaboom");
+  });
+  const p = safe(throwing, "caught");
+  const res = p({ text: "boomstuff", index: 0 });
+  assertEquals(res.success, false);
+  if (!res.success) assertEquals(res.ctx.index, 0);
+});
+
+Deno.test("safe: catches invalid Date toISOString", () => {
+  const dateParser = map(str("bad-date"), () => {
+    return new Date("not-a-date").toISOString();
+  });
+  const p = safe(dateParser, "valid date");
+  const res = p({ text: "bad-date", index: 0 });
+  assertEquals(res.success, false);
+  if (!res.success) assertEquals(res.expected, "valid date");
+});