@frictionless-ts/table 1.0.1

package/build/field/checks/maximum.spec.js

@@ -0,0 +1,476 @@
+import * as pl from "nodejs-polars";
+import { describe, expect, it } from "vitest";
+import { inspectTable } from "../../table/index.js";
+describe("inspectTable (cell/maximum)", () => {
+    it("should not errors for valid values", async () => {
+        const table = pl
+            .DataFrame({
+            price: [10.5, 20.75, 30.0],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "price",
+                    type: "number",
+                    constraints: { maximum: 50 },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toHaveLength(0);
+    });
+    it("should report an error for invalid values", async () => {
+        const table = pl
+            .DataFrame({
+            temperature: [20.5, 30.0, 40, 50.5],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "temperature",
+                    type: "number",
+                    constraints: { maximum: 40 },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors.filter(e => e.type === "cell/maximum")).toHaveLength(1);
+        expect(errors).toContainEqual({
+            type: "cell/maximum",
+            fieldName: "temperature",
+            maximum: "40",
+            rowNumber: 4,
+            cell: "50.5",
+        });
+    });
+    it("should report an error for invalid values (exclusive)", async () => {
+        const table = pl
+            .DataFrame({
+            temperature: [20.5, 30.0, 40.0, 50.5],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "temperature",
+                    type: "number",
+                    constraints: { exclusiveMaximum: 40 },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors.filter(e => e.type === "cell/exclusiveMaximum")).toHaveLength(2);
+        expect(errors).toContainEqual({
+            type: "cell/exclusiveMaximum",
+            fieldName: "temperature",
+            maximum: "40",
+            rowNumber: 3,
+            cell: "40",
+        });
+        expect(errors).toContainEqual({
+            type: "cell/exclusiveMaximum",
+            fieldName: "temperature",
+            maximum: "40",
+            rowNumber: 4,
+            cell: "50.5",
+        });
+    });
+    it("should handle maximum as string", async () => {
+        const table = pl
+            .DataFrame({
+            price: [10.5, 20.75, 55.0],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "price",
+                    type: "number",
+                    constraints: { maximum: "50" },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/maximum",
+                fieldName: "price",
+                maximum: "50",
+                rowNumber: 3,
+                cell: "55",
+            },
+        ]);
+    });
+    it("should handle exclusiveMaximum as string", async () => {
+        const table = pl
+            .DataFrame({
+            temperature: [20.5, 40.0, 50.5],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "temperature",
+                    type: "number",
+                    constraints: { exclusiveMaximum: "40" },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/exclusiveMaximum",
+                fieldName: "temperature",
+                maximum: "40",
+                rowNumber: 2,
+                cell: "40",
+            },
+            {
+                type: "cell/exclusiveMaximum",
+                fieldName: "temperature",
+                maximum: "40",
+                rowNumber: 3,
+                cell: "50.5",
+            },
+        ]);
+    });
+    it("should handle maximum as string with groupChar", async () => {
+        const table = pl
+            .DataFrame({
+            price: ["5,000", "10,500", "15,000"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "price",
+                    type: "integer",
+                    groupChar: ",",
+                    constraints: { maximum: "12,000" },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/maximum",
+                fieldName: "price",
+                maximum: "12,000",
+                rowNumber: 3,
+                cell: "15,000",
+            },
+        ]);
+    });
+    it("should handle maximum as string with decimalChar", async () => {
+        const table = pl
+            .DataFrame({
+            price: ["5,5", "10,75", "15,3"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "price",
+                    type: "number",
+                    decimalChar: ",",
+                    constraints: { maximum: "12,0" },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/maximum",
+                fieldName: "price",
+                maximum: "12,0",
+                rowNumber: 3,
+                cell: "15,3",
+            },
+        ]);
+    });
+    it("should handle maximum as string with groupChar and decimalChar", async () => {
+        const table = pl
+            .DataFrame({
+            price: ["5.000,50", "10.500,75", "15.000,30"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "price",
+                    type: "number",
+                    groupChar: ".",
+                    decimalChar: ",",
+                    constraints: { maximum: "12.000,00" },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/maximum",
+                fieldName: "price",
+                maximum: "12.000,00",
+                rowNumber: 3,
+                cell: "15.000,30",
+            },
+        ]);
+    });
+    it("should handle maximum as string with bareNumber false", async () => {
+        const table = pl
+            .DataFrame({
+            price: ["$5.00", "$10.50", "$15.50"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "price",
+                    type: "number",
+                    bareNumber: false,
+                    constraints: { maximum: "$12.00" },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/maximum",
+                fieldName: "price",
+                maximum: "$12.00",
+                rowNumber: 3,
+                cell: "$15.50",
+            },
+        ]);
+    });
+    it("should handle maximum for date fields", async () => {
+        const table = pl
+            .DataFrame({
+            date: ["2024-01-15", "2024-02-20", "2024-03-25"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "date",
+                    type: "date",
+                    constraints: { maximum: "2024-02-28" },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/maximum",
+                fieldName: "date",
+                maximum: "2024-02-28",
+                rowNumber: 3,
+                cell: "2024-03-25",
+            },
+        ]);
+    });
+    it.skip("should handle maximum for time fields", async () => {
+        const table = pl
+            .DataFrame({
+            time: ["14:30:00", "16:45:00", "18:00:00"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "time",
+                    type: "time",
+                    constraints: { maximum: "17:00:00" },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/maximum",
+                fieldName: "time",
+                maximum: "17:00:00",
+                rowNumber: 3,
+                cell: "18:00:00",
+            },
+        ]);
+    });
+    it("should handle maximum for datetime fields", async () => {
+        const table = pl
+            .DataFrame({
+            timestamp: [
+                "2024-01-15T14:30:00",
+                "2024-02-20T08:15:00",
+                "2024-03-25T10:00:00",
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "timestamp",
+                    type: "datetime",
+                    constraints: { maximum: "2024-02-28T23:59:59" },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/maximum",
+                fieldName: "timestamp",
+                maximum: "2024-02-28T23:59:59",
+                rowNumber: 3,
+                cell: "2024-03-25T10:00:00",
+            },
+        ]);
+    });
+    it("should handle maximum for date fields with custom format", async () => {
+        const table = pl
+            .DataFrame({
+            date: ["15/01/2024", "20/02/2024", "25/03/2024"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "date",
+                    type: "date",
+                    format: "%d/%m/%Y",
+                    constraints: { maximum: "28/02/2024" },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/maximum",
+                fieldName: "date",
+                maximum: "28/02/2024",
+                rowNumber: 3,
+                cell: "25/03/2024",
+            },
+        ]);
+    });
+    it("should handle maximum for year fields", async () => {
+        const table = pl
+            .DataFrame({
+            year: ["2020", "2021", "2023"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "year",
+                    type: "year",
+                    constraints: { maximum: "2022" },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/maximum",
+                fieldName: "year",
+                maximum: "2022",
+                rowNumber: 3,
+                cell: "2023",
+            },
+        ]);
+    });
+    it("should handle exclusiveMaximum for year fields", async () => {
+        const table = pl
+            .DataFrame({
+            year: ["2020", "2021", "2022", "2023"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "year",
+                    type: "year",
+                    constraints: { exclusiveMaximum: "2022" },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/exclusiveMaximum",
+                fieldName: "year",
+                maximum: "2022",
+                rowNumber: 3,
+                cell: "2022",
+            },
+            {
+                type: "cell/exclusiveMaximum",
+                fieldName: "year",
+                maximum: "2022",
+                rowNumber: 4,
+                cell: "2023",
+            },
+        ]);
+    });
+    it.skip("should handle maximum for yearmonth fields", async () => {
+        const table = pl
+            .DataFrame({
+            yearmonth: ["2024-01", "2024-03", "2024-06"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "yearmonth",
+                    type: "yearmonth",
+                    constraints: { maximum: "2024-05" },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/maximum",
+                fieldName: "yearmonth",
+                maximum: "2024-05",
+                rowNumber: 3,
+                cell: "2024-06",
+            },
+        ]);
+    });
+    it.skip("should handle exclusiveMaximum for yearmonth fields", async () => {
+        const table = pl
+            .DataFrame({
+            yearmonth: ["2024-01", "2024-03", "2024-05", "2024-06"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "yearmonth",
+                    type: "yearmonth",
+                    constraints: { exclusiveMaximum: "2024-05" },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/exclusiveMaximum",
+                fieldName: "yearmonth",
+                maximum: "2024-05",
+                rowNumber: 3,
+                cell: "2024-05",
+            },
+            {
+                type: "cell/exclusiveMaximum",
+                fieldName: "yearmonth",
+                maximum: "2024-05",
+                rowNumber: 4,
+                cell: "2024-06",
+            },
+        ]);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"maximum.spec.js","sourceRoot":"","sources":["../../../field/checks/maximum.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Schema } from \"@frictionless-ts/metadata\"\nimport * as pl from \"nodejs-polars\"\nimport { describe, expect, it } from \"vitest\"\nimport { inspectTable } from \"../../table/index.ts\"\n\ndescribe(\"inspectTable (cell/maximum)\", () => {\n  it(\"should not errors for valid values\", async () => {\n    const table = pl\n      .DataFrame({\n        price: [10.5, 20.75, 30.0],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"price\",\n          type: \"number\",\n          constraints: { maximum: 50 },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toHaveLength(0)\n  })\n\n  it(\"should report an error for invalid values\", async () => {\n    const table = pl\n      .DataFrame({\n        temperature: [20.5, 30.0, 40, 50.5],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"temperature\",\n          type: \"number\",\n          constraints: { maximum: 40 },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors.filter(e => e.type === \"cell/maximum\")).toHaveLength(1)\n    expect(errors).toContainEqual({\n      type: \"cell/maximum\",\n      fieldName: \"temperature\",\n      maximum: \"40\",\n      rowNumber: 4,\n      cell: \"50.5\",\n    })\n  })\n\n  it(\"should report an error for invalid values (exclusive)\", async () => {\n    const table = pl\n      .DataFrame({\n        temperature: [20.5, 30.0, 40.0, 50.5],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"temperature\",\n          type: \"number\",\n          constraints: { exclusiveMaximum: 40 },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors.filter(e => e.type === \"cell/exclusiveMaximum\")).toHaveLength(\n      2,\n    )\n    expect(errors).toContainEqual({\n      type: \"cell/exclusiveMaximum\",\n      fieldName: \"temperature\",\n      maximum: \"40\",\n      rowNumber: 3,\n      cell: \"40\",\n    })\n    expect(errors).toContainEqual({\n      type: \"cell/exclusiveMaximum\",\n      fieldName: \"temperature\",\n      maximum: \"40\",\n      rowNumber: 4,\n      cell: \"50.5\",\n    })\n  })\n\n  it(\"should handle maximum as string\", async () => {\n    const table = pl\n      .DataFrame({\n        price: [10.5, 20.75, 55.0],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"price\",\n          type: \"number\",\n          constraints: { maximum: \"50\" },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/maximum\",\n        fieldName: \"price\",\n        maximum: \"50\",\n        rowNumber: 3,\n        cell: \"55\",\n      },\n    ])\n  })\n\n  it(\"should handle exclusiveMaximum as string\", async () => {\n    const table = pl\n      .DataFrame({\n        temperature: [20.5, 40.0, 50.5],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"temperature\",\n          type: \"number\",\n          constraints: { exclusiveMaximum: \"40\" },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/exclusiveMaximum\",\n        fieldName: \"temperature\",\n        maximum: \"40\",\n        rowNumber: 2,\n        cell: \"40\",\n      },\n      {\n        type: \"cell/exclusiveMaximum\",\n        fieldName: \"temperature\",\n        maximum: \"40\",\n        rowNumber: 3,\n        cell: \"50.5\",\n      },\n    ])\n  })\n\n  it(\"should handle maximum as string with groupChar\", async () => {\n    const table = pl\n      .DataFrame({\n        price: [\"5,000\", \"10,500\", \"15,000\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"price\",\n          type: \"integer\",\n          groupChar: \",\",\n          constraints: { maximum: \"12,000\" },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/maximum\",\n        fieldName: \"price\",\n        maximum: \"12,000\",\n        rowNumber: 3,\n        cell: \"15,000\",\n      },\n    ])\n  })\n\n  it(\"should handle maximum as string with decimalChar\", async () => {\n    const table = pl\n      .DataFrame({\n        price: [\"5,5\", \"10,75\", \"15,3\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"price\",\n          type: \"number\",\n          decimalChar: \",\",\n          constraints: { maximum: \"12,0\" },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/maximum\",\n        fieldName: \"price\",\n        maximum: \"12,0\",\n        rowNumber: 3,\n        cell: \"15,3\",\n      },\n    ])\n  })\n\n  it(\"should handle maximum as string with groupChar and decimalChar\", async () => {\n    const table = pl\n      .DataFrame({\n        price: [\"5.000,50\", \"10.500,75\", \"15.000,30\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"price\",\n          type: \"number\",\n          groupChar: \".\",\n          decimalChar: \",\",\n          constraints: { maximum: \"12.000,00\" },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/maximum\",\n        fieldName: \"price\",\n        maximum: \"12.000,00\",\n        rowNumber: 3,\n        cell: \"15.000,30\",\n      },\n    ])\n  })\n\n  it(\"should handle maximum as string with bareNumber false\", async () => {\n    const table = pl\n      .DataFrame({\n        price: [\"$5.00\", \"$10.50\", \"$15.50\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"price\",\n          type: \"number\",\n          bareNumber: false,\n          constraints: { maximum: \"$12.00\" },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/maximum\",\n        fieldName: \"price\",\n        maximum: \"$12.00\",\n        rowNumber: 3,\n        cell: \"$15.50\",\n      },\n    ])\n  })\n\n  it(\"should handle maximum for date fields\", async () => {\n    const table = pl\n      .DataFrame({\n        date: [\"2024-01-15\", \"2024-02-20\", \"2024-03-25\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"date\",\n          type: \"date\",\n          constraints: { maximum: \"2024-02-28\" },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/maximum\",\n        fieldName: \"date\",\n        maximum: \"2024-02-28\",\n        rowNumber: 3,\n        cell: \"2024-03-25\",\n      },\n    ])\n  })\n\n  it.skip(\"should handle maximum for time fields\", async () => {\n    const table = pl\n      .DataFrame({\n        time: [\"14:30:00\", \"16:45:00\", \"18:00:00\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"time\",\n          type: \"time\",\n          constraints: { maximum: \"17:00:00\" },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/maximum\",\n        fieldName: \"time\",\n        maximum: \"17:00:00\",\n        rowNumber: 3,\n        cell: \"18:00:00\",\n      },\n    ])\n  })\n\n  it(\"should handle maximum for datetime fields\", async () => {\n    const table = pl\n      .DataFrame({\n        timestamp: [\n          \"2024-01-15T14:30:00\",\n          \"2024-02-20T08:15:00\",\n          \"2024-03-25T10:00:00\",\n        ],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"timestamp\",\n          type: \"datetime\",\n          constraints: { maximum: \"2024-02-28T23:59:59\" },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/maximum\",\n        fieldName: \"timestamp\",\n        maximum: \"2024-02-28T23:59:59\",\n        rowNumber: 3,\n        cell: \"2024-03-25T10:00:00\",\n      },\n    ])\n  })\n\n  it(\"should handle maximum for date fields with custom format\", async () => {\n    const table = pl\n      .DataFrame({\n        date: [\"15/01/2024\", \"20/02/2024\", \"25/03/2024\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"date\",\n          type: \"date\",\n          format: \"%d/%m/%Y\",\n          constraints: { maximum: \"28/02/2024\" },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/maximum\",\n        fieldName: \"date\",\n        maximum: \"28/02/2024\",\n        rowNumber: 3,\n        cell: \"25/03/2024\",\n      },\n    ])\n  })\n\n  it(\"should handle maximum for year fields\", async () => {\n    const table = pl\n      .DataFrame({\n        year: [\"2020\", \"2021\", \"2023\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"year\",\n          type: \"year\",\n          constraints: { maximum: \"2022\" },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/maximum\",\n        fieldName: \"year\",\n        maximum: \"2022\",\n        rowNumber: 3,\n        cell: \"2023\",\n      },\n    ])\n  })\n\n  it(\"should handle exclusiveMaximum for year fields\", async () => {\n    const table = pl\n      .DataFrame({\n        year: [\"2020\", \"2021\", \"2022\", \"2023\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"year\",\n          type: \"year\",\n          constraints: { exclusiveMaximum: \"2022\" },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/exclusiveMaximum\",\n        fieldName: \"year\",\n        maximum: \"2022\",\n        rowNumber: 3,\n        cell: \"2022\",\n      },\n      {\n        type: \"cell/exclusiveMaximum\",\n        fieldName: \"year\",\n        maximum: \"2022\",\n        rowNumber: 4,\n        cell: \"2023\",\n      },\n    ])\n  })\n\n  it.skip(\"should handle maximum for yearmonth fields\", async () => {\n    const table = pl\n      .DataFrame({\n        yearmonth: [\"2024-01\", \"2024-03\", \"2024-06\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"yearmonth\",\n          type: \"yearmonth\",\n          constraints: { maximum: \"2024-05\" },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/maximum\",\n        fieldName: \"yearmonth\",\n        maximum: \"2024-05\",\n        rowNumber: 3,\n        cell: \"2024-06\",\n      },\n    ])\n  })\n\n  it.skip(\"should handle exclusiveMaximum for yearmonth fields\", async () => {\n    const table = pl\n      .DataFrame({\n        yearmonth: [\"2024-01\", \"2024-03\", \"2024-05\", \"2024-06\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"yearmonth\",\n          type: \"yearmonth\",\n          constraints: { exclusiveMaximum: \"2024-05\" },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/exclusiveMaximum\",\n        fieldName: \"yearmonth\",\n        maximum: \"2024-05\",\n        rowNumber: 3,\n        cell: \"2024-05\",\n      },\n      {\n        type: \"cell/exclusiveMaximum\",\n        fieldName: \"yearmonth\",\n        maximum: \"2024-05\",\n        rowNumber: 4,\n        cell: \"2024-06\",\n      },\n    ])\n  })\n})\n"]}

package/build/field/checks/minLength.d.ts

@@ -0,0 +1,7 @@
+import type { Field } from "@frictionless-ts/metadata";
+import type { CellMinLengthError } from "@frictionless-ts/metadata";
+import type { CellMapping } from "../Mapping.ts";
+export declare function checkCellMinLength(field: Field, mapping: CellMapping): {
+    isErrorExpr: import("nodejs-polars").Expr;
+    errorTemplate: CellMinLengthError;
+} | undefined;

package/build/field/checks/minLength.js

@@ -0,0 +1,17 @@
+export function checkCellMinLength(field, mapping) {
+    if (field.type !== "string")
+        return undefined;
+    const minLength = field.constraints?.minLength;
+    if (!minLength)
+        return undefined;
+    const isErrorExpr = mapping.target.str.lengths().lt(minLength);
+    const errorTemplate = {
+        type: "cell/minLength",
+        fieldName: field.name,
+        minLength: minLength,
+        rowNumber: 0,
+        cell: "",
+    };
+    return { isErrorExpr, errorTemplate };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWluTGVuZ3RoLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vZmllbGQvY2hlY2tzL21pbkxlbmd0aC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxNQUFNLFVBQVUsa0JBQWtCLENBQUMsS0FBWSxFQUFFLE9BQW9CO0lBQ25FLElBQUksS0FBSyxDQUFDLElBQUksS0FBSyxRQUFRO1FBQUUsT0FBTyxTQUFTLENBQUE7SUFFN0MsTUFBTSxTQUFTLEdBQUcsS0FBSyxDQUFDLFdBQVcsRUFBRSxTQUFTLENBQUE7SUFDOUMsSUFBSSxDQUFDLFNBQVM7UUFBRSxPQUFPLFNBQVMsQ0FBQTtJQUVoQyxNQUFNLFdBQVcsR0FBRyxPQUFPLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxPQUFPLEVBQUUsQ0FBQyxFQUFFLENBQUMsU0FBUyxDQUFDLENBQUE7SUFFOUQsTUFBTSxhQUFhLEdBQXVCO1FBQ3hDLElBQUksRUFBRSxnQkFBZ0I7UUFDdEIsU0FBUyxFQUFFLEtBQUssQ0FBQyxJQUFJO1FBQ3JCLFNBQVMsRUFBRSxTQUFTO1FBQ3BCLFNBQVMsRUFBRSxDQUFDO1FBQ1osSUFBSSxFQUFFLEVBQUU7S0FDVCxDQUFBO0lBRUQsT0FBTyxFQUFFLFdBQVcsRUFBRSxhQUFhLEVBQUUsQ0FBQTtBQUN2QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBGaWVsZCB9IGZyb20gXCJAZnJpY3Rpb25sZXNzLXRzL21ldGFkYXRhXCJcbmltcG9ydCB0eXBlIHsgQ2VsbE1pbkxlbmd0aEVycm9yIH0gZnJvbSBcIkBmcmljdGlvbmxlc3MtdHMvbWV0YWRhdGFcIlxuaW1wb3J0IHR5cGUgeyBDZWxsTWFwcGluZyB9IGZyb20gXCIuLi9NYXBwaW5nLnRzXCJcblxuZXhwb3J0IGZ1bmN0aW9uIGNoZWNrQ2VsbE1pbkxlbmd0aChmaWVsZDogRmllbGQsIG1hcHBpbmc6IENlbGxNYXBwaW5nKSB7XG4gIGlmIChmaWVsZC50eXBlICE9PSBcInN0cmluZ1wiKSByZXR1cm4gdW5kZWZpbmVkXG5cbiAgY29uc3QgbWluTGVuZ3RoID0gZmllbGQuY29uc3RyYWludHM/Lm1pbkxlbmd0aFxuICBpZiAoIW1pbkxlbmd0aCkgcmV0dXJuIHVuZGVmaW5lZFxuXG4gIGNvbnN0IGlzRXJyb3JFeHByID0gbWFwcGluZy50YXJnZXQuc3RyLmxlbmd0aHMoKS5sdChtaW5MZW5ndGgpXG5cbiAgY29uc3QgZXJyb3JUZW1wbGF0ZTogQ2VsbE1pbkxlbmd0aEVycm9yID0ge1xuICAgIHR5cGU6IFwiY2VsbC9taW5MZW5ndGhcIixcbiAgICBmaWVsZE5hbWU6IGZpZWxkLm5hbWUsXG4gICAgbWluTGVuZ3RoOiBtaW5MZW5ndGgsXG4gICAgcm93TnVtYmVyOiAwLFxuICAgIGNlbGw6IFwiXCIsXG4gIH1cblxuICByZXR1cm4geyBpc0Vycm9yRXhwciwgZXJyb3JUZW1wbGF0ZSB9XG59XG4iXX0=

package/build/field/checks/minLength.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/field/checks/minLength.spec.js

@@ -0,0 +1,56 @@
+import * as pl from "nodejs-polars";
+import { describe, expect, it } from "vitest";
+import { inspectTable } from "../../table/index.js";
+describe("inspectTable (cell/minLength)", () => {
+    it("should not errors for string values that meet the minLength constraint", async () => {
+        const table = pl
+            .DataFrame({
+            code: ["A123", "B456", "C789"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "code",
+                    type: "string",
+                    constraints: { minLength: 3 },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toHaveLength(0);
+    });
+    it("should report an error for strings that are too short", async () => {
+        const table = pl
+            .DataFrame({
+            username: ["bob", "a", "christopher", "ab"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "username",
+                    type: "string",
+                    constraints: { minLength: 3 },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors.filter(e => e.type === "cell/minLength")).toHaveLength(2);
+        expect(errors).toContainEqual({
+            type: "cell/minLength",
+            fieldName: "username",
+            minLength: 3,
+            rowNumber: 2,
+            cell: "a",
+        });
+        expect(errors).toContainEqual({
+            type: "cell/minLength",
+            fieldName: "username",
+            minLength: 3,
+            rowNumber: 4,
+            cell: "ab",
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/field/checks/minimum.d.ts

@@ -0,0 +1,11 @@
+import type { Field } from "@frictionless-ts/metadata";
+import type { CellExclusiveMinimumError } from "@frictionless-ts/metadata";
+import type { CellMinimumError } from "@frictionless-ts/metadata";
+import * as pl from "nodejs-polars";
+import type { CellMapping } from "../Mapping.ts";
+export declare function createCheckCellMinimum(options?: {
+    isExclusive?: boolean;
+}): (field: Field, mapping: CellMapping) => {
+    isErrorExpr: pl.Expr;
+    errorTemplate: CellMinimumError | CellExclusiveMinimumError;
+} | undefined;