@truedat/df 8.13.5 → 8.13.7

package/src/templates/utils/__tests__/validateContentDateRestrictions.spec.js

@@ -0,0 +1,519 @@
+import { validateContent, validateDateRestrictions } from "../validateContent";
+
+const template = {
+  content: [
+    {
+      name: "dates",
+      fields: [
+        {
+          name: "fecha",
+          type: "date",
+          cardinality: "?",
+          restrictions: {
+            resolved: { min: "2026-01-01", max: "2026-12-31" },
+          },
+        },
+      ],
+    },
+  ],
+};
+
+const dateField = template.content[0].fields[0];
+const fieldValue = (value, origin = "user") => ({ value, origin });
+const dateContent = (value, origin) => ({ fecha: fieldValue(value, origin) });
+const dateError = (
+  field = "fecha",
+  values = dateField.restrictions.resolved,
+) => ({
+  error: "date out of range",
+  field,
+  values,
+});
+const templateWith = (fields) => ({ content: [{ name: "fields", fields }] });
+const tableField = {
+  name: "periodos",
+  type: "dynamic_table",
+  values: {
+    table_columns: [
+      { ...dateField, name: "fin" },
+      { name: "description", type: "string" },
+    ],
+  },
+};
+const tableTemplate = templateWith([tableField]);
+const row = (value, description = "original") => ({
+  fin: fieldValue(value),
+  description: fieldValue(description),
+});
+const tableContent = (rows) => ({ periodos: fieldValue(rows) });
+
+describe("validateContent date restrictions", () => {
+  it("blocks a complete value outside the published bounds", () => {
+    expect(
+      validateContent(template)({
+        fecha: { value: "2027-01-01", origin: "user" },
+      }),
+    ).toEqual([
+      {
+        error: "date out of range",
+        field: "fecha",
+        values: { min: "2026-01-01", max: "2026-12-31" },
+      },
+    ]);
+  });
+
+  it.each(["2026-01-01", "2026-12-31"])(
+    "accepts inclusive limit %s",
+    (value) => {
+      expect(
+        validateContent(template)({
+          fecha: { value, origin: "user" },
+        }),
+      ).toEqual([]);
+    },
+  );
+
+  it("validates creation when original content is explicitly undefined", () => {
+    expect(
+      validateContent(template, undefined)(dateContent("2027-01-01")),
+    ).toEqual([dateError()]);
+  });
+
+  it("exempts an unchanged out-of-range date", () => {
+    expect(
+      validateContent(
+        template,
+        dateContent("2027-01-01"),
+      )(dateContent("2027-01-01")),
+    ).toEqual([]);
+  });
+
+  it("validates a changed out-of-range date", () => {
+    expect(
+      validateContent(
+        template,
+        dateContent("2026-01-01"),
+      )(dateContent("2027-01-01")),
+    ).toEqual([dateError()]);
+  });
+
+  it("accepts a changed date within the bounds", () => {
+    expect(
+      validateContent(
+        template,
+        dateContent("2027-01-01"),
+      )(dateContent("2026-01-01")),
+    ).toEqual([]);
+  });
+
+  it("exempts an out-of-range date restored after an intermediate edit", () => {
+    const validate = validateContent(template, dateContent("2027-01-01"));
+    validate(dateContent("2028-01-01"));
+
+    expect(validate(dateContent("2027-01-01"))).toEqual([]);
+  });
+
+  it("ignores an origin-only change", () => {
+    expect(
+      validateContent(
+        template,
+        dateContent("2027-01-01", "system"),
+      )(dateContent("2027-01-01", "user")),
+    ).toEqual([]);
+  });
+
+  it("validates a date absent from the original content", () => {
+    expect(validateContent(template, {})(dateContent("2027-01-01"))).toEqual([
+      dateError(),
+    ]);
+  });
+
+  it.each([null, undefined, "", []])(
+    "preserves required validation for unchanged empty value %p",
+    (value) => {
+      const requiredTemplate = templateWith([
+        { ...dateField, cardinality: "1" },
+      ]);
+
+      expect(
+        validateContent(
+          requiredTemplate,
+          dateContent(value),
+        )(dateContent(value)),
+      ).toEqual([{ error: "missing required", field: "fecha" }]);
+    },
+  );
+
+  it("threads original content through the standalone date validator", () => {
+    const content = dateContent("2027-01-01");
+    const validations = [{ error: "existing", field: "other" }];
+
+    expect(
+      validateDateRestrictions(
+        [dateField],
+        dateContent("2027-01-01"),
+      )([validations, content]),
+    ).toEqual([validations, content]);
+  });
+
+  describe("multiple values", () => {
+    const multipleTemplate = templateWith([{ ...dateField, cardinality: "*" }]);
+
+    it("validates every value during creation", () => {
+      expect(
+        validateContent(multipleTemplate)(
+          dateContent(["2026-01-01", "2027-01-01"]),
+        ),
+      ).toEqual([dateError()]);
+    });
+
+    it("exempts a deeply equal array with a different reference", () => {
+      expect(
+        validateContent(
+          multipleTemplate,
+          dateContent([fieldValue("2027-01-01")]),
+        )(dateContent([fieldValue("2027-01-01")])),
+      ).toEqual([]);
+    });
+
+    it("ignores origin-only changes within array entries", () => {
+      expect(
+        validateContent(
+          multipleTemplate,
+          dateContent([fieldValue("2027-01-01", "system")]),
+        )(dateContent([fieldValue("2027-01-01", "user")])),
+      ).toEqual([]);
+    });
+
+    it.each([
+      ["2027-01-01", "2026-02-01"],
+      ["2027-01-01", "2026-01-01", "2026-02-01"],
+      ["2026-01-01", "2027-01-01"],
+      ["2027-01-01"],
+    ])("validates the entire modified array %p", (...values) => {
+      expect(
+        validateContent(
+          multipleTemplate,
+          dateContent(["2027-01-01", "2026-01-01"]),
+        )(dateContent(values)),
+      ).toEqual([dateError()]);
+    });
+
+    it("accepts removal of all values from an optional field", () => {
+      expect(
+        validateContent(
+          multipleTemplate,
+          dateContent(["2027-01-01"]),
+        )(dateContent([])),
+      ).toEqual([]);
+    });
+  });
+
+  describe("editing dynamic tables", () => {
+    it("exempts unchanged dates when an unrelated cell changes", () => {
+      expect(
+        validateContent(
+          tableTemplate,
+          tableContent([row("2027-01-01")]),
+        )(tableContent([row("2027-01-01", "edited")])),
+      ).toEqual([]);
+    });
+
+    it("validates only the changed date at its corresponding row", () => {
+      expect(
+        validateContent(
+          tableTemplate,
+          tableContent([row("2027-01-01"), row("2026-01-01")]),
+        )(tableContent([row("2027-01-01"), row("2028-01-01")])),
+      ).toEqual([dateError("periodos.1.fin")]);
+    });
+
+    it("validates a newly added row even when its date matches another row", () => {
+      expect(
+        validateContent(
+          tableTemplate,
+          tableContent([row("2027-01-01")]),
+        )(tableContent([row("2027-01-01"), row("2027-01-01")])),
+      ).toEqual([dateError("periodos.1.fin")]);
+    });
+
+    it("validates a newly added table", () => {
+      expect(
+        validateContent(tableTemplate, {})(tableContent([row("2027-01-01")])),
+      ).toEqual([dateError("periodos.0.fin")]);
+    });
+
+    it("does not reject dates from removed rows", () => {
+      expect(
+        validateContent(
+          tableTemplate,
+          tableContent([row("2027-01-01")]),
+        )(tableContent([])),
+      ).toEqual([]);
+    });
+
+    it("compares corresponding columns independently", () => {
+      const twoDates = templateWith([
+        {
+          ...tableField,
+          values: {
+            table_columns: [
+              { ...dateField, name: "fin" },
+              { ...dateField, name: "inicio" },
+            ],
+          },
+        },
+      ]);
+
+      expect(
+        validateContent(
+          twoDates,
+          tableContent([
+            {
+              fin: fieldValue("2027-01-01"),
+              inicio: fieldValue("2026-01-01"),
+            },
+          ]),
+        )(
+          tableContent([
+            {
+              fin: fieldValue("2027-01-01"),
+              inicio: fieldValue("2028-01-01"),
+            },
+          ]),
+        ),
+      ).toEqual([dateError("periodos.0.inicio")]);
+    });
+
+    it("recurses through nested dynamic-table cells", () => {
+      const nestedTemplate = templateWith([
+        {
+          ...tableField,
+          values: { table_columns: [{ ...tableField, name: "nested" }] },
+        },
+      ]);
+      const nestedContent = (date) =>
+        tableContent([
+          {
+            nested: fieldValue([row(date)]),
+          },
+        ]);
+
+      expect(
+        validateContent(
+          nestedTemplate,
+          nestedContent("2026-01-01"),
+        )(nestedContent("2027-01-01")),
+      ).toEqual([dateError("periodos.0.nested.0.fin")]);
+    });
+
+    it("preserves required validation for unchanged empty table cells", () => {
+      const requiredTable = templateWith([
+        {
+          ...tableField,
+          values: {
+            table_columns: [{ ...dateField, name: "fin", cardinality: "1" }],
+          },
+        },
+      ]);
+
+      expect(
+        validateContent(
+          requiredTable,
+          tableContent([row("")]),
+        )(tableContent([row("")])),
+      ).toEqual([{ error: "missing required", field: "periodos" }]);
+    });
+  });
+
+  describe("datetime", () => {
+    const bounds = { min: "2026-01-01T00:00", max: "2026-12-31T23:59" };
+    const datetimeTemplate = templateWith([
+      {
+        ...dateField,
+        type: "datetime",
+        restrictions: { resolved: bounds },
+      },
+    ]);
+
+    it("validates an out-of-range datetime during creation", () => {
+      expect(
+        validateContent(datetimeTemplate)(dateContent("2027-01-01T00:00")),
+      ).toEqual([dateError("fecha", bounds)]);
+    });
+
+    it("exempts an unchanged out-of-range datetime", () => {
+      expect(
+        validateContent(
+          datetimeTemplate,
+          dateContent("2027-01-01T00:00"),
+        )(dateContent("2027-01-01T00:00")),
+      ).toEqual([]);
+    });
+
+    it("validates a changed out-of-range datetime", () => {
+      expect(
+        validateContent(
+          datetimeTemplate,
+          dateContent("2027-01-01T00:00"),
+        )(dateContent("2027-01-01T00:01")),
+      ).toEqual([dateError("fecha", bounds)]);
+    });
+  });
+
+  describe("dynamic bounds", () => {
+    const dynamicTemplate = templateWith([
+      {
+        ...dateField,
+        restrictions: {
+          min_date: { mode: "dynamic", amount: 0, unit: "days" },
+        },
+      },
+    ]);
+
+    beforeEach(() => {
+      jest.useFakeTimers().setSystemTime(new Date("2026-10-21T12:00:00Z"));
+    });
+
+    afterEach(() => {
+      jest.useRealTimers();
+    });
+
+    it("validates creation against the current dynamic bounds", () => {
+      expect(
+        validateContent(dynamicTemplate)(dateContent("2026-10-20")),
+      ).toEqual([dateError("fecha", { min: "2026-10-21", max: undefined })]);
+    });
+
+    it("exempts an unchanged date that has aged outside dynamic bounds", () => {
+      expect(
+        validateContent(
+          dynamicTemplate,
+          dateContent("2026-10-20"),
+        )(dateContent("2026-10-20")),
+      ).toEqual([]);
+    });
+
+    it("validates a changed date against the current dynamic bounds", () => {
+      expect(
+        validateContent(
+          dynamicTemplate,
+          dateContent("2026-10-19"),
+        )(dateContent("2026-10-20")),
+      ).toEqual([dateError("fecha", { min: "2026-10-21", max: undefined })]);
+    });
+  });
+
+  it("does not reject partial keyboard input", () => {
+    expect(
+      validateContent(template)({
+        fecha: { value: "2026-0", origin: "user" },
+      }),
+    ).toEqual([]);
+  });
+
+  it.each(["2026-02-30", "2027-01-01T00:00:00Z", "2027-01-01T02:00:00+02:00"])(
+    "rejects complete invalid or out-of-range imported value %s",
+    (value) => {
+      expect(validateContent(template)({ fecha: fieldValue(value) })).toEqual([
+        value === "2026-02-30"
+          ? { error: "invalid date", field: "fecha" }
+          : dateError(
+              "fecha",
+              template.content[0].fields[0].restrictions.resolved,
+            ),
+      ]);
+    },
+  );
+
+  it("validates an invalid complete date in a dynamic-table cell", () => {
+    expect(
+      validateContent(tableTemplate)({
+        periodos: fieldValue([row("2026-02-30")]),
+      }),
+    ).toEqual([{ error: "invalid date", field: "periodos.0.fin" }]);
+  });
+
+  it("accepts a modified date whose seconds remain within its minute-level bound", () => {
+    const minuteTemplate = templateWith([
+      {
+        ...dateField,
+        type: "datetime",
+        restrictions: {
+          resolved: { min: null, max: "2026-12-31T23:59" },
+        },
+      },
+    ]);
+
+    expect(
+      validateContent(
+        minuteTemplate,
+        dateContent("2026-12-31T23:59"),
+      )(dateContent("2026-12-31T23:59:59Z")),
+    ).toEqual([]);
+  });
+
+  it("rejects a modified date-time with a sub-minute value past its maximum", () => {
+    const minuteTemplate = templateWith([
+      {
+        ...dateField,
+        type: "datetime",
+        restrictions: {
+          resolved: { min: null, max: "2026-12-31T23:59" },
+        },
+      },
+    ]);
+
+    expect(
+      validateContent(
+        minuteTemplate,
+        dateContent("2026-12-31T23:59"),
+      )(dateContent("2027-01-01T00:00:00Z")),
+    ).toEqual([dateError("fecha", { max: "2026-12-31T23:59" })]);
+  });
+
+  it("validates date columns in every dynamic-table row", () => {
+    const tableTemplate = {
+      content: [
+        {
+          name: "table",
+          fields: [
+            {
+              name: "periodos",
+              type: "dynamic_table",
+              values: {
+                table_columns: [
+                  {
+                    name: "fin",
+                    type: "date",
+                    restrictions: {
+                      resolved: { min: null, max: "2026-12-31" },
+                    },
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+    };
+
+    expect(
+      validateContent(tableTemplate)({
+        periodos: {
+          value: [
+            { fin: { value: "2026-12-31", origin: "user" } },
+            { fin: { value: "2027-01-01", origin: "user" } },
+          ],
+          origin: "user",
+        },
+      }),
+    ).toEqual([
+      {
+        error: "date out of range",
+        field: "periodos.1.fin",
+        values: { min: undefined, max: "2026-12-31" },
+      },
+    ]);
+  });
+});

package/src/templates/utils/applyTemplate.js

@@ -6,6 +6,7 @@ import { filterDomains } from "./filterDomains";
 import { filterFields } from "./filterFields";
 import { filterSwitches } from "./filterSwitches";
 import { filterValues } from "./filterValues";
+import { copyTableRowLineage } from "./originalTableRows";
 
 const isInformed = _.flow(
   _.cond([
@@ -80,32 +81,38 @@ export const applyTemplate =
   (template) =>
   (content, domainId = null) => {
     const templateContent = flattenFields(template);
-    return _.flow(
-      filterFields(templateContent),
-      filterValues(templateContent),
-      filterDepends(templateContent),
-      filterSwitches(templateContent),
-      (content) => filterDomains(templateContent)(content, domainId),
-      (content) => applyDefaults(templateContent)(content, domainId),
-      _.pickBy((value) => isInformed(value.value)),
-      (content) => applyTableFields(templateContent, content, domainId),
-    )(content);
+    return copyTableRowLineage(
+      content,
+      _.flow(
+        filterFields(templateContent),
+        filterValues(templateContent),
+        filterDepends(templateContent),
+        filterSwitches(templateContent),
+        (content) => filterDomains(templateContent)(content, domainId),
+        (content) => applyDefaults(templateContent)(content, domainId),
+        _.pickBy((value) => isInformed(value.value)),
+        (content) => applyTableFields(templateContent, content, domainId),
+      )(content),
+    );
   };
 
 export const applyTemplateWithoutDefaults =
   (template) =>
   (content, domainId = null) => {
     const templateContent = flattenFields(template);
-    return _.flow(
-      filterFields(templateContent),
-      filterValues(templateContent),
-      filterDepends(templateContent),
-      filterSwitches(templateContent),
-      (content) => filterDomains(templateContent)(content, domainId),
-      _.pickBy((value) => isInformed(value.value)),
-      (content) =>
-        applyTableFieldsWithoutDefaults(templateContent, content, domainId),
-    )(content);
+    return copyTableRowLineage(
+      content,
+      _.flow(
+        filterFields(templateContent),
+        filterValues(templateContent),
+        filterDepends(templateContent),
+        filterSwitches(templateContent),
+        (content) => filterDomains(templateContent)(content, domainId),
+        _.pickBy((value) => isInformed(value.value)),
+        (content) =>
+          applyTableFieldsWithoutDefaults(templateContent, content, domainId),
+      )(content),
+    );
   };
 
 export default applyTemplate;