@zauru-sdk/common 6.11.0 → 6.12.0

package/CHANGELOG.md

@@ -3,6 +3,23 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [6.12.0](https://github.com/intuitiva/zauru-typescript-sdk/compare/@zauru-sdk/common@6.10.1...@zauru-sdk/common@6.12.0) (2026-10-26)
+
+
+### Bug Fixes
+
+* rechazar restricciones que dejan al proveedor sin opciones ([24e6609](https://github.com/intuitiva/zauru-typescript-sdk/commit/24e6609b9cbf1498bec52bbeae9cd52a57945b45))
+
+
+### Features
+
+* agregar matriz de restricciones de recepción ([11a07b0](https://github.com/intuitiva/zauru-typescript-sdk/commit/11a07b04aa71dd6a38b79f10c4209d08e8f7607c))
+* motor de restricciones de tipos y verduras por proveedor ([ea09fd6](https://github.com/intuitiva/zauru-typescript-sdk/commit/ea09fd6a4cbed61fc29640baf1bc2b0b78db18da))
+
+
+
+
+
 # [6.11.0](https://github.com/intuitiva/zauru-typescript-sdk/compare/@zauru-sdk/common@6.10.1...@zauru-sdk/common@6.11.0) (2026-10-23)
 
 

package/dist/esm/index.js

@@ -19,4 +19,5 @@ __exportStar(require("./gtZones.js"), exports);
 __exportStar(require("./httpClientPolicy.js"), exports);
 __exportStar(require("./oauthErrors.js"), exports);
 __exportStar(require("./providerRestrictions.js"), exports);
+__exportStar(require("./providerReceptionMatrix.js"), exports);
 __exportStar(require("./rejectionPercentageAdjustment.js"), exports);

package/dist/esm/providerReceptionMatrix.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateProviderReceptionMatrix = exports.validateProviderReceptionException = exports.providerReceptionMatrixLeavesNoAllowedCombination = exports.resolveAllowedProviderReceptionTypes = exports.resolveAllowedProviderReceptionItems = exports.PROVIDER_RECEPTION_EXCEPTIONS_TABLE_VAR = exports.PROVIDER_RECEPTION_MATRIX_TABLE_VAR = void 0;
+const providerRestrictions_js_1 = require("./providerRestrictions.js");
+exports.PROVIDER_RECEPTION_MATRIX_TABLE_VAR = "ctl_calidad_admin_matriz_recepcion_proveedor_web_app_table_id";
+exports.PROVIDER_RECEPTION_EXCEPTIONS_TABLE_VAR = "ctl_calidad_admin_excepciones_recepcion_proveedor_web_app_table_id";
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+const isActive = (row, date) => {
+    if ((0, providerRestrictions_js_1.normalizeRestrictionValue)(row.fechaEliminacion) || !DATE_RE.test(date)) {
+        return false;
+    }
+    const start = (0, providerRestrictions_js_1.normalizeRestrictionValue)(row.start_date);
+    const end = (0, providerRestrictions_js_1.normalizeRestrictionValue)(row.end_date);
+    return DATE_RE.test(start) && DATE_RE.test(end) && start <= date && date <= end;
+};
+const matchesProviderAndType = (row, payeeId, receptionTypeCode) => Number(row.payee_id) === Number(payeeId) &&
+    (0, providerRestrictions_js_1.normalizeRestrictionValue)(row.reception_type_code) ===
+        (0, providerRestrictions_js_1.normalizeRestrictionValue)(receptionTypeCode);
+const resolveAllowedProviderReceptionItems = (input) => {
+    const universe = input.universe
+        .map(providerRestrictions_js_1.normalizeRestrictionValue)
+        .filter(Boolean);
+    const universeSet = new Set(universe);
+    const blocked = new Set((input.blockRules ?? [])
+        .filter((row) => !(0, providerRestrictions_js_1.normalizeRestrictionValue)(row.fechaEliminacion) &&
+        matchesProviderAndType(row, input.payeeId, input.receptionTypeCode))
+        .flatMap((row) => (0, providerRestrictions_js_1.normalizeProviderRestrictionValues)(row.blocked_item_ids)));
+    const activeExceptions = (input.exceptions ?? []).filter((row) => matchesProviderAndType(row, input.payeeId, input.receptionTypeCode) && isActive(row, input.date));
+    const temporarilyAllowed = new Set(activeExceptions
+        .filter((row) => row.mode === "allow")
+        .flatMap((row) => (0, providerRestrictions_js_1.normalizeProviderRestrictionValues)(row.item_ids)));
+    const temporarilyBlocked = new Set(activeExceptions
+        .filter((row) => row.mode === "block")
+        .flatMap((row) => (0, providerRestrictions_js_1.normalizeProviderRestrictionValues)(row.item_ids)));
+    const allowed = new Set(universe.filter((itemId) => !blocked.has(itemId)));
+    for (const itemId of temporarilyAllowed) {
+        if (universeSet.has(itemId)) {
+            allowed.add(itemId);
+        }
+    }
+    for (const itemId of temporarilyBlocked) {
+        allowed.delete(itemId);
+    }
+    return universe.filter((itemId) => allowed.has(itemId));
+};
+exports.resolveAllowedProviderReceptionItems = resolveAllowedProviderReceptionItems;
+const resolveAllowedProviderReceptionTypes = (input) => input.receptionTypeCodes
+    .map(providerRestrictions_js_1.normalizeRestrictionValue)
+    .filter(Boolean)
+    .filter((receptionTypeCode) => (0, exports.resolveAllowedProviderReceptionItems)({
+    ...input,
+    receptionTypeCode,
+    universe: input.itemIds,
+}).length > 0);
+exports.resolveAllowedProviderReceptionTypes = resolveAllowedProviderReceptionTypes;
+const providerReceptionMatrixLeavesNoAllowedCombination = (input) => {
+    const relevantExceptions = (input.exceptions ?? []).filter((row) => Number(row.payee_id) === Number(input.payeeId) &&
+        !(0, providerRestrictions_js_1.normalizeRestrictionValue)(row.fechaEliminacion));
+    const dates = (0, providerRestrictions_js_1.sampleDatesForRestrictionRules)(relevantExceptions);
+    return dates.some((date) => (0, exports.resolveAllowedProviderReceptionTypes)({
+        ...input,
+        date,
+    }).length === 0);
+};
+exports.providerReceptionMatrixLeavesNoAllowedCombination = providerReceptionMatrixLeavesNoAllowedCombination;
+const validateProviderReceptionException = (row, options) => {
+    const errors = [];
+    const typeCodes = new Set(options.receptionTypeCodes.map(providerRestrictions_js_1.normalizeRestrictionValue).filter(Boolean));
+    const itemIds = new Set(options.itemIds.map(providerRestrictions_js_1.normalizeRestrictionValue).filter(Boolean));
+    const selectedItems = (0, providerRestrictions_js_1.normalizeProviderRestrictionValues)(row.item_ids);
+    if (!Number(row.payee_id) || Number(row.payee_id) < 1) {
+        errors.push("Seleccione un proveedor.");
+    }
+    if (!typeCodes.has((0, providerRestrictions_js_1.normalizeRestrictionValue)(row.reception_type_code))) {
+        errors.push("Seleccione un tipo de recepción válido.");
+    }
+    if (row.mode !== "allow" && row.mode !== "block") {
+        errors.push("Seleccione si la excepción permite o bloquea verduras.");
+    }
+    if (selectedItems.length === 0 ||
+        selectedItems.some((itemId) => !itemIds.has(itemId))) {
+        errors.push("Seleccione al menos una verdura válida.");
+    }
+    if (!DATE_RE.test(row.start_date) ||
+        !DATE_RE.test(row.end_date) ||
+        row.start_date > row.end_date) {
+        errors.push("Indique un rango de fechas válido.");
+    }
+    if (!(0, providerRestrictions_js_1.normalizeRestrictionValue)(row.motivo)) {
+        errors.push("Indique el motivo de la excepción.");
+    }
+    return errors;
+};
+exports.validateProviderReceptionException = validateProviderReceptionException;
+const evaluateProviderReceptionMatrix = (input) => {
+    const itemId = (0, providerRestrictions_js_1.normalizeRestrictionValue)(input.itemId);
+    const allowed = (0, exports.resolveAllowedProviderReceptionItems)({
+        ...input,
+        universe: input.itemIds,
+    });
+    if (allowed.includes(itemId)) {
+        return { allowed: true };
+    }
+    const blockingException = (input.exceptions ?? []).find((row) => row.mode === "block" &&
+        matchesProviderAndType(row, input.payeeId, input.receptionTypeCode) &&
+        isActive(row, input.date) &&
+        (0, providerRestrictions_js_1.normalizeProviderRestrictionValues)(row.item_ids).includes(itemId));
+    const itemLabel = (0, providerRestrictions_js_1.normalizeRestrictionValue)(input.itemLabel) || itemId;
+    if (blockingException) {
+        return {
+            allowed: false,
+            mode: "exclude",
+            matchedValues: [itemLabel],
+            title: "Verdura no permitida para este proveedor",
+            description: `Del ${blockingException.start_date} al ${blockingException.end_date}, la verdura "${itemLabel}" está bloqueada para el tipo ${(0, providerRestrictions_js_1.normalizeRestrictionValue)(input.receptionTypeCode)}. Motivo: ${(0, providerRestrictions_js_1.normalizeRestrictionValue)(blockingException.motivo)}.`,
+        };
+    }
+    return {
+        allowed: false,
+        mode: "exclude",
+        matchedValues: [itemLabel],
+        title: "Verdura no permitida para este proveedor",
+        description: `La combinación de tipo ${(0, providerRestrictions_js_1.normalizeRestrictionValue)(input.receptionTypeCode)} y verdura "${itemLabel}" está desmarcada en la matriz del proveedor.`,
+    };
+};
+exports.evaluateProviderReceptionMatrix = evaluateProviderReceptionMatrix;

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/index.d.ts

@@ -3,4 +3,5 @@ export * from "./gtZones.js";
 export * from "./httpClientPolicy.js";
 export * from "./oauthErrors.js";
 export * from "./providerRestrictions.js";
+export * from "./providerReceptionMatrix.js";
 export * from "./rejectionPercentageAdjustment.js";

package/dist/providerReceptionMatrix.d.ts

@@ -0,0 +1,40 @@
+import type { ProviderReceptionBlockRule, ProviderReceptionException, ProviderRestrictionCheckResult } from "@zauru-sdk/types";
+export declare const PROVIDER_RECEPTION_MATRIX_TABLE_VAR = "ctl_calidad_admin_matriz_recepcion_proveedor_web_app_table_id";
+export declare const PROVIDER_RECEPTION_EXCEPTIONS_TABLE_VAR = "ctl_calidad_admin_excepciones_recepcion_proveedor_web_app_table_id";
+export declare const resolveAllowedProviderReceptionItems: (input: {
+    payeeId: number;
+    receptionTypeCode: string;
+    date: string;
+    universe: Array<string | number>;
+    blockRules?: ProviderReceptionBlockRule[];
+    exceptions?: ProviderReceptionException[];
+}) => string[];
+export declare const resolveAllowedProviderReceptionTypes: (input: {
+    payeeId: number;
+    date: string;
+    receptionTypeCodes: Array<string | number>;
+    itemIds: Array<string | number>;
+    blockRules?: ProviderReceptionBlockRule[];
+    exceptions?: ProviderReceptionException[];
+}) => string[];
+export declare const providerReceptionMatrixLeavesNoAllowedCombination: (input: {
+    payeeId: number;
+    receptionTypeCodes: Array<string | number>;
+    itemIds: Array<string | number>;
+    blockRules?: ProviderReceptionBlockRule[];
+    exceptions?: ProviderReceptionException[];
+}) => boolean;
+export declare const validateProviderReceptionException: (row: ProviderReceptionException, options: {
+    receptionTypeCodes: Array<string | number>;
+    itemIds: Array<string | number>;
+}) => string[];
+export declare const evaluateProviderReceptionMatrix: (input: {
+    payeeId: number;
+    receptionTypeCode: string;
+    date: string;
+    itemId: string | number;
+    itemLabel?: string;
+    itemIds: Array<string | number>;
+    blockRules?: ProviderReceptionBlockRule[];
+    exceptions?: ProviderReceptionException[];
+}) => ProviderRestrictionCheckResult;

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.12.0",
   "description": "Funciones de uso común en el desarrollo de webapps en Zauru",
   "main": "./dist/esm/index.js",
   "module": "./dist/esm/index.js",
@@ -12,7 +12,7 @@
   "scripts": {
     "build": "npm run build:esm",
     "build:esm": "tsc -p tsconfig.esm.json",
-    "test": "tsx --test src/httpClientPolicy.test.ts src/providerRestrictions.test.ts"
+    "test": "tsx --test src/httpClientPolicy.test.ts src/providerRestrictions.test.ts src/providerReceptionMatrix.test.ts"
   },
   "author": "Oscar Cuéllar",
   "license": "MIT",
@@ -22,9 +22,9 @@
   },
   "dependencies": {
     "@remix-run/node": "^2.8.1",
-    "@zauru-sdk/types": "^6.27.0",
+    "@zauru-sdk/types": "^6.28.0",
     "moment": "^2.30.1",
     "moment-timezone": "^0.5.45"
   },
-  "gitHead": "d8141f1d30edee6edb8d2777d0e12e2f4f1b2726"
+  "gitHead": "2fda4a18e3f62d22c38fbb91052869db9ebc16f4"
 }

package/src/index.ts

@@ -3,4 +3,5 @@ export * from "./gtZones.js";
 export * from "./httpClientPolicy.js";
 export * from "./oauthErrors.js";
 export * from "./providerRestrictions.js";
+export * from "./providerReceptionMatrix.js";
 export * from "./rejectionPercentageAdjustment.js";

package/src/providerReceptionMatrix.test.ts

@@ -0,0 +1,184 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type {
+  ProviderReceptionBlockRule,
+  ProviderReceptionException,
+} from "@zauru-sdk/types";
+import {
+  evaluateProviderReceptionMatrix,
+  providerReceptionMatrixLeavesNoAllowedCombination,
+  resolveAllowedProviderReceptionItems,
+  resolveAllowedProviderReceptionTypes,
+  validateProviderReceptionException,
+} from "./providerReceptionMatrix.js";
+
+const block = (
+  partial: Partial<ProviderReceptionBlockRule> = {},
+): ProviderReceptionBlockRule => ({
+  payee_id: 10,
+  reception_type_code: "1",
+  blocked_item_ids: [],
+  ...partial,
+});
+
+const exception = (
+  partial: Partial<ProviderReceptionException> = {},
+): ProviderReceptionException => ({
+  payee_id: 10,
+  reception_type_code: "1",
+  mode: "block",
+  item_ids: [100],
+  start_date: "2026-10-01",
+  end_date: "2026-10-31",
+  motivo: "Suspensión temporal",
+  ...partial,
+});
+
+describe("resolveAllowedProviderReceptionItems", () => {
+  it("allows the whole universe when no matrix row exists", () => {
+    assert.deepEqual(
+      resolveAllowedProviderReceptionItems({
+        payeeId: 10,
+        receptionTypeCode: "1",
+        date: "2026-10-15",
+        universe: [100, 200],
+      }),
+      ["100", "200"],
+    );
+  });
+
+  it("blocks only the exact provider, type and item combination", () => {
+    const rules = [block({ blocked_item_ids: [100] })];
+    assert.deepEqual(
+      resolveAllowedProviderReceptionItems({
+        payeeId: 10,
+        receptionTypeCode: "1",
+        date: "2026-10-15",
+        universe: [100, 200],
+        blockRules: rules,
+      }),
+      ["200"],
+    );
+    assert.deepEqual(
+      resolveAllowedProviderReceptionItems({
+        payeeId: 10,
+        receptionTypeCode: "Normal",
+        date: "2026-10-15",
+        universe: [100, 200],
+        blockRules: rules,
+      }),
+      ["100", "200"],
+    );
+  });
+
+  it("allows a base-blocked item only inside an allow exception range", () => {
+    const input = {
+      payeeId: 10,
+      receptionTypeCode: "1",
+      universe: [100, 200],
+      blockRules: [block({ blocked_item_ids: [100] })],
+      exceptions: [exception({ mode: "allow" as const })],
+    };
+    assert.deepEqual(
+      resolveAllowedProviderReceptionItems({ ...input, date: "2026-10-15" }),
+      ["100", "200"],
+    );
+    assert.deepEqual(
+      resolveAllowedProviderReceptionItems({ ...input, date: "2026-11-01" }),
+      ["200"],
+    );
+  });
+
+  it("makes a temporary block win over an overlapping allow", () => {
+    assert.deepEqual(
+      resolveAllowedProviderReceptionItems({
+        payeeId: 10,
+        receptionTypeCode: "1",
+        date: "2026-10-15",
+        universe: [100, 200],
+        exceptions: [
+          exception({ mode: "allow" }),
+          exception({ mode: "block" }),
+        ],
+      }),
+      ["200"],
+    );
+  });
+
+  it("ignores soft-deleted matrix rows and exceptions", () => {
+    assert.deepEqual(
+      resolveAllowedProviderReceptionItems({
+        payeeId: 10,
+        receptionTypeCode: "1",
+        date: "2026-10-15",
+        universe: [100, 200],
+        blockRules: [
+          block({ blocked_item_ids: [100], fechaEliminacion: "2026-10-01" }),
+        ],
+        exceptions: [exception({ fechaEliminacion: "2026-10-01" })],
+      }),
+      ["100", "200"],
+    );
+  });
+});
+
+describe("provider reception matrix validation", () => {
+  it("keeps only reception types with at least one allowed item", () => {
+    assert.deepEqual(
+      resolveAllowedProviderReceptionTypes({
+        payeeId: 10,
+        date: "2026-10-15",
+        receptionTypeCodes: ["Normal", "1"],
+        itemIds: [100],
+        blockRules: [block({ blocked_item_ids: [100] })],
+      }),
+      ["Normal"],
+    );
+  });
+
+  it("rejects rules whose dated overlap leaves no valid combination", () => {
+    assert.equal(
+      providerReceptionMatrixLeavesNoAllowedCombination({
+        payeeId: 10,
+        receptionTypeCodes: ["Normal", "1"],
+        itemIds: [100],
+        blockRules: [block({ blocked_item_ids: [100] })],
+        exceptions: [
+          exception({
+            reception_type_code: "Normal",
+            mode: "block",
+            item_ids: [100],
+          }),
+        ],
+      }),
+      true,
+    );
+  });
+
+  it("requires valid dates, items and motivo for exceptions", () => {
+    const errors = validateProviderReceptionException(
+      exception({ end_date: "2026-09-01", motivo: "", item_ids: [999] }),
+      { receptionTypeCodes: ["1"], itemIds: [100, 200] },
+    );
+    assert.equal(errors.length, 3);
+  });
+});
+
+describe("evaluateProviderReceptionMatrix", () => {
+  it("includes the temporary reason and inclusive range when blocked", () => {
+    const result = evaluateProviderReceptionMatrix({
+      payeeId: 10,
+      receptionTypeCode: "1",
+      date: "2026-10-31",
+      itemId: 100,
+      itemLabel: "Ejote",
+      itemIds: [100, 200],
+      exceptions: [exception()],
+    });
+    assert.equal(result.allowed, false);
+    if (!result.allowed) {
+      assert.match(result.description, /Suspensión temporal/);
+      assert.match(result.description, /2026-10-31/);
+    }
+  });
+});

package/src/providerReceptionMatrix.ts

@@ -0,0 +1,237 @@
+import type {
+  ProviderReceptionBlockRule,
+  ProviderReceptionException,
+  ProviderRestrictionCheckResult,
+} from "@zauru-sdk/types";
+import {
+  normalizeProviderRestrictionValues,
+  normalizeRestrictionValue,
+  sampleDatesForRestrictionRules,
+} from "./providerRestrictions.js";
+
+export const PROVIDER_RECEPTION_MATRIX_TABLE_VAR =
+  "ctl_calidad_admin_matriz_recepcion_proveedor_web_app_table_id";
+
+export const PROVIDER_RECEPTION_EXCEPTIONS_TABLE_VAR =
+  "ctl_calidad_admin_excepciones_recepcion_proveedor_web_app_table_id";
+
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+
+const isActive = (
+  row: Pick<ProviderReceptionException, "start_date" | "end_date" | "fechaEliminacion">,
+  date: string,
+): boolean => {
+  if (normalizeRestrictionValue(row.fechaEliminacion) || !DATE_RE.test(date)) {
+    return false;
+  }
+  const start = normalizeRestrictionValue(row.start_date);
+  const end = normalizeRestrictionValue(row.end_date);
+  return DATE_RE.test(start) && DATE_RE.test(end) && start <= date && date <= end;
+};
+
+const matchesProviderAndType = (
+  row: { payee_id: number; reception_type_code: string },
+  payeeId: number,
+  receptionTypeCode: string,
+): boolean =>
+  Number(row.payee_id) === Number(payeeId) &&
+  normalizeRestrictionValue(row.reception_type_code) ===
+    normalizeRestrictionValue(receptionTypeCode);
+
+export const resolveAllowedProviderReceptionItems = (input: {
+  payeeId: number;
+  receptionTypeCode: string;
+  date: string;
+  universe: Array<string | number>;
+  blockRules?: ProviderReceptionBlockRule[];
+  exceptions?: ProviderReceptionException[];
+}): string[] => {
+  const universe = input.universe
+    .map(normalizeRestrictionValue)
+    .filter(Boolean);
+  const universeSet = new Set(universe);
+  const blocked = new Set(
+    (input.blockRules ?? [])
+      .filter(
+        (row) =>
+          !normalizeRestrictionValue(row.fechaEliminacion) &&
+          matchesProviderAndType(
+            row,
+            input.payeeId,
+            input.receptionTypeCode,
+          ),
+      )
+      .flatMap((row) =>
+        normalizeProviderRestrictionValues(row.blocked_item_ids),
+      ),
+  );
+
+  const activeExceptions = (input.exceptions ?? []).filter(
+    (row) =>
+      matchesProviderAndType(
+        row,
+        input.payeeId,
+        input.receptionTypeCode,
+      ) && isActive(row, input.date),
+  );
+
+  const temporarilyAllowed = new Set(
+    activeExceptions
+      .filter((row) => row.mode === "allow")
+      .flatMap((row) => normalizeProviderRestrictionValues(row.item_ids)),
+  );
+  const temporarilyBlocked = new Set(
+    activeExceptions
+      .filter((row) => row.mode === "block")
+      .flatMap((row) => normalizeProviderRestrictionValues(row.item_ids)),
+  );
+
+  const allowed = new Set(universe.filter((itemId) => !blocked.has(itemId)));
+  for (const itemId of temporarilyAllowed) {
+    if (universeSet.has(itemId)) {
+      allowed.add(itemId);
+    }
+  }
+  for (const itemId of temporarilyBlocked) {
+    allowed.delete(itemId);
+  }
+
+  return universe.filter((itemId) => allowed.has(itemId));
+};
+
+export const resolveAllowedProviderReceptionTypes = (input: {
+  payeeId: number;
+  date: string;
+  receptionTypeCodes: Array<string | number>;
+  itemIds: Array<string | number>;
+  blockRules?: ProviderReceptionBlockRule[];
+  exceptions?: ProviderReceptionException[];
+}): string[] =>
+  input.receptionTypeCodes
+    .map(normalizeRestrictionValue)
+    .filter(Boolean)
+    .filter(
+      (receptionTypeCode) =>
+        resolveAllowedProviderReceptionItems({
+          ...input,
+          receptionTypeCode,
+          universe: input.itemIds,
+        }).length > 0,
+    );
+
+export const providerReceptionMatrixLeavesNoAllowedCombination = (input: {
+  payeeId: number;
+  receptionTypeCodes: Array<string | number>;
+  itemIds: Array<string | number>;
+  blockRules?: ProviderReceptionBlockRule[];
+  exceptions?: ProviderReceptionException[];
+}): boolean => {
+  const relevantExceptions = (input.exceptions ?? []).filter(
+    (row) =>
+      Number(row.payee_id) === Number(input.payeeId) &&
+      !normalizeRestrictionValue(row.fechaEliminacion),
+  );
+  const dates = sampleDatesForRestrictionRules(relevantExceptions);
+  return dates.some(
+    (date) =>
+      resolveAllowedProviderReceptionTypes({
+        ...input,
+        date,
+      }).length === 0,
+  );
+};
+
+export const validateProviderReceptionException = (
+  row: ProviderReceptionException,
+  options: {
+    receptionTypeCodes: Array<string | number>;
+    itemIds: Array<string | number>;
+  },
+): string[] => {
+  const errors: string[] = [];
+  const typeCodes = new Set(
+    options.receptionTypeCodes.map(normalizeRestrictionValue).filter(Boolean),
+  );
+  const itemIds = new Set(
+    options.itemIds.map(normalizeRestrictionValue).filter(Boolean),
+  );
+  const selectedItems = normalizeProviderRestrictionValues(row.item_ids);
+
+  if (!Number(row.payee_id) || Number(row.payee_id) < 1) {
+    errors.push("Seleccione un proveedor.");
+  }
+  if (!typeCodes.has(normalizeRestrictionValue(row.reception_type_code))) {
+    errors.push("Seleccione un tipo de recepción válido.");
+  }
+  if (row.mode !== "allow" && row.mode !== "block") {
+    errors.push("Seleccione si la excepción permite o bloquea verduras.");
+  }
+  if (
+    selectedItems.length === 0 ||
+    selectedItems.some((itemId) => !itemIds.has(itemId))
+  ) {
+    errors.push("Seleccione al menos una verdura válida.");
+  }
+  if (
+    !DATE_RE.test(row.start_date) ||
+    !DATE_RE.test(row.end_date) ||
+    row.start_date > row.end_date
+  ) {
+    errors.push("Indique un rango de fechas válido.");
+  }
+  if (!normalizeRestrictionValue(row.motivo)) {
+    errors.push("Indique el motivo de la excepción.");
+  }
+  return errors;
+};
+
+export const evaluateProviderReceptionMatrix = (input: {
+  payeeId: number;
+  receptionTypeCode: string;
+  date: string;
+  itemId: string | number;
+  itemLabel?: string;
+  itemIds: Array<string | number>;
+  blockRules?: ProviderReceptionBlockRule[];
+  exceptions?: ProviderReceptionException[];
+}): ProviderRestrictionCheckResult => {
+  const itemId = normalizeRestrictionValue(input.itemId);
+  const allowed = resolveAllowedProviderReceptionItems({
+    ...input,
+    universe: input.itemIds,
+  });
+  if (allowed.includes(itemId)) {
+    return { allowed: true };
+  }
+
+  const blockingException = (input.exceptions ?? []).find(
+    (row) =>
+      row.mode === "block" &&
+      matchesProviderAndType(
+        row,
+        input.payeeId,
+        input.receptionTypeCode,
+      ) &&
+      isActive(row, input.date) &&
+      normalizeProviderRestrictionValues(row.item_ids).includes(itemId),
+  );
+  const itemLabel = normalizeRestrictionValue(input.itemLabel) || itemId;
+
+  if (blockingException) {
+    return {
+      allowed: false,
+      mode: "exclude",
+      matchedValues: [itemLabel],
+      title: "Verdura no permitida para este proveedor",
+      description: `Del ${blockingException.start_date} al ${blockingException.end_date}, la verdura "${itemLabel}" está bloqueada para el tipo ${normalizeRestrictionValue(input.receptionTypeCode)}. Motivo: ${normalizeRestrictionValue(blockingException.motivo)}.`,
+    };
+  }
+
+  return {
+    allowed: false,
+    mode: "exclude",
+    matchedValues: [itemLabel],
+    title: "Verdura no permitida para este proveedor",
+    description: `La combinación de tipo ${normalizeRestrictionValue(input.receptionTypeCode)} y verdura "${itemLabel}" está desmarcada en la matriz del proveedor.`,
+  };
+};

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;
 };