@truedat/df 8.13.4 → 8.13.6

package/src/templates/utils/dateRestrictions.js

@@ -0,0 +1,497 @@
+const UNITS = ["days", "weeks", "months", "years"];
+const DATE_TYPES = ["date", "datetime"];
+const MS_IN_DAY = 24 * 60 * 60 * 1000;
+
+export const resolveRestrictions = (
+  restrictions,
+  fieldType,
+  now = new Date(),
+) => {
+  if (!DATE_TYPES.includes(fieldType)) return open();
+
+  const r = restrictions || {};
+  const range = effectiveBetween(r, now, fieldType);
+  const lows = [limitOf(r.min_date, now, fieldType, "min"), range.low].filter(
+    defined,
+  );
+  const highs = [limitOf(r.max_date, now, fieldType, "max"), range.high].filter(
+    defined,
+  );
+
+  return {
+    min: format(tightest(lows, "min"), fieldType),
+    max: format(tightest(highs, "max"), fieldType),
+  };
+};
+
+export const publishedBounds = (restrictions) => {
+  const resolved = restrictions && restrictions.resolved;
+  if (!resolved) return undefined;
+  return { min: resolved.min ?? undefined, max: resolved.max ?? undefined };
+};
+
+const open = () => ({ min: undefined, max: undefined });
+
+const defined = (value) => value !== null && value !== undefined;
+
+const limitOf = (side, now, fieldType, which) => {
+  if (!side || typeof side !== "object") return null;
+  if (side.mode === "static") return parseBound(side.value, which, fieldType);
+  if (side.mode === "dynamic") return shift(side, now, fieldType, which);
+  return null;
+};
+
+const effectiveBetween = (r, now, fieldType) => {
+  const between = r.between;
+
+  if (between && between.mode === "static") {
+    return {
+      low: parseBound(between.start, "min", fieldType),
+      high: parseBound(between.end, "max", fieldType),
+    };
+  }
+
+  if (between && between.mode === "dynamic") {
+    return {
+      low: shift(between.from, now, fieldType, "min", false),
+      high: shift(between.to, now, fieldType, "max", false),
+    };
+  }
+
+  const hasLegacy =
+    r.between_start !== undefined || r.between_end !== undefined;
+  if (!hasLegacy) return { low: null, high: null };
+
+  return {
+    low: parseBound(r.between_start, "min", fieldType),
+    high: parseBound(r.between_end, "max", fieldType),
+  };
+};
+
+const shift = (side, now, fieldType, which, invertPositiveMinimum = true) => {
+  const amount = toInteger(side.amount);
+  if (amount === null || !UNITS.includes(side.unit)) return null;
+  const anchor = fieldType === "datetime" ? localCalendarDate(now) : now;
+  const offset =
+    invertPositiveMinimum && which === "min" && amount > 0 ? -amount : amount;
+  const shifted = shiftFromNow(anchor, offset, side.unit, fieldType);
+
+  return fieldType === "datetime" && shifted instanceof Date
+    ? atDayBoundary(shifted, which)
+    : shifted;
+};
+
+const shiftFromNow = (now, amount, unit, fieldType) => {
+  switch (unit) {
+    case "days":
+      return addDays(now, amount, fieldType);
+    case "weeks":
+      return addDays(now, amount * 7, fieldType);
+    case "months":
+      return addMonths(now, amount, fieldType);
+    case "years":
+      return addMonths(now, amount * 12, fieldType);
+    default:
+      return null;
+  }
+};
+
+const addDays = (now, amount, fieldType) =>
+  fieldType === "date"
+    ? sameKind(new Date(now.getTime() + amount * MS_IN_DAY), "date")
+    : sameKind(new Date(now.getTime() + amount * MS_IN_DAY), "datetime");
+
+const addMonths = (now, amount, fieldType) => {
+  const year = now.getUTCFullYear();
+  const month = now.getUTCMonth();
+  const day = now.getUTCDate();
+
+  const zeroBased = month + amount;
+  const targetYear = year + Math.floor(zeroBased / 12);
+  const targetMonth = ((zeroBased % 12) + 12) % 12;
+  const lastDay = daysInMonth(targetYear, targetMonth);
+
+  return sameKind(
+    new Date(
+      Date.UTC(
+        targetYear,
+        targetMonth,
+        Math.min(day, lastDay),
+        now.getUTCHours(),
+        now.getUTCMinutes(),
+        now.getUTCSeconds(),
+        0,
+      ),
+    ),
+    fieldType,
+  );
+};
+
+const daysInMonth = (year, month) =>
+  new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
+
+const toInteger = (value) => {
+  if (Number.isInteger(value)) return value;
+  if (typeof value === "string" && /^-?\d+$/.test(value.trim())) {
+    return parseInt(value, 10);
+  }
+  return null;
+};
+
+const parseBound = (value, which, fieldType) => {
+  if (typeof value !== "string" || !value) return null;
+  if (fieldType !== "datetime" || value.includes("T")) {
+    return parse(value, fieldType);
+  }
+
+  return parseLocalDateTime(`${value}T${which === "max" ? "23:59" : "00:00"}`);
+};
+
+const parse = (value, fieldType) => {
+  if (typeof value !== "string" || !value) return null;
+
+  if (fieldType === "datetime") {
+    if (!value.includes("T")) return parseLocalDateTime(`${value}T00:00`);
+    return parseDateTime(value);
+  }
+
+  const ms = Date.parse(
+    value.includes("T") ? normalizeIso(value) : `${value}T00:00:00Z`,
+  );
+
+  if (Number.isNaN(ms)) return null;
+  return sameKind(new Date(ms), fieldType);
+};
+
+const parseDateTime = (value) => {
+  const zoned = /(?:Z|[+-]\d{2}:?\d{2})$/i.test(value);
+  if (zoned) {
+    const ms = Date.parse(normalizeIso(value));
+    return Number.isNaN(ms) ? null : utcCalendarDate(new Date(ms));
+  }
+
+  return parseLocalDateTime(value);
+};
+
+const parseLocalDateTime = (value) => {
+  const match =
+    /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::\d{2}(?:\.\d+)?)?$/.exec(
+      value,
+    );
+  if (!match) return null;
+
+  const [, year, month, day, hours, minutes] = match.map(Number);
+  if (
+    month < 1 ||
+    month > 12 ||
+    day < 1 ||
+    day > daysInMonth(year, month - 1) ||
+    hours > 23 ||
+    minutes > 59
+  ) {
+    return null;
+  }
+
+  return new Date(Date.UTC(year, month - 1, day, hours, minutes));
+};
+
+const localCalendarDate = (date) =>
+  new Date(
+    Date.UTC(
+      date.getFullYear(),
+      date.getMonth(),
+      date.getDate(),
+      date.getHours(),
+      date.getMinutes(),
+    ),
+  );
+
+const utcCalendarDate = (date) =>
+  new Date(
+    Date.UTC(
+      date.getUTCFullYear(),
+      date.getUTCMonth(),
+      date.getUTCDate(),
+      date.getUTCHours(),
+      date.getUTCMinutes(),
+    ),
+  );
+
+const atDayBoundary = (date, which) =>
+  new Date(
+    Date.UTC(
+      date.getUTCFullYear(),
+      date.getUTCMonth(),
+      date.getUTCDate(),
+      which === "max" ? 23 : 0,
+      which === "max" ? 59 : 0,
+    ),
+  );
+
+const normalizeIso = (iso) => {
+  const match = /^(.*T\d{2}:\d{2})(.*)$/.exec(iso);
+  if (!match) return iso;
+
+  const [, dateAndMinute, suffix] = match;
+  const remainder = suffix.replace(/(Z|[+-]\d{2}:?\d{2})$/i, "");
+  return /:\d{2}/.test(remainder) ? iso : `${dateAndMinute}:00${suffix}`;
+};
+
+const sameKind = (date, fieldType) =>
+  fieldType === "date"
+    ? new Date(
+        Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()),
+      )
+    : date;
+
+const tightest = (candidates, direction) => {
+  const usable = candidates.filter((c) => c instanceof Date);
+  if (usable.length === 0) return null;
+
+  return usable.reduce((acc, candidate) => {
+    if (acc === null) return candidate;
+    const cmp = candidate.getTime() - acc.getTime();
+    return direction === "min"
+      ? cmp > 0
+        ? candidate
+        : acc
+      : cmp < 0
+        ? candidate
+        : acc;
+  }, null);
+};
+
+const pad = (value) => String(value).padStart(2, "0");
+
+const format = (date, fieldType) => {
+  if (!(date instanceof Date)) return undefined;
+
+  const day = `${date.getUTCFullYear()}-${pad(date.getUTCMonth() + 1)}-${pad(date.getUTCDate())}`;
+  if (fieldType === "date") return day;
+
+  return `${day}T${pad(date.getUTCHours())}:${pad(date.getUTCMinutes())}`;
+};
+
+export const toInputBound = (value, side) => {
+  if (typeof value !== "string" || !value) return undefined;
+  if (value.includes("T")) return value.slice(0, 16);
+  return `${value}T${side === "max" ? "23:59" : "00:00"}`;
+};
+
+export const compareToLimits = (value, min, max) => {
+  if (typeof value !== "string" || !value) return "ok";
+  if (!min && !max) return "ok";
+
+  const parsedValue = parseIsoDateValue(value);
+  if (!parsedValue) {
+    return isPartialIsoDateInput(value) ? "ok" : "invalid_date";
+  }
+
+  const parsedMin = min ? parseIsoDateValue(min) : null;
+  const parsedMax = max ? parseIsoDateValue(max) : null;
+  const normalizedFor = (bound) =>
+    valueForPrecision(parsedValue, granularityOf(bound || min || max));
+  const minPrecision = granularityOf(min || max);
+  const maxPrecision = granularityOf(max || min);
+  const minValue = parsedMin && valueForPrecision(parsedMin, minPrecision);
+  const maxValue = parsedMax && valueForPrecision(parsedMax, maxPrecision);
+  const normalizedMin = normalizedFor(min);
+  const normalizedMax = normalizedFor(max);
+
+  if (parsedMin && normalizedMin < minValue) {
+    return "too_early";
+  }
+  if (parsedMax && normalizedMax > maxValue) {
+    return "too_late";
+  }
+  return "ok";
+};
+
+export const isWithinLimits = (value, min, max) =>
+  compareToLimits(value, min, max) === "ok";
+
+const granularityOf = (bound) =>
+  typeof bound === "string" && bound.includes("T") ? "minute" : "day";
+
+const ISO_DATE_VALUE =
+  /^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d+))?)?(Z|[+-]\d{2}:?\d{2})?)?$/i;
+
+const isPartialIsoDateInput = (value) => {
+  const partialDate = /^(\d{0,4})(?:-(\d{0,2})(?:-(\d{0,2}))?)?$/.exec(value);
+  if (partialDate) {
+    const [, yearString, monthString, dayString] = partialDate;
+    if (!monthString || monthString.length === 0) return true;
+    if (
+      (monthString.length === 1 && !/^[01]$/.test(monthString)) ||
+      (monthString.length === 2 &&
+        (Number(monthString) < 1 || Number(monthString) > 12))
+    ) {
+      return false;
+    }
+    if (dayString === undefined || dayString.length === 0) return true;
+    if (monthString.length !== 2 || yearString.length !== 4) return false;
+
+    const year = Number(yearString);
+    const month = Number(monthString);
+    const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+    const daysInMonth = [
+      31,
+      leap ? 29 : 28,
+      31,
+      30,
+      31,
+      30,
+      31,
+      31,
+      30,
+      31,
+      30,
+      31,
+    ];
+    const maxDay = daysInMonth[month - 1];
+    return dayString.length === 1
+      ? Number(dayString) <= 2 ||
+          (dayString === "3" && maxDay >= 30) ||
+          dayString === "0"
+      : Number(dayString) >= 1 && Number(dayString) <= maxDay;
+  }
+
+  const partialDateTime = /^(\d{4}-\d{2}-\d{2})T(.*)$/.exec(value);
+  if (!partialDateTime || !parseIsoDateValue(partialDateTime[1])) return false;
+
+  const partialTime =
+    /^(\d{0,2})(?::(\d{0,2})(?::(\d{0,2})(?:\.(\d*))?)?)?$/.exec(
+      partialDateTime[2],
+    );
+  if (!partialTime) return false;
+
+  const [, hour = "", minute, second] = partialTime;
+  const validComponent = (component, max, firstDigitMax) => {
+    if (component === undefined || component === "") return true;
+    if (component.length === 1) return Number(component) <= firstDigitMax;
+    return Number(component) <= max;
+  };
+
+  return (
+    validComponent(hour, 23, 2) &&
+    validComponent(minute, 59, 5) &&
+    validComponent(second, 59, 5)
+  );
+};
+
+const parseIsoDateValue = (value) => {
+  if (typeof value !== "string") return null;
+  const match = ISO_DATE_VALUE.exec(value);
+  if (!match) return null;
+
+  const [
+    ,
+    rawYear,
+    rawMonth,
+    rawDay,
+    rawHour,
+    rawMinute,
+    rawSecond,
+    fractionalSecond,
+    zone,
+  ] = match;
+  const year = Number(rawYear);
+  const month = Number(rawMonth);
+  const day = Number(rawDay);
+  const hour = rawHour === undefined ? 0 : Number(rawHour);
+  const minute = rawMinute === undefined ? 0 : Number(rawMinute);
+  const second = rawSecond === undefined ? 0 : Number(rawSecond);
+  const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+  const daysInMonth = [
+    31,
+    leap ? 29 : 28,
+    31,
+    30,
+    31,
+    30,
+    31,
+    31,
+    30,
+    31,
+    30,
+    31,
+  ];
+
+  if (
+    month < 1 ||
+    month > 12 ||
+    day < 1 ||
+    day > daysInMonth[month - 1] ||
+    hour > 23 ||
+    minute > 59 ||
+    second > 59
+  ) {
+    return null;
+  }
+
+  const offsetMatch = zone && /^[+-](\d{2}):?(\d{2})$/.exec(zone);
+  if (
+    offsetMatch &&
+    (Number(offsetMatch[1]) > 14 ||
+      Number(offsetMatch[2]) > 59 ||
+      (Number(offsetMatch[1]) === 14 && Number(offsetMatch[2]) !== 0))
+  ) {
+    return null;
+  }
+
+  const millisecond = fractionalSecond
+    ? Math.floor(Number(`0.${fractionalSecond}`) * 1000)
+    : 0;
+  const validDate = createUtcDate(
+    year,
+    month - 1,
+    day,
+    hour,
+    minute,
+    second,
+    millisecond,
+  );
+  if (offsetMatch) {
+    const offsetMinutes =
+      (Number(offsetMatch[1]) * 60 + Number(offsetMatch[2])) *
+      (zone[0] === "+" ? 1 : -1);
+    validDate.setTime(validDate.getTime() - offsetMinutes * 60 * 1000);
+  }
+
+  return validDate.getUTCFullYear() < 0 || validDate.getUTCFullYear() > 9999
+    ? null
+    : { date: validDate };
+};
+
+const createUtcDate = (year, month, day, hour, minute, second, millisecond) => {
+  const date = new Date(0);
+  date.setUTCFullYear(year, month, day);
+  date.setUTCHours(hour, minute, second, millisecond);
+  return date;
+};
+
+const valueForPrecision = ({ date }, precision) =>
+  precision === "minute"
+    ? Math.floor(date.getTime() / (60 * 1000))
+    : date.getUTCFullYear() * 10000 +
+      (date.getUTCMonth() + 1) * 100 +
+      date.getUTCDate();
+
+export const checkValuesAgainstBounds = (value, { min, max }) => {
+  const candidates =
+    value === null || value === undefined
+      ? []
+      : (Array.isArray(value) ? value : [value]).map(unwrap);
+
+  const verdicts = candidates.map((candidate) =>
+    compareToLimits(candidate, min, max),
+  );
+  return (
+    verdicts.find((verdict) => verdict === "invalid_date") ||
+    verdicts.find((verdict) => verdict !== "ok") ||
+    "ok"
+  );
+};
+
+const unwrap = (item) =>
+  item && typeof item === "object" && !Array.isArray(item) ? item.value : item;

package/src/templates/utils/dateValueUnchanged.js

@@ -0,0 +1,12 @@
+import _ from "lodash/fp";
+
+const withoutOrigin = (value) =>
+  _.isArray(value)
+    ? _.map(withoutOrigin)(value)
+    : _.isPlainObject(value)
+      ? _.flow(_.omit("origin"), _.mapValues(withoutOrigin))(value)
+      : value;
+
+export const dateValueUnchanged = (value, originalField) =>
+  !_.isNil(originalField) &&
+  _.isEqual(withoutOrigin(value), withoutOrigin(originalField.value));

package/src/templates/utils/originalTableRows.js

@@ -0,0 +1,41 @@
+const rowBaselines = new WeakMap();
+const newRow = Symbol("new table row");
+
+export const markNewRow = (row) => {
+  rowBaselines.set(row, new Map([[newRow, true]]));
+  return row;
+};
+
+export const getOriginalRow = (row, index, originalRows) => {
+  if (row === null || typeof row !== "object") return undefined;
+  const baselines = rowBaselines.get(row);
+  const original = baselines?.has(newRow)
+    ? undefined
+    : baselines?.has(originalRows)
+      ? baselines.get(originalRows)
+      : originalRows?.includes(row)
+        ? row
+        : originalRows?.[index];
+  originalRows &&
+    rowBaselines.set(
+      row,
+      new Map([...(baselines || []), [originalRows, original]]),
+    );
+  return original;
+};
+
+export const copyRow = (source, output) => {
+  const baselines = rowBaselines.get(source);
+  baselines && rowBaselines.set(output, new Map(baselines));
+  return output;
+};
+
+export const copyTableRowLineage = (source, output) => {
+  const objects = source && output && typeof output === "object";
+  objects && copyRow(source, output);
+  objects &&
+    Object.keys(output).forEach((key) =>
+      copyTableRowLineage(source[key], output[key]),
+    );
+  return output;
+};

package/src/templates/utils/validateContent.js

@@ -1,5 +1,12 @@
 import _ from "lodash/fp";
 import { flattenFields } from "./flattenFields";
+import { getOriginalRow } from "./originalTableRows";
+import { dateValueUnchanged } from "./dateValueUnchanged";
+import {
+  publishedBounds,
+  checkValuesAgainstBounds,
+  resolveRestrictions,
+} from "./dateRestrictions";
 
 const fieldIsHiddenVerifier =
   (content) =>
@@ -27,15 +34,19 @@ const isTableRequired = (field, content) => {
   return false;
 };
 
-const validateTemplateContent = (schema, content) => {
+const validateTemplateContent = (schema, content, originalContent) => {
   const fieldIsHidden = fieldIsHiddenVerifier(content);
   const templateContent = _.reject(fieldIsHidden)(schema);
-  return _.flow(validateRequired(templateContent), _.head)([[], content]);
+  return _.flow(
+    validateRequired(templateContent),
+    validateDateRestrictions(templateContent, originalContent),
+    _.head,
+  )([[], content]);
 };
 
-export const validateContent = (template) => (content) => {
+export const validateContent = (template, originalContent) => (content) => {
   const schema = flattenFields(template);
-  return validateTemplateContent(schema, content);
+  return validateTemplateContent(schema, content, originalContent);
 };
 
 const isEmptyValue = (value) =>
@@ -69,6 +80,66 @@ export const validateRequired =
     return [[...validations, ...newValidations], content];
   };
 
+export const validateDateRestrictions =
+  (templateContent, originalContent) =>
+  ([validations, content]) => {
+    const validateDate = (field, fieldContent, originalFieldContent, path) => {
+      const unchanged = dateValueUnchanged(
+        fieldContent?.value,
+        originalFieldContent,
+      );
+      const bounds =
+        publishedBounds(field?.restrictions) ||
+        resolveRestrictions(field?.restrictions, field?.type);
+      if (
+        unchanged ||
+        !bounds ||
+        !["date", "datetime"].includes(field?.type) ||
+        (!bounds.min && !bounds.max)
+      ) {
+        return [];
+      }
+      const verdict = checkValuesAgainstBounds(fieldContent?.value, bounds);
+      if (verdict === "invalid_date") {
+        return [{ error: "invalid date", field: path }];
+      }
+      return verdict === "ok"
+        ? []
+        : [{ error: "date out of range", field: path, values: bounds }];
+    };
+
+    const validateField = (
+      field,
+      fieldContent,
+      originalFieldContent,
+      path = field?.name,
+    ) =>
+      field?.type === "dynamic_table"
+        ? (fieldContent?.value || []).flatMap((row, rowIndex) =>
+            (field?.values?.table_columns || []).flatMap((column) =>
+              validateField(
+                column,
+                row?.[column.name],
+                getOriginalRow(row, rowIndex, originalFieldContent?.value)?.[
+                  column.name
+                ],
+                `${path}.${rowIndex}.${column.name}`,
+              ),
+            ),
+          )
+        : validateDate(field, fieldContent, originalFieldContent, path);
+
+    const newValidations = templateContent.flatMap((field) =>
+      validateField(
+        field,
+        content?.[field?.name],
+        originalContent?.[field?.name],
+      ),
+    );
+
+    return [[...validations, ...newValidations], content];
+  };
+
 export const dependentRequired = (field, content) => {
   if (_.has("mandatory")(field)) {
     const on = field?.mandatory?.on;