@frictionless-ts/table 1.0.1

package/build/schema/infer.spec.js

@@ -0,0 +1,304 @@
+import * as pl from "nodejs-polars";
+import { describe, expect, it } from "vitest";
+import { inferSchemaFromTable } from "./infer.js";
+describe("inferSchemaFromTable", () => {
+    it("should infer from native types", async () => {
+        const table = pl
+            .DataFrame({
+            integer: pl.Series("integer", [1, 2], pl.Int32),
+            number: [1.1, 2.2],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                { name: "integer", type: "integer" },
+                { name: "number", type: "number" },
+            ],
+        };
+        expect(await inferSchemaFromTable(table)).toEqual(schema);
+    });
+    it("should infer integers from floats", async () => {
+        const table = pl
+            .DataFrame({
+            id: [1.0, 2.0, 3.0],
+            count: [10.0, 20.0, 30.0],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                { name: "id", type: "integer" },
+                { name: "count", type: "integer" },
+            ],
+        };
+        expect(await inferSchemaFromTable(table)).toEqual(schema);
+    });
+    it("should infer numeric", async () => {
+        const table = pl
+            .DataFrame({
+            name1: ["1", "2", "3"],
+            name2: ["1,000", "2,000", "3,000"],
+            name3: ["1.1", "2.2", "3.3"],
+            name4: ["1,000.1", "2,000.2", "3,000.3"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                { name: "name1", type: "integer" },
+                { name: "name2", type: "integer", groupChar: "," },
+                { name: "name3", type: "number" },
+                { name: "name4", type: "number", groupChar: "," },
+            ],
+        };
+        expect(await inferSchemaFromTable(table)).toEqual(schema);
+    });
+    it("should infer numeric (commaDecimal)", async () => {
+        const table = pl
+            .DataFrame({
+            name1: ["1.000", "2.000", "3.000"],
+            name2: ["1.000,5", "2.000,5", "3.000,5"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                { name: "name1", type: "integer", groupChar: "." },
+                { name: "name2", type: "number", decimalChar: ",", groupChar: "." },
+            ],
+        };
+        expect(await inferSchemaFromTable(table, { commaDecimal: true })).toEqual(schema);
+    });
+    it("should infer booleans", async () => {
+        const table = pl
+            .DataFrame({
+            name1: ["true", "True", "TRUE"],
+            name2: ["false", "False", "FALSE"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                { name: "name1", type: "boolean" },
+                { name: "name2", type: "boolean" },
+            ],
+        };
+        expect(await inferSchemaFromTable(table)).toEqual(schema);
+    });
+    it("should infer objects", async () => {
+        const table = pl
+            .DataFrame({
+            name1: ['{"a": 1}'],
+            name2: ["{}"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                { name: "name1", type: "object" },
+                { name: "name2", type: "object" },
+            ],
+        };
+        expect(await inferSchemaFromTable(table)).toEqual(schema);
+    });
+    it("should infer arrays", async () => {
+        const table = pl
+            .DataFrame({
+            name1: ["[1,2,3]"],
+            name2: ["[]"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                { name: "name1", type: "array" },
+                { name: "name2", type: "array" },
+            ],
+        };
+        expect(await inferSchemaFromTable(table)).toEqual(schema);
+    });
+    it("should infer dates with ISO format", async () => {
+        const table = pl
+            .DataFrame({
+            name1: ["2023-01-15", "2023-02-20", "2023-03-25"],
+        })
+            .lazy();
+        const schema = {
+            fields: [{ name: "name1", type: "date" }],
+        };
+        expect(await inferSchemaFromTable(table)).toEqual(schema);
+    });
+    it("should infer dates with slash format", async () => {
+        const table = pl
+            .DataFrame({
+            yearFirst: ["2023/01/15", "2023/02/20", "2023/03/25"],
+            dayMonth: ["15/01/2023", "20/02/2023", "25/03/2023"],
+            monthDay: ["01/15/2023", "02/20/2023", "03/25/2023"],
+        })
+            .lazy();
+        const schemaDefault = {
+            fields: [
+                { name: "yearFirst", type: "date", format: "%Y/%m/%d" },
+                { name: "dayMonth", type: "date", format: "%d/%m/%Y" },
+                { name: "monthDay", type: "date", format: "%d/%m/%Y" },
+            ],
+        };
+        const schemaMonthFirst = {
+            fields: [
+                { name: "yearFirst", type: "date", format: "%Y/%m/%d" },
+                { name: "dayMonth", type: "date", format: "%m/%d/%Y" },
+                { name: "monthDay", type: "date", format: "%m/%d/%Y" },
+            ],
+        };
+        expect(await inferSchemaFromTable(table)).toEqual(schemaDefault);
+        expect(await inferSchemaFromTable(table, { monthFirst: true })).toEqual(schemaMonthFirst);
+    });
+    it("should infer dates with hyphen format", async () => {
+        const table = pl
+            .DataFrame({
+            dayMonth: ["15-01-2023", "20-02-2023", "25-03-2023"],
+        })
+            .lazy();
+        const schemaDefault = {
+            fields: [{ name: "dayMonth", type: "date", format: "%d-%m-%Y" }],
+        };
+        const schemaMonthFirst = {
+            fields: [{ name: "dayMonth", type: "date", format: "%m-%d-%Y" }],
+        };
+        expect(await inferSchemaFromTable(table)).toEqual(schemaDefault);
+        expect(await inferSchemaFromTable(table, { monthFirst: true })).toEqual(schemaMonthFirst);
+    });
+    it("should infer times with standard format", async () => {
+        const table = pl
+            .DataFrame({
+            fullTime: ["14:30:45", "08:15:30", "23:59:59"],
+            shortTime: ["14:30", "08:15", "23:59"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                { name: "fullTime", type: "time" },
+                { name: "shortTime", type: "time", format: "%H:%M" },
+            ],
+        };
+        expect(await inferSchemaFromTable(table)).toEqual(schema);
+    });
+    it("should infer times with 12-hour format", async () => {
+        const table = pl
+            .DataFrame({
+            fullTime: ["2:30:45 PM", "8:15:30 AM", "11:59:59 PM"],
+            shortTime: ["2:30 PM", "8:15 AM", "11:59 PM"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                { name: "fullTime", type: "time", format: "%I:%M:%S %p" },
+                { name: "shortTime", type: "time", format: "%I:%M %p" },
+            ],
+        };
+        expect(await inferSchemaFromTable(table)).toEqual(schema);
+    });
+    it("should infer times with timezone offset", async () => {
+        const table = pl
+            .DataFrame({
+            name: ["14:30:45+01:00", "08:15:30-05:00", "23:59:59+00:00"],
+        })
+            .lazy();
+        const schema = {
+            fields: [{ name: "name", type: "time" }],
+        };
+        expect(await inferSchemaFromTable(table)).toEqual(schema);
+    });
+    it("should infer datetimes with ISO format", async () => {
+        const table = pl
+            .DataFrame({
+            standard: [
+                "2023-01-15T14:30:45",
+                "2023-02-20T08:15:30",
+                "2023-03-25T23:59:59",
+            ],
+            utc: [
+                "2023-01-15T14:30:45Z",
+                "2023-02-20T08:15:30Z",
+                "2023-03-25T23:59:59Z",
+            ],
+            withTz: [
+                "2023-01-15T14:30:45+01:00",
+                "2023-02-20T08:15:30-05:00",
+                "2023-03-25T23:59:59+00:00",
+            ],
+            withSpace: [
+                "2023-01-15 14:30:45",
+                "2023-02-20 08:15:30",
+                "2023-03-25 23:59:59",
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                { name: "standard", type: "datetime" },
+                { name: "utc", type: "datetime" },
+                { name: "withTz", type: "datetime" },
+                { name: "withSpace", type: "datetime", format: "%Y-%m-%d %H:%M:%S" },
+            ],
+        };
+        expect(await inferSchemaFromTable(table)).toEqual(schema);
+    });
+    it("should infer datetimes with custom formats", async () => {
+        const table = pl
+            .DataFrame({
+            shortDayMonth: [
+                "15/01/2023 14:30",
+                "20/02/2023 08:15",
+                "25/03/2023 23:59",
+            ],
+            fullDayMonth: [
+                "15/01/2023 14:30:45",
+                "20/02/2023 08:15:30",
+                "25/03/2023 23:59:59",
+            ],
+            shortMonthDay: [
+                "01/15/2023 14:30",
+                "02/20/2023 08:15",
+                "03/25/2023 23:59",
+            ],
+            fullMonthDay: [
+                "01/15/2023 14:30:45",
+                "02/20/2023 08:15:30",
+                "03/25/2023 23:59:59",
+            ],
+        })
+            .lazy();
+        const schemaDefault = {
+            fields: [
+                { name: "shortDayMonth", type: "datetime", format: "%d/%m/%Y %H:%M" },
+                { name: "fullDayMonth", type: "datetime", format: "%d/%m/%Y %H:%M:%S" },
+                { name: "shortMonthDay", type: "datetime", format: "%d/%m/%Y %H:%M" },
+                { name: "fullMonthDay", type: "datetime", format: "%d/%m/%Y %H:%M:%S" },
+            ],
+        };
+        const schemaMonthFirst = {
+            fields: [
+                { name: "shortDayMonth", type: "datetime", format: "%m/%d/%Y %H:%M" },
+                { name: "fullDayMonth", type: "datetime", format: "%m/%d/%Y %H:%M:%S" },
+                { name: "shortMonthDay", type: "datetime", format: "%m/%d/%Y %H:%M" },
+                { name: "fullMonthDay", type: "datetime", format: "%m/%d/%Y %H:%M:%S" },
+            ],
+        };
+        expect(await inferSchemaFromTable(table)).toEqual(schemaDefault);
+        expect(await inferSchemaFromTable(table, { monthFirst: true })).toEqual(schemaMonthFirst);
+    });
+    it("should infer lists", async () => {
+        const table = pl
+            .DataFrame({
+            numericList: ["1.5,2.3", "4.1,5.9", "7.2,8.6"],
+            integerList: ["1,2", "3,4", "5,6"],
+            singleValue: ["1.5", "2.3", "4.1"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                { name: "numericList", type: "list", itemType: "number" },
+                { name: "integerList", type: "list", itemType: "integer" },
+                { name: "singleValue", type: "number" },
+            ],
+            missingValues: undefined,
+        };
+        expect(await inferSchemaFromTable(table)).toEqual(schema);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"infer.spec.js","sourceRoot":"","sources":["../../schema/infer.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import * as pl from \"nodejs-polars\"\nimport { describe, expect, it } from \"vitest\"\nimport { inferSchemaFromTable } from \"./infer.ts\"\n\ndescribe(\"inferSchemaFromTable\", () => {\n  it(\"should infer from native types\", async () => {\n    const table = pl\n      .DataFrame({\n        integer: pl.Series(\"integer\", [1, 2], pl.Int32),\n        number: [1.1, 2.2],\n      })\n      .lazy()\n\n    const schema = {\n      fields: [\n        { name: \"integer\", type: \"integer\" },\n        { name: \"number\", type: \"number\" },\n      ],\n    }\n\n    expect(await inferSchemaFromTable(table)).toEqual(schema)\n  })\n\n  it(\"should infer integers from floats\", async () => {\n    const table = pl\n      .DataFrame({\n        id: [1.0, 2.0, 3.0],\n        count: [10.0, 20.0, 30.0],\n      })\n      .lazy()\n\n    const schema = {\n      fields: [\n        { name: \"id\", type: \"integer\" },\n        { name: \"count\", type: \"integer\" },\n      ],\n    }\n\n    expect(await inferSchemaFromTable(table)).toEqual(schema)\n  })\n\n  it(\"should infer numeric\", async () => {\n    const table = pl\n      .DataFrame({\n        name1: [\"1\", \"2\", \"3\"],\n        name2: [\"1,000\", \"2,000\", \"3,000\"],\n        name3: [\"1.1\", \"2.2\", \"3.3\"],\n        name4: [\"1,000.1\", \"2,000.2\", \"3,000.3\"],\n      })\n      .lazy()\n\n    const schema = {\n      fields: [\n        { name: \"name1\", type: \"integer\" },\n        { name: \"name2\", type: \"integer\", groupChar: \",\" },\n        { name: \"name3\", type: \"number\" },\n        { name: \"name4\", type: \"number\", groupChar: \",\" },\n      ],\n    }\n\n    expect(await inferSchemaFromTable(table)).toEqual(schema)\n  })\n\n  it(\"should infer numeric (commaDecimal)\", async () => {\n    const table = pl\n      .DataFrame({\n        name1: [\"1.000\", \"2.000\", \"3.000\"],\n        name2: [\"1.000,5\", \"2.000,5\", \"3.000,5\"],\n      })\n      .lazy()\n\n    const schema = {\n      fields: [\n        { name: \"name1\", type: \"integer\", groupChar: \".\" },\n        { name: \"name2\", type: \"number\", decimalChar: \",\", groupChar: \".\" },\n      ],\n    }\n\n    expect(await inferSchemaFromTable(table, { commaDecimal: true })).toEqual(\n      schema,\n    )\n  })\n\n  it(\"should infer booleans\", async () => {\n    const table = pl\n      .DataFrame({\n        name1: [\"true\", \"True\", \"TRUE\"],\n        name2: [\"false\", \"False\", \"FALSE\"],\n      })\n      .lazy()\n\n    const schema = {\n      fields: [\n        { name: \"name1\", type: \"boolean\" },\n        { name: \"name2\", type: \"boolean\" },\n      ],\n    }\n\n    expect(await inferSchemaFromTable(table)).toEqual(schema)\n  })\n\n  it(\"should infer objects\", async () => {\n    const table = pl\n      .DataFrame({\n        name1: ['{\"a\": 1}'],\n        name2: [\"{}\"],\n      })\n      .lazy()\n\n    const schema = {\n      fields: [\n        { name: \"name1\", type: \"object\" },\n        { name: \"name2\", type: \"object\" },\n      ],\n    }\n\n    expect(await inferSchemaFromTable(table)).toEqual(schema)\n  })\n\n  it(\"should infer arrays\", async () => {\n    const table = pl\n      .DataFrame({\n        name1: [\"[1,2,3]\"],\n        name2: [\"[]\"],\n      })\n      .lazy()\n\n    const schema = {\n      fields: [\n        { name: \"name1\", type: \"array\" },\n        { name: \"name2\", type: \"array\" },\n      ],\n    }\n\n    expect(await inferSchemaFromTable(table)).toEqual(schema)\n  })\n\n  it(\"should infer dates with ISO format\", async () => {\n    const table = pl\n      .DataFrame({\n        name1: [\"2023-01-15\", \"2023-02-20\", \"2023-03-25\"],\n      })\n      .lazy()\n\n    const schema = {\n      fields: [{ name: \"name1\", type: \"date\" }],\n    }\n\n    expect(await inferSchemaFromTable(table)).toEqual(schema)\n  })\n\n  it(\"should infer dates with slash format\", async () => {\n    const table = pl\n      .DataFrame({\n        yearFirst: [\"2023/01/15\", \"2023/02/20\", \"2023/03/25\"],\n        dayMonth: [\"15/01/2023\", \"20/02/2023\", \"25/03/2023\"],\n        monthDay: [\"01/15/2023\", \"02/20/2023\", \"03/25/2023\"],\n      })\n      .lazy()\n\n    const schemaDefault = {\n      fields: [\n        { name: \"yearFirst\", type: \"date\", format: \"%Y/%m/%d\" },\n        { name: \"dayMonth\", type: \"date\", format: \"%d/%m/%Y\" },\n        { name: \"monthDay\", type: \"date\", format: \"%d/%m/%Y\" },\n      ],\n    }\n\n    const schemaMonthFirst = {\n      fields: [\n        { name: \"yearFirst\", type: \"date\", format: \"%Y/%m/%d\" },\n        { name: \"dayMonth\", type: \"date\", format: \"%m/%d/%Y\" },\n        { name: \"monthDay\", type: \"date\", format: \"%m/%d/%Y\" },\n      ],\n    }\n\n    expect(await inferSchemaFromTable(table)).toEqual(schemaDefault)\n    expect(await inferSchemaFromTable(table, { monthFirst: true })).toEqual(\n      schemaMonthFirst,\n    )\n  })\n\n  it(\"should infer dates with hyphen format\", async () => {\n    const table = pl\n      .DataFrame({\n        dayMonth: [\"15-01-2023\", \"20-02-2023\", \"25-03-2023\"],\n      })\n      .lazy()\n\n    const schemaDefault = {\n      fields: [{ name: \"dayMonth\", type: \"date\", format: \"%d-%m-%Y\" }],\n    }\n\n    const schemaMonthFirst = {\n      fields: [{ name: \"dayMonth\", type: \"date\", format: \"%m-%d-%Y\" }],\n    }\n\n    expect(await inferSchemaFromTable(table)).toEqual(schemaDefault)\n    expect(await inferSchemaFromTable(table, { monthFirst: true })).toEqual(\n      schemaMonthFirst,\n    )\n  })\n\n  it(\"should infer times with standard format\", async () => {\n    const table = pl\n      .DataFrame({\n        fullTime: [\"14:30:45\", \"08:15:30\", \"23:59:59\"],\n        shortTime: [\"14:30\", \"08:15\", \"23:59\"],\n      })\n      .lazy()\n\n    const schema = {\n      fields: [\n        { name: \"fullTime\", type: \"time\" },\n        { name: \"shortTime\", type: \"time\", format: \"%H:%M\" },\n      ],\n    }\n\n    expect(await inferSchemaFromTable(table)).toEqual(schema)\n  })\n\n  it(\"should infer times with 12-hour format\", async () => {\n    const table = pl\n      .DataFrame({\n        fullTime: [\"2:30:45 PM\", \"8:15:30 AM\", \"11:59:59 PM\"],\n        shortTime: [\"2:30 PM\", \"8:15 AM\", \"11:59 PM\"],\n      })\n      .lazy()\n\n    const schema = {\n      fields: [\n        { name: \"fullTime\", type: \"time\", format: \"%I:%M:%S %p\" },\n        { name: \"shortTime\", type: \"time\", format: \"%I:%M %p\" },\n      ],\n    }\n\n    expect(await inferSchemaFromTable(table)).toEqual(schema)\n  })\n\n  it(\"should infer times with timezone offset\", async () => {\n    const table = pl\n      .DataFrame({\n        name: [\"14:30:45+01:00\", \"08:15:30-05:00\", \"23:59:59+00:00\"],\n      })\n      .lazy()\n\n    const schema = {\n      fields: [{ name: \"name\", type: \"time\" }],\n    }\n\n    expect(await inferSchemaFromTable(table)).toEqual(schema)\n  })\n\n  it(\"should infer datetimes with ISO format\", async () => {\n    const table = pl\n      .DataFrame({\n        standard: [\n          \"2023-01-15T14:30:45\",\n          \"2023-02-20T08:15:30\",\n          \"2023-03-25T23:59:59\",\n        ],\n        utc: [\n          \"2023-01-15T14:30:45Z\",\n          \"2023-02-20T08:15:30Z\",\n          \"2023-03-25T23:59:59Z\",\n        ],\n        withTz: [\n          \"2023-01-15T14:30:45+01:00\",\n          \"2023-02-20T08:15:30-05:00\",\n          \"2023-03-25T23:59:59+00:00\",\n        ],\n        withSpace: [\n          \"2023-01-15 14:30:45\",\n          \"2023-02-20 08:15:30\",\n          \"2023-03-25 23:59:59\",\n        ],\n      })\n      .lazy()\n\n    const schema = {\n      fields: [\n        { name: \"standard\", type: \"datetime\" },\n        { name: \"utc\", type: \"datetime\" },\n        { name: \"withTz\", type: \"datetime\" },\n        { name: \"withSpace\", type: \"datetime\", format: \"%Y-%m-%d %H:%M:%S\" },\n      ],\n    }\n\n    expect(await inferSchemaFromTable(table)).toEqual(schema)\n  })\n\n  it(\"should infer datetimes with custom formats\", async () => {\n    const table = pl\n      .DataFrame({\n        shortDayMonth: [\n          \"15/01/2023 14:30\",\n          \"20/02/2023 08:15\",\n          \"25/03/2023 23:59\",\n        ],\n        fullDayMonth: [\n          \"15/01/2023 14:30:45\",\n          \"20/02/2023 08:15:30\",\n          \"25/03/2023 23:59:59\",\n        ],\n        shortMonthDay: [\n          \"01/15/2023 14:30\",\n          \"02/20/2023 08:15\",\n          \"03/25/2023 23:59\",\n        ],\n        fullMonthDay: [\n          \"01/15/2023 14:30:45\",\n          \"02/20/2023 08:15:30\",\n          \"03/25/2023 23:59:59\",\n        ],\n      })\n      .lazy()\n\n    const schemaDefault = {\n      fields: [\n        { name: \"shortDayMonth\", type: \"datetime\", format: \"%d/%m/%Y %H:%M\" },\n        { name: \"fullDayMonth\", type: \"datetime\", format: \"%d/%m/%Y %H:%M:%S\" },\n        { name: \"shortMonthDay\", type: \"datetime\", format: \"%d/%m/%Y %H:%M\" },\n        { name: \"fullMonthDay\", type: \"datetime\", format: \"%d/%m/%Y %H:%M:%S\" },\n      ],\n    }\n\n    const schemaMonthFirst = {\n      fields: [\n        { name: \"shortDayMonth\", type: \"datetime\", format: \"%m/%d/%Y %H:%M\" },\n        { name: \"fullDayMonth\", type: \"datetime\", format: \"%m/%d/%Y %H:%M:%S\" },\n        { name: \"shortMonthDay\", type: \"datetime\", format: \"%m/%d/%Y %H:%M\" },\n        { name: \"fullMonthDay\", type: \"datetime\", format: \"%m/%d/%Y %H:%M:%S\" },\n      ],\n    }\n\n    expect(await inferSchemaFromTable(table)).toEqual(schemaDefault)\n    expect(await inferSchemaFromTable(table, { monthFirst: true })).toEqual(\n      schemaMonthFirst,\n    )\n  })\n\n  it(\"should infer lists\", async () => {\n    const table = pl\n      .DataFrame({\n        numericList: [\"1.5,2.3\", \"4.1,5.9\", \"7.2,8.6\"],\n        integerList: [\"1,2\", \"3,4\", \"5,6\"],\n        singleValue: [\"1.5\", \"2.3\", \"4.1\"],\n      })\n      .lazy()\n\n    const schema = {\n      fields: [\n        { name: \"numericList\", type: \"list\", itemType: \"number\" },\n        { name: \"integerList\", type: \"list\", itemType: \"integer\" },\n        { name: \"singleValue\", type: \"number\" },\n      ],\n      missingValues: undefined,\n    }\n\n    expect(await inferSchemaFromTable(table)).toEqual(schema)\n  })\n})\n"]}

package/build/schema/match.d.ts

@@ -0,0 +1,6 @@
+import type { Field } from "@frictionless-ts/metadata";
+import type { SchemaMapping } from "./Mapping.ts";
+export declare function matchSchemaField(mapping: SchemaMapping, field: Field, index: number): {
+    source: import("../index.ts").PolarsField;
+    target: Field;
+} | undefined;

package/build/schema/match.js

@@ -0,0 +1,8 @@
+export function matchSchemaField(mapping, field, index) {
+    const fieldsMatch = mapping.target.fieldsMatch ?? "exact";
+    const polarsField = fieldsMatch !== "exact"
+        ? mapping.source.fields.find(it => it.name === field.name)
+        : mapping.source.fields[index];
+    return polarsField ? { source: polarsField, target: field } : undefined;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWF0Y2guanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zY2hlbWEvbWF0Y2gudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsTUFBTSxVQUFVLGdCQUFnQixDQUM5QixPQUFzQixFQUN0QixLQUFZLEVBQ1osS0FBYTtJQUViLE1BQU0sV0FBVyxHQUFHLE9BQU8sQ0FBQyxNQUFNLENBQUMsV0FBVyxJQUFJLE9BQU8sQ0FBQTtJQUV6RCxNQUFNLFdBQVcsR0FDZixXQUFXLEtBQUssT0FBTztRQUNyQixDQUFDLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLElBQUksS0FBSyxLQUFLLENBQUMsSUFBSSxDQUFDO1FBQzFELENBQUMsQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQTtJQUVsQyxPQUFPLFdBQVcsQ0FBQyxDQUFDLENBQUMsRUFBRSxNQUFNLEVBQUUsV0FBVyxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFBO0FBQ3pFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IEZpZWxkIH0gZnJvbSBcIkBmcmljdGlvbmxlc3MtdHMvbWV0YWRhdGFcIlxuaW1wb3J0IHR5cGUgeyBTY2hlbWFNYXBwaW5nIH0gZnJvbSBcIi4vTWFwcGluZy50c1wiXG5cbmV4cG9ydCBmdW5jdGlvbiBtYXRjaFNjaGVtYUZpZWxkKFxuICBtYXBwaW5nOiBTY2hlbWFNYXBwaW5nLFxuICBmaWVsZDogRmllbGQsXG4gIGluZGV4OiBudW1iZXIsXG4pIHtcbiAgY29uc3QgZmllbGRzTWF0Y2ggPSBtYXBwaW5nLnRhcmdldC5maWVsZHNNYXRjaCA/PyBcImV4YWN0XCJcblxuICBjb25zdCBwb2xhcnNGaWVsZCA9XG4gICAgZmllbGRzTWF0Y2ggIT09IFwiZXhhY3RcIlxuICAgICAgPyBtYXBwaW5nLnNvdXJjZS5maWVsZHMuZmluZChpdCA9PiBpdC5uYW1lID09PSBmaWVsZC5uYW1lKVxuICAgICAgOiBtYXBwaW5nLnNvdXJjZS5maWVsZHNbaW5kZXhdXG5cbiAgcmV0dXJuIHBvbGFyc0ZpZWxkID8geyBzb3VyY2U6IHBvbGFyc0ZpZWxkLCB0YXJnZXQ6IGZpZWxkIH0gOiB1bmRlZmluZWRcbn1cbiJdfQ==

package/build/table/Frame.d.ts

@@ -0,0 +1,2 @@
+import type * as pl from "nodejs-polars";
+export type Frame = pl.DataFrame;

package/build/table/Frame.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRnJhbWUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90YWJsZS9GcmFtZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgKiBhcyBwbCBmcm9tIFwibm9kZWpzLXBvbGFyc1wiXG5cbmV4cG9ydCB0eXBlIEZyYW1lID0gcGwuRGF0YUZyYW1lXG4iXX0=

package/build/table/Table.d.ts

@@ -0,0 +1,2 @@
+import type * as pl from "nodejs-polars";
+export type Table = pl.LazyDataFrame;

package/build/table/Table.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVGFibGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90YWJsZS9UYWJsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgKiBhcyBwbCBmcm9tIFwibm9kZWpzLXBvbGFyc1wiXG5cbmV4cG9ydCB0eXBlIFRhYmxlID0gcGwuTGF6eURhdGFGcmFtZVxuIl19

package/build/table/checks/unique.d.ts

@@ -0,0 +1,7 @@
+import type { RowUniqueError } from "@frictionless-ts/metadata";
+import * as pl from "nodejs-polars";
+import type { SchemaMapping } from "../../schema/index.ts";
+export declare function createChecksRowUnique(mapping: SchemaMapping): {
+    isErrorExpr: pl.Expr;
+    errorTemplate: RowUniqueError;
+}[];

package/build/table/checks/unique.js

@@ -0,0 +1,23 @@
+import * as pl from "nodejs-polars";
+export function createChecksRowUnique(mapping) {
+    const uniqueKeys = mapping.target.uniqueKeys ?? [];
+    if (mapping.target.primaryKey) {
+        uniqueKeys.push(mapping.target.primaryKey);
+    }
+    return uniqueKeys.map(createCheckRowUnique);
+}
+function createCheckRowUnique(uniqueKey) {
+    const isErrorExpr = pl
+        .concatList(uniqueKey)
+        .isFirstDistinct()
+        .not()
+        // Fold is not available so we use a tricky way to eliminate nulls
+        .and(pl.concatList(uniqueKey).lst.min().isNotNull());
+    const errorTemplate = {
+        type: "row/unique",
+        fieldNames: uniqueKey,
+        rowNumber: 0,
+    };
+    return { isErrorExpr, errorTemplate };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5pcXVlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdGFibGUvY2hlY2tzL3VuaXF1ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssRUFBRSxNQUFNLGVBQWUsQ0FBQTtBQUduQyxNQUFNLFVBQVUscUJBQXFCLENBQUMsT0FBc0I7SUFDMUQsTUFBTSxVQUFVLEdBQUcsT0FBTyxDQUFDLE1BQU0sQ0FBQyxVQUFVLElBQUksRUFBRSxDQUFBO0lBRWxELElBQUksT0FBTyxDQUFDLE1BQU0sQ0FBQyxVQUFVLEVBQUUsQ0FBQztRQUM5QixVQUFVLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsVUFBVSxDQUFDLENBQUE7SUFDNUMsQ0FBQztJQUVELE9BQU8sVUFBVSxDQUFDLEdBQUcsQ0FBQyxvQkFBb0IsQ0FBQyxDQUFBO0FBQzdDLENBQUM7QUFFRCxTQUFTLG9CQUFvQixDQUFDLFNBQW1CO0lBQy9DLE1BQU0sV0FBVyxHQUFHLEVBQUU7U0FDbkIsVUFBVSxDQUFDLFNBQVMsQ0FBQztTQUNyQixlQUFlLEVBQUU7U0FDakIsR0FBRyxFQUFFO1FBQ04sa0VBQWtFO1NBQ2pFLEdBQUcsQ0FBQyxFQUFFLENBQUMsVUFBVSxDQUFDLFNBQVMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxTQUFTLEVBQUUsQ0FBQyxDQUFBO0lBRXRELE1BQU0sYUFBYSxHQUFtQjtRQUNwQyxJQUFJLEVBQUUsWUFBWTtRQUNsQixVQUFVLEVBQUUsU0FBUztRQUNyQixTQUFTLEVBQUUsQ0FBQztLQUNiLENBQUE7SUFFRCxPQUFPLEVBQUUsV0FBVyxFQUFFLGFBQWEsRUFBRSxDQUFBO0FBQ3ZDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFJvd1VuaXF1ZUVycm9yIH0gZnJvbSBcIkBmcmljdGlvbmxlc3MtdHMvbWV0YWRhdGFcIlxuaW1wb3J0ICogYXMgcGwgZnJvbSBcIm5vZGVqcy1wb2xhcnNcIlxuaW1wb3J0IHR5cGUgeyBTY2hlbWFNYXBwaW5nIH0gZnJvbSBcIi4uLy4uL3NjaGVtYS9pbmRleC50c1wiXG5cbmV4cG9ydCBmdW5jdGlvbiBjcmVhdGVDaGVja3NSb3dVbmlxdWUobWFwcGluZzogU2NoZW1hTWFwcGluZykge1xuICBjb25zdCB1bmlxdWVLZXlzID0gbWFwcGluZy50YXJnZXQudW5pcXVlS2V5cyA/PyBbXVxuXG4gIGlmIChtYXBwaW5nLnRhcmdldC5wcmltYXJ5S2V5KSB7XG4gICAgdW5pcXVlS2V5cy5wdXNoKG1hcHBpbmcudGFyZ2V0LnByaW1hcnlLZXkpXG4gIH1cblxuICByZXR1cm4gdW5pcXVlS2V5cy5tYXAoY3JlYXRlQ2hlY2tSb3dVbmlxdWUpXG59XG5cbmZ1bmN0aW9uIGNyZWF0ZUNoZWNrUm93VW5pcXVlKHVuaXF1ZUtleTogc3RyaW5nW10pIHtcbiAgY29uc3QgaXNFcnJvckV4cHIgPSBwbFxuICAgIC5jb25jYXRMaXN0KHVuaXF1ZUtleSlcbiAgICAuaXNGaXJzdERpc3RpbmN0KClcbiAgICAubm90KClcbiAgICAvLyBGb2xkIGlzIG5vdCBhdmFpbGFibGUgc28gd2UgdXNlIGEgdHJpY2t5IHdheSB0byBlbGltaW5hdGUgbnVsbHNcbiAgICAuYW5kKHBsLmNvbmNhdExpc3QodW5pcXVlS2V5KS5sc3QubWluKCkuaXNOb3ROdWxsKCkpXG5cbiAgY29uc3QgZXJyb3JUZW1wbGF0ZTogUm93VW5pcXVlRXJyb3IgPSB7XG4gICAgdHlwZTogXCJyb3cvdW5pcXVlXCIsXG4gICAgZmllbGROYW1lczogdW5pcXVlS2V5LFxuICAgIHJvd051bWJlcjogMCxcbiAgfVxuXG4gIHJldHVybiB7IGlzRXJyb3JFeHByLCBlcnJvclRlbXBsYXRlIH1cbn1cbiJdfQ==

package/build/table/checks/unique.spec.d.ts

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

package/build/table/checks/unique.spec.js

@@ -0,0 +1,187 @@
+import * as pl from "nodejs-polars";
+import { describe, expect, it } from "vitest";
+import { inspectTable } from "../../table/index.js";
+describe("inspectTable (row/unique)", () => {
+    it("should not errors when all rows are unique for primary key", async () => {
+        const table = pl
+            .DataFrame({
+            id: [1, 2, 3, 4, 5],
+            name: ["Alice", "Bob", "Charlie", "David", "Eve"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                { name: "id", type: "number" },
+                { name: "name", type: "string" },
+            ],
+            primaryKey: ["id"],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toHaveLength(0);
+    });
+    it("should errors for duplicate primary key rows", async () => {
+        const table = pl
+            .DataFrame({
+            id: [1, 2, 3, 2, 5],
+            name: ["Alice", "Bob", "Charlie", "Bob2", "Eve"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                { name: "id", type: "number" },
+                { name: "name", type: "string" },
+            ],
+            primaryKey: ["id"],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors.filter(e => e.type === "row/unique")).toHaveLength(1);
+        expect(errors).toContainEqual({
+            type: "row/unique",
+            rowNumber: 4,
+            fieldNames: ["id"],
+        });
+    });
+    it("should not errors when all rows are unique for unique key", async () => {
+        const table = pl
+            .DataFrame({
+            id: [1, 2, 3, 4, 5],
+            email: [
+                "a@test.com",
+                "b@test.com",
+                "c@test.com",
+                "d@test.com",
+                "e@test.com",
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                { name: "id", type: "number" },
+                { name: "email", type: "string" },
+            ],
+            uniqueKeys: [["email"]],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toHaveLength(0);
+    });
+    it("should errors for duplicate unique key rows", async () => {
+        const table = pl
+            .DataFrame({
+            id: [1, 2, 3, 4, 5],
+            email: [
+                "a@test.com",
+                "b@test.com",
+                "a@test.com",
+                "d@test.com",
+                "b@test.com",
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                { name: "id", type: "number" },
+                { name: "email", type: "string" },
+            ],
+            uniqueKeys: [["email"]],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors.filter(e => e.type === "row/unique")).toHaveLength(2);
+        expect(errors).toContainEqual({
+            type: "row/unique",
+            rowNumber: 3,
+            fieldNames: ["email"],
+        });
+        expect(errors).toContainEqual({
+            type: "row/unique",
+            rowNumber: 5,
+            fieldNames: ["email"],
+        });
+    });
+    it("should handle composite unique keys", async () => {
+        const table = pl
+            .DataFrame({
+            category: ["A", "A", "B", "A", "B"],
+            subcategory: ["X", "Y", "X", "X", "Y"],
+            value: [1, 2, 3, 4, 5],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                { name: "category", type: "string" },
+                { name: "subcategory", type: "string" },
+                { name: "value", type: "number" },
+            ],
+            uniqueKeys: [["category", "subcategory"]],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors.filter(e => e.type === "row/unique")).toHaveLength(1);
+        expect(errors).toContainEqual({
+            type: "row/unique",
+            rowNumber: 4,
+            fieldNames: ["category", "subcategory"],
+        });
+    });
+    it("should handle both primary key and unique keys", async () => {
+        const table = pl
+            .DataFrame({
+            id: [1, 2, 3, 2, 5],
+            email: [
+                "a@test.com",
+                "b@test.com",
+                "c@test.com",
+                "d@test.com",
+                "a@test.com",
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                { name: "id", type: "number" },
+                { name: "email", type: "string" },
+            ],
+            primaryKey: ["id"],
+            uniqueKeys: [["email"]],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors.filter(e => e.type === "row/unique")).toHaveLength(2);
+        expect(errors).toContainEqual({
+            type: "row/unique",
+            rowNumber: 4,
+            fieldNames: ["id"],
+        });
+        expect(errors).toContainEqual({
+            type: "row/unique",
+            rowNumber: 5,
+            fieldNames: ["email"],
+        });
+    });
+    it("should handle null values in unique keys correctly", async () => {
+        const table = pl
+            .DataFrame({
+            id: [1, 2, null, 4, null, 2],
+            name: ["Alice", "Bob", "Charlie", "David", "Eve", "Bob"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                { name: "id", type: "number" },
+                { name: "name", type: "string" },
+            ],
+            uniqueKeys: [["id"], ["id", "name"]],
+        };
+        const errors = await inspectTable(table, { schema });
+        console.log(errors);
+        expect(errors).toHaveLength(2);
+        expect(errors).toContainEqual({
+            type: "row/unique",
+            rowNumber: 6,
+            fieldNames: ["id"],
+        });
+        expect(errors).toContainEqual({
+            type: "row/unique",
+            rowNumber: 6,
+            fieldNames: ["id", "name"],
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"unique.spec.js","sourceRoot":"","sources":["../../../table/checks/unique.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 (row/unique)\", () => {\n  it(\"should not errors when all rows are unique for primary key\", async () => {\n    const table = pl\n      .DataFrame({\n        id: [1, 2, 3, 4, 5],\n        name: [\"Alice\", \"Bob\", \"Charlie\", \"David\", \"Eve\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        { name: \"id\", type: \"number\" },\n        { name: \"name\", type: \"string\" },\n      ],\n      primaryKey: [\"id\"],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toHaveLength(0)\n  })\n\n  it(\"should errors for duplicate primary key rows\", async () => {\n    const table = pl\n      .DataFrame({\n        id: [1, 2, 3, 2, 5],\n        name: [\"Alice\", \"Bob\", \"Charlie\", \"Bob2\", \"Eve\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        { name: \"id\", type: \"number\" },\n        { name: \"name\", type: \"string\" },\n      ],\n      primaryKey: [\"id\"],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors.filter(e => e.type === \"row/unique\")).toHaveLength(1)\n    expect(errors).toContainEqual({\n      type: \"row/unique\",\n      rowNumber: 4,\n      fieldNames: [\"id\"],\n    })\n  })\n\n  it(\"should not errors when all rows are unique for unique key\", async () => {\n    const table = pl\n      .DataFrame({\n        id: [1, 2, 3, 4, 5],\n        email: [\n          \"a@test.com\",\n          \"b@test.com\",\n          \"c@test.com\",\n          \"d@test.com\",\n          \"e@test.com\",\n        ],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        { name: \"id\", type: \"number\" },\n        { name: \"email\", type: \"string\" },\n      ],\n      uniqueKeys: [[\"email\"]],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toHaveLength(0)\n  })\n\n  it(\"should errors for duplicate unique key rows\", async () => {\n    const table = pl\n      .DataFrame({\n        id: [1, 2, 3, 4, 5],\n        email: [\n          \"a@test.com\",\n          \"b@test.com\",\n          \"a@test.com\",\n          \"d@test.com\",\n          \"b@test.com\",\n        ],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        { name: \"id\", type: \"number\" },\n        { name: \"email\", type: \"string\" },\n      ],\n      uniqueKeys: [[\"email\"]],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors.filter(e => e.type === \"row/unique\")).toHaveLength(2)\n    expect(errors).toContainEqual({\n      type: \"row/unique\",\n      rowNumber: 3,\n      fieldNames: [\"email\"],\n    })\n    expect(errors).toContainEqual({\n      type: \"row/unique\",\n      rowNumber: 5,\n      fieldNames: [\"email\"],\n    })\n  })\n\n  it(\"should handle composite unique keys\", async () => {\n    const table = pl\n      .DataFrame({\n        category: [\"A\", \"A\", \"B\", \"A\", \"B\"],\n        subcategory: [\"X\", \"Y\", \"X\", \"X\", \"Y\"],\n        value: [1, 2, 3, 4, 5],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        { name: \"category\", type: \"string\" },\n        { name: \"subcategory\", type: \"string\" },\n        { name: \"value\", type: \"number\" },\n      ],\n      uniqueKeys: [[\"category\", \"subcategory\"]],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors.filter(e => e.type === \"row/unique\")).toHaveLength(1)\n    expect(errors).toContainEqual({\n      type: \"row/unique\",\n      rowNumber: 4,\n      fieldNames: [\"category\", \"subcategory\"],\n    })\n  })\n\n  it(\"should handle both primary key and unique keys\", async () => {\n    const table = pl\n      .DataFrame({\n        id: [1, 2, 3, 2, 5],\n        email: [\n          \"a@test.com\",\n          \"b@test.com\",\n          \"c@test.com\",\n          \"d@test.com\",\n          \"a@test.com\",\n        ],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        { name: \"id\", type: \"number\" },\n        { name: \"email\", type: \"string\" },\n      ],\n      primaryKey: [\"id\"],\n      uniqueKeys: [[\"email\"]],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors.filter(e => e.type === \"row/unique\")).toHaveLength(2)\n    expect(errors).toContainEqual({\n      type: \"row/unique\",\n      rowNumber: 4,\n      fieldNames: [\"id\"],\n    })\n    expect(errors).toContainEqual({\n      type: \"row/unique\",\n      rowNumber: 5,\n      fieldNames: [\"email\"],\n    })\n  })\n\n  it(\"should handle null values in unique keys correctly\", async () => {\n    const table = pl\n      .DataFrame({\n        id: [1, 2, null, 4, null, 2],\n        name: [\"Alice\", \"Bob\", \"Charlie\", \"David\", \"Eve\", \"Bob\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        { name: \"id\", type: \"number\" },\n        { name: \"name\", type: \"string\" },\n      ],\n      uniqueKeys: [[\"id\"], [\"id\", \"name\"]],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    console.log(errors)\n\n    expect(errors).toHaveLength(2)\n    expect(errors).toContainEqual({\n      type: \"row/unique\",\n      rowNumber: 6,\n      fieldNames: [\"id\"],\n    })\n    expect(errors).toContainEqual({\n      type: \"row/unique\",\n      rowNumber: 6,\n      fieldNames: [\"id\", \"name\"],\n    })\n  })\n})\n"]}