@zauru-sdk/common 6.11.0 → 6.11.1

package/dist/esm/providerRestrictions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkProviderRestrictionValue = exports.validateProviderRestrictionInput = exports.matchReceptionTypeCode = exports.isRestrictionValueAllowed = exports.resolveAllowedRestrictionValues = exports.filterActiveProviderRestrictions = exports.isRestrictionActiveOnDate = exports.restrictionHasDateRange = exports.normalizeProviderRestrictionValues = exports.isProviderRestrictionMode = exports.formatRestrictionTypeValue = exports.normalizeRestrictionValue = exports.PROVIDER_ITEM_RESTRICTIONS_TABLE_VAR = exports.PROVIDER_TYPE_RESTRICTIONS_TABLE_VAR = void 0;
+exports.checkProviderRestrictionValue = exports.validateProviderRestrictionInput = exports.restrictionLeavesNoAllowedValues = exports.sampleDatesForRestrictionRules = exports.matchReceptionTypeCode = exports.isRestrictionValueAllowed = exports.resolveAllowedRestrictionValues = exports.filterActiveProviderRestrictions = exports.isRestrictionActiveOnDate = exports.restrictionHasDateRange = exports.normalizeProviderRestrictionValues = exports.isProviderRestrictionMode = exports.formatRestrictionTypeValue = exports.normalizeRestrictionValue = exports.PROVIDER_ITEM_RESTRICTIONS_TABLE_VAR = exports.PROVIDER_TYPE_RESTRICTIONS_TABLE_VAR = void 0;
 const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 exports.PROVIDER_TYPE_RESTRICTIONS_TABLE_VAR = "ctl_calidad_admin_restricciones_tipos_proveedor_web_app_table_id";
 exports.PROVIDER_ITEM_RESTRICTIONS_TABLE_VAR = "ctl_calidad_admin_restricciones_verduras_proveedor_web_app_table_id";
@@ -119,7 +119,47 @@ const matchReceptionTypeCode = (formValue, types) => {
     return wanted;
 };
 exports.matchReceptionTypeCode = matchReceptionTypeCode;
-const validateProviderRestrictionInput = (input) => {
+const shiftYmd = (ymd, days) => {
+    const [year, month, day] = ymd.split("-").map(Number);
+    const utc = new Date(Date.UTC(year, month - 1, day + days));
+    const nextYear = utc.getUTCFullYear();
+    const nextMonth = String(utc.getUTCMonth() + 1).padStart(2, "0");
+    const nextDay = String(utc.getUTCDate()).padStart(2, "0");
+    return `${nextYear}-${nextMonth}-${nextDay}`;
+};
+const sampleDatesForRestrictionRules = (rules) => {
+    const dates = new Set(["1970-01-01", "2999-12-31"]);
+    for (const rule of rules) {
+        const start = (0, exports.normalizeRestrictionValue)(rule.start_date);
+        const end = (0, exports.normalizeRestrictionValue)(rule.end_date);
+        if (DATE_RE.test(start)) {
+            dates.add(start);
+            dates.add(shiftYmd(start, -1));
+        }
+        if (DATE_RE.test(end)) {
+            dates.add(end);
+            dates.add(shiftYmd(end, 1));
+        }
+    }
+    return [...dates].sort();
+};
+exports.sampleDatesForRestrictionRules = sampleDatesForRestrictionRules;
+const restrictionLeavesNoAllowedValues = (input) => {
+    const universe = input.universe
+        .map(exports.normalizeRestrictionValue)
+        .filter(Boolean);
+    if (universe.length === 0) {
+        return false;
+    }
+    return (0, exports.sampleDatesForRestrictionRules)(input.rules ?? []).some((date) => (0, exports.resolveAllowedRestrictionValues)({
+        payeeId: input.payeeId,
+        date,
+        rules: input.rules,
+        universe,
+    }).length === 0);
+};
+exports.restrictionLeavesNoAllowedValues = restrictionLeavesNoAllowedValues;
+const validateProviderRestrictionInput = (input, options) => {
     const errors = [];
     if (!Number(input.payee_id) || Number(input.payee_id) < 1) {
         errors.push({ field: "payee_id", message: "Seleccione un proveedor." });
@@ -166,6 +206,35 @@ const validateProviderRestrictionInput = (input) => {
             });
         }
     }
+    const universe = (options?.universe ?? [])
+        .map(exports.normalizeRestrictionValue)
+        .filter(Boolean);
+    if (universe.length > 0 &&
+        Number(input.payee_id) > 0 &&
+        (0, exports.isProviderRestrictionMode)(input.mode) &&
+        (0, exports.normalizeProviderRestrictionValues)(input.values).length > 0) {
+        const proposed = {
+            payee_id: Number(input.payee_id),
+            mode: input.mode,
+            values: (0, exports.normalizeProviderRestrictionValues)(input.values),
+            start_date: start,
+            end_date: end,
+            motivo: (0, exports.normalizeRestrictionValue)(input.motivo),
+        };
+        const otherRules = (options?.otherRules ?? []).filter((rule) => Number(rule.payee_id) === Number(input.payee_id) &&
+            !(0, exports.normalizeRestrictionValue)(rule.fechaEliminacion));
+        if ((0, exports.restrictionLeavesNoAllowedValues)({
+            payeeId: Number(input.payee_id),
+            rules: [...otherRules, proposed],
+            universe,
+        })) {
+            const noun = (0, exports.normalizeRestrictionValue)(options?.valueNoun) || "opciones";
+            errors.push({
+                field: "values",
+                message: `Esta regla dejaría al proveedor sin ${noun} para escoger. Debe quedar al menos uno.`,
+            });
+        }
+    }
     return errors;
 };
 exports.validateProviderRestrictionInput = validateProviderRestrictionInput;

package/dist/providerRestrictions.d.ts

@@ -39,7 +39,18 @@ export type ProviderRestrictionInputError = {
     field: string;
     message: string;
 };
-export declare const validateProviderRestrictionInput: (input: ProviderRestrictionInput) => ProviderRestrictionInputError[];
+export type ValidateProviderRestrictionOptions = {
+    universe?: Array<string | number>;
+    otherRules?: ProviderRestrictionRule[];
+    valueNoun?: string;
+};
+export declare const sampleDatesForRestrictionRules: (rules: Array<Pick<ProviderRestrictionRule, "start_date" | "end_date">>) => string[];
+export declare const restrictionLeavesNoAllowedValues: (input: {
+    payeeId: number;
+    rules: ProviderRestrictionRule[] | undefined;
+    universe: Array<string | number>;
+}) => boolean;
+export declare const validateProviderRestrictionInput: (input: ProviderRestrictionInput, options?: ValidateProviderRestrictionOptions) => ProviderRestrictionInputError[];
 export declare const checkProviderRestrictionValue: (input: {
     payeeId: number;
     date: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zauru-sdk/common",
-  "version": "6.11.0",
+  "version": "6.11.1",
   "description": "Funciones de uso común en el desarrollo de webapps en Zauru",
   "main": "./dist/esm/index.js",
   "module": "./dist/esm/index.js",
@@ -26,5 +26,5 @@
     "moment": "^2.30.1",
     "moment-timezone": "^0.5.45"
   },
-  "gitHead": "d8141f1d30edee6edb8d2777d0e12e2f4f1b2726"
+  "gitHead": "04f79cf77f767191f4be6358d9b23a3a0f1641b0"
 }

package/src/providerRestrictions.test.ts

@@ -8,6 +8,7 @@ import {
   isRestrictionValueAllowed,
   matchReceptionTypeCode,
   resolveAllowedRestrictionValues,
+  restrictionLeavesNoAllowedValues,
   validateProviderRestrictionInput,
 } from "./providerRestrictions.js";
 
@@ -274,4 +275,86 @@ describe("validateProviderRestrictionInput", () => {
       true,
     );
   });
+
+  it("When exclude removes every value in the universe, it should reject it", () => {
+    const errors = validateProviderRestrictionInput(
+      {
+        payee_id: 1,
+        mode: "exclude",
+        values: ["N", "1"],
+      },
+      { universe: ["N", "1"], valueNoun: "tipos de recepción" },
+    );
+    assert.equal(
+      errors.some((error) => error.message.includes("sin tipos de recepción")),
+      true,
+    );
+  });
+
+  it("When exclude leaves at least one value, it should allow it", () => {
+    const errors = validateProviderRestrictionInput(
+      {
+        payee_id: 1,
+        mode: "exclude",
+        values: ["1"],
+      },
+      { universe: ["N", "1"] },
+    );
+    assert.deepEqual(errors, []);
+  });
+
+  it("When an overlapping exclude would empty an include, it should reject it", () => {
+    const errors = validateProviderRestrictionInput(
+      {
+        payee_id: 10,
+        mode: "exclude",
+        values: ["Normal"],
+        start_date: "2026-10-27",
+        end_date: "2026-11-02",
+        motivo: "Auditoría",
+      },
+      {
+        universe: ["Normal", "Certificado 1"],
+        otherRules: [
+          rule({
+            payee_id: 10,
+            mode: "include",
+            values: ["Normal"],
+          }),
+        ],
+      },
+    );
+    assert.equal(
+      errors.some((error) => error.field === "values"),
+      true,
+    );
+  });
+});
+
+describe("restrictionLeavesNoAllowedValues", () => {
+  it("When two dated excludes only empty the overlap, it should detect that day", () => {
+    assert.equal(
+      restrictionLeavesNoAllowedValues({
+        payeeId: 3,
+        universe: ["A", "B"],
+        rules: [
+          rule({
+            payee_id: 3,
+            mode: "exclude",
+            values: ["A"],
+            start_date: "2026-10-01",
+            end_date: "2026-10-20",
+          }),
+          rule({
+            payee_id: 3,
+            mode: "exclude",
+            values: ["B"],
+            start_date: "2026-10-10",
+            end_date: "2026-10-15",
+          }),
+        ],
+      }),
+      true,
+    );
+  });
 });

package/src/providerRestrictions.ts

@@ -196,8 +196,65 @@ export type ProviderRestrictionInputError = {
   message: string;
 };
 
+export type ValidateProviderRestrictionOptions = {
+  universe?: Array<string | number>;
+  otherRules?: ProviderRestrictionRule[];
+  valueNoun?: string;
+};
+
+const shiftYmd = (ymd: string, days: number): string => {
+  const [year, month, day] = ymd.split("-").map(Number);
+  const utc = new Date(Date.UTC(year, month - 1, day + days));
+  const nextYear = utc.getUTCFullYear();
+  const nextMonth = String(utc.getUTCMonth() + 1).padStart(2, "0");
+  const nextDay = String(utc.getUTCDate()).padStart(2, "0");
+  return `${nextYear}-${nextMonth}-${nextDay}`;
+};
+
+export const sampleDatesForRestrictionRules = (
+  rules: Array<Pick<ProviderRestrictionRule, "start_date" | "end_date">>,
+): string[] => {
+  const dates = new Set<string>(["1970-01-01", "2999-12-31"]);
+  for (const rule of rules) {
+    const start = normalizeRestrictionValue(rule.start_date);
+    const end = normalizeRestrictionValue(rule.end_date);
+    if (DATE_RE.test(start)) {
+      dates.add(start);
+      dates.add(shiftYmd(start, -1));
+    }
+    if (DATE_RE.test(end)) {
+      dates.add(end);
+      dates.add(shiftYmd(end, 1));
+    }
+  }
+  return [...dates].sort();
+};
+
+export const restrictionLeavesNoAllowedValues = (input: {
+  payeeId: number;
+  rules: ProviderRestrictionRule[] | undefined;
+  universe: Array<string | number>;
+}): boolean => {
+  const universe = input.universe
+    .map(normalizeRestrictionValue)
+    .filter(Boolean);
+  if (universe.length === 0) {
+    return false;
+  }
+  return sampleDatesForRestrictionRules(input.rules ?? []).some(
+    (date) =>
+      resolveAllowedRestrictionValues({
+        payeeId: input.payeeId,
+        date,
+        rules: input.rules,
+        universe,
+      }).length === 0,
+  );
+};
+
 export const validateProviderRestrictionInput = (
   input: ProviderRestrictionInput,
+  options?: ValidateProviderRestrictionOptions,
 ): ProviderRestrictionInputError[] => {
   const errors: ProviderRestrictionInputError[] = [];
   if (!Number(input.payee_id) || Number(input.payee_id) < 1) {
@@ -245,6 +302,44 @@ export const validateProviderRestrictionInput = (
     }
   }
 
+  const universe = (options?.universe ?? [])
+    .map(normalizeRestrictionValue)
+    .filter(Boolean);
+  if (
+    universe.length > 0 &&
+    Number(input.payee_id) > 0 &&
+    isProviderRestrictionMode(input.mode) &&
+    normalizeProviderRestrictionValues(input.values).length > 0
+  ) {
+    const proposed: ProviderRestrictionRule = {
+      payee_id: Number(input.payee_id),
+      mode: input.mode,
+      values: normalizeProviderRestrictionValues(input.values),
+      start_date: start,
+      end_date: end,
+      motivo: normalizeRestrictionValue(input.motivo),
+    };
+    const otherRules = (options?.otherRules ?? []).filter(
+      (rule) =>
+        Number(rule.payee_id) === Number(input.payee_id) &&
+        !normalizeRestrictionValue(rule.fechaEliminacion),
+    );
+    if (
+      restrictionLeavesNoAllowedValues({
+        payeeId: Number(input.payee_id),
+        rules: [...otherRules, proposed],
+        universe,
+      })
+    ) {
+      const noun =
+        normalizeRestrictionValue(options?.valueNoun) || "opciones";
+      errors.push({
+        field: "values",
+        message: `Esta regla dejaría al proveedor sin ${noun} para escoger. Debe quedar al menos uno.`,
+      });
+    }
+  }
+
   return errors;
 };