frictionless-ts 1.0.1

package/build/table/load.spec.js

@@ -0,0 +1,121 @@
+import { writeTempFile } from "@frictionless-ts/dataset";
+import { describe, expect, it } from "vitest";
+import { loadTable } from "./load.js";
+describe("loadTable", () => {
+    it("should load table from CSV file", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n2,bob");
+        const resource = { path: csvPath, format: "csv" };
+        const table = await loadTable(resource);
+        expect(table).toBeDefined();
+        expect(typeof table).toBe("object");
+    });
+    it("should load table from inline data", async () => {
+        const resource = {
+            name: "test-resource",
+            type: "table",
+            data: [
+                { id: 1, name: "alice" },
+                { id: 2, name: "bob" },
+            ],
+        };
+        const table = await loadTable(resource);
+        expect(table).toBeDefined();
+        expect(typeof table).toBe("object");
+    });
+    it("should load table with schema", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n2,bob");
+        const resource = {
+            path: csvPath,
+            format: "csv",
+            schema: {
+                fields: [
+                    { name: "id", type: "integer" },
+                    { name: "name", type: "string" },
+                ],
+            },
+        };
+        const table = await loadTable(resource);
+        expect(table).toBeDefined();
+        expect(typeof table).toBe("object");
+    });
+    it("should load table with custom delimiter", async () => {
+        const csvPath = await writeTempFile("id|name\n1|alice\n2|bob");
+        const resource = {
+            path: csvPath,
+            format: "csv",
+            dialect: { delimiter: "|" },
+        };
+        const table = await loadTable(resource);
+        expect(table).toBeDefined();
+        expect(typeof table).toBe("object");
+    });
+    it("should load denormalized table", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n2,bob");
+        const resource = { path: csvPath, format: "csv" };
+        const table = await loadTable(resource, { denormalized: true });
+        expect(table).toBeDefined();
+        expect(typeof table).toBe("object");
+    });
+    it("should load table with different data types", async () => {
+        const csvPath = await writeTempFile("id,name,score,active\n1,alice,95.5,true\n2,bob,87.3,false");
+        const resource = { path: csvPath, format: "csv" };
+        const table = await loadTable(resource);
+        expect(table).toBeDefined();
+        expect(typeof table).toBe("object");
+    });
+    it("should load table with empty rows", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n\n2,bob");
+        const resource = { path: csvPath, format: "csv" };
+        const table = await loadTable(resource);
+        expect(table).toBeDefined();
+    });
+    it("should load table with quoted fields", async () => {
+        const csvPath = await writeTempFile('id,name,description\n1,"alice","Test, data"\n2,"bob","Normal"');
+        const resource = { path: csvPath, format: "csv" };
+        const table = await loadTable(resource);
+        expect(table).toBeDefined();
+        expect(typeof table).toBe("object");
+    });
+    it("should load single row table", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice");
+        const resource = { path: csvPath, format: "csv" };
+        const table = await loadTable(resource);
+        expect(table).toBeDefined();
+        expect(typeof table).toBe("object");
+    });
+    it("should load table with numeric values", async () => {
+        const csvPath = await writeTempFile("id,score\n1,95.5\n2,87.3\n3,100");
+        const resource = { path: csvPath, format: "csv" };
+        const table = await loadTable(resource);
+        expect(table).toBeDefined();
+        expect(typeof table).toBe("object");
+    });
+    it("should load table with date values", async () => {
+        const csvPath = await writeTempFile("id,created\n1,2024-01-01\n2,2024-01-02");
+        const resource = { path: csvPath, format: "csv" };
+        const table = await loadTable(resource);
+        expect(table).toBeDefined();
+        expect(typeof table).toBe("object");
+    });
+    it("should load table with boolean values", async () => {
+        const csvPath = await writeTempFile("id,active\n1,true\n2,false\n3,true");
+        const resource = { path: csvPath, format: "csv" };
+        const table = await loadTable(resource);
+        expect(table).toBeDefined();
+        expect(typeof table).toBe("object");
+    });
+    it("should load empty table with headers only", async () => {
+        const csvPath = await writeTempFile("id,name,age");
+        const resource = { path: csvPath, format: "csv" };
+        const table = await loadTable(resource);
+        expect(table).toBeDefined();
+    });
+    it("should load table with null values", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n2,");
+        const resource = { path: csvPath, format: "csv" };
+        const table = await loadTable(resource);
+        expect(table).toBeDefined();
+        expect(typeof table).toBe("object");
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"load.spec.js","sourceRoot":"","sources":["../../table/load.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import { writeTempFile } from \"@frictionless-ts/dataset\"\nimport { describe, expect, it } from \"vitest\"\nimport { loadTable } from \"./load.ts\"\n\ndescribe(\"loadTable\", () => {\n  it(\"should load table from CSV file\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\\n2,bob\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const table = await loadTable(resource)\n\n    expect(table).toBeDefined()\n    expect(typeof table).toBe(\"object\")\n  })\n\n  it(\"should load table from inline data\", async () => {\n    const resource = {\n      name: \"test-resource\",\n      type: \"table\" as const,\n      data: [\n        { id: 1, name: \"alice\" },\n        { id: 2, name: \"bob\" },\n      ],\n    }\n\n    const table = await loadTable(resource)\n\n    expect(table).toBeDefined()\n    expect(typeof table).toBe(\"object\")\n  })\n\n  it(\"should load table with schema\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\\n2,bob\")\n    const resource = {\n      path: csvPath,\n      format: \"csv\" as const,\n      schema: {\n        fields: [\n          { name: \"id\", type: \"integer\" as const },\n          { name: \"name\", type: \"string\" as const },\n        ],\n      },\n    }\n\n    const table = await loadTable(resource)\n\n    expect(table).toBeDefined()\n    expect(typeof table).toBe(\"object\")\n  })\n\n  it(\"should load table with custom delimiter\", async () => {\n    const csvPath = await writeTempFile(\"id|name\\n1|alice\\n2|bob\")\n    const resource = {\n      path: csvPath,\n      format: \"csv\" as const,\n      dialect: { delimiter: \"|\" },\n    }\n\n    const table = await loadTable(resource)\n\n    expect(table).toBeDefined()\n    expect(typeof table).toBe(\"object\")\n  })\n\n  it(\"should load denormalized table\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\\n2,bob\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const table = await loadTable(resource, { denormalized: true })\n\n    expect(table).toBeDefined()\n    expect(typeof table).toBe(\"object\")\n  })\n\n  it(\"should load table with different data types\", async () => {\n    const csvPath = await writeTempFile(\n      \"id,name,score,active\\n1,alice,95.5,true\\n2,bob,87.3,false\",\n    )\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const table = await loadTable(resource)\n\n    expect(table).toBeDefined()\n    expect(typeof table).toBe(\"object\")\n  })\n\n  it(\"should load table with empty rows\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\\n\\n2,bob\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const table = await loadTable(resource)\n\n    expect(table).toBeDefined()\n  })\n\n  it(\"should load table with quoted fields\", async () => {\n    const csvPath = await writeTempFile(\n      'id,name,description\\n1,\"alice\",\"Test, data\"\\n2,\"bob\",\"Normal\"',\n    )\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const table = await loadTable(resource)\n\n    expect(table).toBeDefined()\n    expect(typeof table).toBe(\"object\")\n  })\n\n  it(\"should load single row table\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const table = await loadTable(resource)\n\n    expect(table).toBeDefined()\n    expect(typeof table).toBe(\"object\")\n  })\n\n  it(\"should load table with numeric values\", async () => {\n    const csvPath = await writeTempFile(\"id,score\\n1,95.5\\n2,87.3\\n3,100\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const table = await loadTable(resource)\n\n    expect(table).toBeDefined()\n    expect(typeof table).toBe(\"object\")\n  })\n\n  it(\"should load table with date values\", async () => {\n    const csvPath = await writeTempFile(\n      \"id,created\\n1,2024-01-01\\n2,2024-01-02\",\n    )\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const table = await loadTable(resource)\n\n    expect(table).toBeDefined()\n    expect(typeof table).toBe(\"object\")\n  })\n\n  it(\"should load table with boolean values\", async () => {\n    const csvPath = await writeTempFile(\"id,active\\n1,true\\n2,false\\n3,true\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const table = await loadTable(resource)\n\n    expect(table).toBeDefined()\n    expect(typeof table).toBe(\"object\")\n  })\n\n  it(\"should load empty table with headers only\", async () => {\n    const csvPath = await writeTempFile(\"id,name,age\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const table = await loadTable(resource)\n\n    expect(table).toBeDefined()\n  })\n\n  it(\"should load table with null values\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\\n2,\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const table = await loadTable(resource)\n\n    expect(table).toBeDefined()\n    expect(typeof table).toBe(\"object\")\n  })\n})\n"]}

package/build/table/save.d.ts

@@ -0,0 +1,2 @@
+import type { SaveTableOptions, Table } from "@frictionless-ts/table";
+export declare function saveTable(table: Table, options: SaveTableOptions): Promise<string>;

package/build/table/save.js

@@ -0,0 +1,11 @@
+import { system } from "../system.js";
+export async function saveTable(table, options) {
+    for (const plugin of system.plugins) {
+        const path = await plugin.saveTable?.(table, options);
+        if (path) {
+            return path;
+        }
+    }
+    throw new Error(`No plugin can save the table: ${options.path}`);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2F2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RhYmxlL3NhdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLGNBQWMsQ0FBQTtBQUVyQyxNQUFNLENBQUMsS0FBSyxVQUFVLFNBQVMsQ0FBQyxLQUFZLEVBQUUsT0FBeUI7SUFDckUsS0FBSyxNQUFNLE1BQU0sSUFBSSxNQUFNLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDcEMsTUFBTSxJQUFJLEdBQUcsTUFBTSxNQUFNLENBQUMsU0FBUyxFQUFFLENBQUMsS0FBSyxFQUFFLE9BQU8sQ0FBQyxDQUFBO1FBQ3JELElBQUksSUFBSSxFQUFFLENBQUM7WUFDVCxPQUFPLElBQUksQ0FBQTtRQUNiLENBQUM7SUFDSCxDQUFDO0lBRUQsTUFBTSxJQUFJLEtBQUssQ0FBQyxpQ0FBaUMsT0FBTyxDQUFDLElBQUksRUFBRSxDQUFDLENBQUE7QUFDbEUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgU2F2ZVRhYmxlT3B0aW9ucywgVGFibGUgfSBmcm9tIFwiQGZyaWN0aW9ubGVzcy10cy90YWJsZVwiXG5pbXBvcnQgeyBzeXN0ZW0gfSBmcm9tIFwiLi4vc3lzdGVtLnRzXCJcblxuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIHNhdmVUYWJsZSh0YWJsZTogVGFibGUsIG9wdGlvbnM6IFNhdmVUYWJsZU9wdGlvbnMpIHtcbiAgZm9yIChjb25zdCBwbHVnaW4gb2Ygc3lzdGVtLnBsdWdpbnMpIHtcbiAgICBjb25zdCBwYXRoID0gYXdhaXQgcGx1Z2luLnNhdmVUYWJsZT8uKHRhYmxlLCBvcHRpb25zKVxuICAgIGlmIChwYXRoKSB7XG4gICAgICByZXR1cm4gcGF0aFxuICAgIH1cbiAgfVxuXG4gIHRocm93IG5ldyBFcnJvcihgTm8gcGx1Z2luIGNhbiBzYXZlIHRoZSB0YWJsZTogJHtvcHRpb25zLnBhdGh9YClcbn1cbiJdfQ==

package/build/table/save.spec.d.ts

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

package/build/table/save.spec.js

@@ -0,0 +1,189 @@
+import { access, unlink } from "node:fs/promises";
+import { writeTempFile } from "@frictionless-ts/dataset";
+import { describe, expect, it } from "vitest";
+import { assert } from "vitest";
+import { loadTable } from "./load.js";
+import { saveTable } from "./save.js";
+describe("saveTable", () => {
+    it("should save table to CSV file", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n2,bob");
+        const resource = { path: csvPath, format: "csv" };
+        const table = await loadTable(resource);
+        const outputPath = await writeTempFile("");
+        await unlink(outputPath);
+        assert(table, "table is not defined");
+        const savedPath = await saveTable(table, {
+            path: outputPath,
+            format: "csv",
+        });
+        expect(savedPath).toBeDefined();
+        expect(typeof savedPath).toBe("string");
+        expect(await access(savedPath)
+            .then(() => true)
+            .catch(() => false)).toBe(true);
+        await unlink(savedPath);
+    });
+    it("should save table with format option", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n2,bob");
+        const resource = { path: csvPath, format: "csv" };
+        const table = await loadTable(resource);
+        const outputPath = await writeTempFile("");
+        await unlink(outputPath);
+        assert(table, "table is not defined");
+        const savedPath = await saveTable(table, {
+            path: outputPath,
+            format: "csv",
+        });
+        expect(savedPath).toBeDefined();
+        expect(await access(savedPath)
+            .then(() => true)
+            .catch(() => false)).toBe(true);
+        await unlink(savedPath);
+    });
+    it("should save and reload table with same data", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n2,bob");
+        const resource = { path: csvPath, format: "csv" };
+        const originalTable = await loadTable(resource);
+        const outputPath = await writeTempFile("");
+        await unlink(outputPath);
+        assert(originalTable, "table is not defined");
+        await saveTable(originalTable, {
+            path: outputPath,
+            format: "csv",
+        });
+        const reloadedTable = await loadTable({
+            path: outputPath,
+            format: "csv",
+        });
+        expect(reloadedTable).toBeDefined();
+        expect(typeof reloadedTable).toBe("object");
+        await unlink(outputPath);
+    });
+    it("should save table with different data types", async () => {
+        const csvPath = await writeTempFile("id,score,active\n1,95.5,true\n2,87.3,false");
+        const resource = { path: csvPath, format: "csv" };
+        const table = await loadTable(resource);
+        const outputPath = await writeTempFile("");
+        await unlink(outputPath);
+        assert(table, "table is not defined");
+        const savedPath = await saveTable(table, {
+            path: outputPath,
+            format: "csv",
+        });
+        expect(savedPath).toBeDefined();
+        expect(await access(savedPath)
+            .then(() => true)
+            .catch(() => false)).toBe(true);
+        await unlink(savedPath);
+    });
+    it("should save table with custom delimiter", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n2,bob");
+        const resource = { path: csvPath, format: "csv" };
+        const table = await loadTable(resource);
+        const outputPath = await writeTempFile("");
+        await unlink(outputPath);
+        assert(table, "table is not defined");
+        const savedPath = await saveTable(table, {
+            path: outputPath,
+            format: "csv",
+            delimiter: "|",
+        });
+        expect(savedPath).toBeDefined();
+        expect(await access(savedPath)
+            .then(() => true)
+            .catch(() => false)).toBe(true);
+        await unlink(savedPath);
+    });
+    it("should save table from inline data", async () => {
+        const resource = {
+            name: "test-resource",
+            type: "table",
+            data: [
+                { id: 1, name: "alice" },
+                { id: 2, name: "bob" },
+            ],
+        };
+        const table = await loadTable(resource);
+        const outputPath = await writeTempFile("");
+        await unlink(outputPath);
+        assert(table, "table is not defined");
+        const savedPath = await saveTable(table, {
+            path: outputPath,
+            format: "csv",
+        });
+        expect(savedPath).toBeDefined();
+        expect(await access(savedPath)
+            .then(() => true)
+            .catch(() => false)).toBe(true);
+        await unlink(savedPath);
+    });
+    it("should save table with special characters", async () => {
+        const csvPath = await writeTempFile('id,name,note\n1,"alice","Test, data"\n2,"bob","Normal"');
+        const resource = { path: csvPath, format: "csv" };
+        const table = await loadTable(resource);
+        const outputPath = await writeTempFile("");
+        await unlink(outputPath);
+        assert(table, "table is not defined");
+        const savedPath = await saveTable(table, {
+            path: outputPath,
+            format: "csv",
+        });
+        expect(savedPath).toBeDefined();
+        expect(await access(savedPath)
+            .then(() => true)
+            .catch(() => false)).toBe(true);
+        await unlink(savedPath);
+    });
+    it("should save table with numeric values", async () => {
+        const csvPath = await writeTempFile("id,value\n1,100\n2,200.5\n3,300");
+        const resource = { path: csvPath, format: "csv" };
+        const table = await loadTable(resource);
+        const outputPath = await writeTempFile("");
+        await unlink(outputPath);
+        assert(table, "table is not defined");
+        const savedPath = await saveTable(table, {
+            path: outputPath,
+            format: "csv",
+        });
+        expect(savedPath).toBeDefined();
+        expect(await access(savedPath)
+            .then(() => true)
+            .catch(() => false)).toBe(true);
+        await unlink(savedPath);
+    });
+    it("should save table with boolean values", async () => {
+        const csvPath = await writeTempFile("id,active\n1,true\n2,false\n3,true");
+        const resource = { path: csvPath, format: "csv" };
+        const table = await loadTable(resource);
+        const outputPath = await writeTempFile("");
+        await unlink(outputPath);
+        assert(table, "table is not defined");
+        const savedPath = await saveTable(table, {
+            path: outputPath,
+            format: "csv",
+        });
+        expect(savedPath).toBeDefined();
+        expect(await access(savedPath)
+            .then(() => true)
+            .catch(() => false)).toBe(true);
+        await unlink(savedPath);
+    });
+    it("should save table with date values", async () => {
+        const csvPath = await writeTempFile("id,created\n1,2024-01-01\n2,2024-01-02");
+        const resource = { path: csvPath, format: "csv" };
+        const table = await loadTable(resource);
+        const outputPath = await writeTempFile("");
+        await unlink(outputPath);
+        assert(table, "table is not defined");
+        const savedPath = await saveTable(table, {
+            path: outputPath,
+            format: "csv",
+        });
+        expect(savedPath).toBeDefined();
+        expect(await access(savedPath)
+            .then(() => true)
+            .catch(() => false)).toBe(true);
+        await unlink(savedPath);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"save.spec.js","sourceRoot":"","sources":["../../table/save.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import { access, unlink } from \"node:fs/promises\"\nimport { writeTempFile } from \"@frictionless-ts/dataset\"\nimport { describe, expect, it } from \"vitest\"\nimport { assert } from \"vitest\"\nimport { loadTable } from \"./load.ts\"\nimport { saveTable } from \"./save.ts\"\n\ndescribe(\"saveTable\", () => {\n  it(\"should save table to CSV file\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\\n2,bob\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n    const table = await loadTable(resource)\n    const outputPath = await writeTempFile(\"\")\n    await unlink(outputPath)\n\n    assert(table, \"table is not defined\")\n    const savedPath = await saveTable(table, {\n      path: outputPath,\n      format: \"csv\" as const,\n    })\n\n    expect(savedPath).toBeDefined()\n    expect(typeof savedPath).toBe(\"string\")\n    expect(\n      await access(savedPath)\n        .then(() => true)\n        .catch(() => false),\n    ).toBe(true)\n    await unlink(savedPath)\n  })\n\n  it(\"should save table with format option\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\\n2,bob\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n    const table = await loadTable(resource)\n    const outputPath = await writeTempFile(\"\")\n    await unlink(outputPath)\n\n    assert(table, \"table is not defined\")\n    const savedPath = await saveTable(table, {\n      path: outputPath,\n      format: \"csv\" as const,\n    })\n\n    expect(savedPath).toBeDefined()\n    expect(\n      await access(savedPath)\n        .then(() => true)\n        .catch(() => false),\n    ).toBe(true)\n    await unlink(savedPath)\n  })\n\n  it(\"should save and reload table with same data\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\\n2,bob\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n    const originalTable = await loadTable(resource)\n    const outputPath = await writeTempFile(\"\")\n    await unlink(outputPath)\n\n    assert(originalTable, \"table is not defined\")\n    await saveTable(originalTable, {\n      path: outputPath,\n      format: \"csv\" as const,\n    })\n    const reloadedTable = await loadTable({\n      path: outputPath,\n      format: \"csv\" as const,\n    })\n\n    expect(reloadedTable).toBeDefined()\n    expect(typeof reloadedTable).toBe(\"object\")\n    await unlink(outputPath)\n  })\n\n  it(\"should save table with different data types\", async () => {\n    const csvPath = await writeTempFile(\n      \"id,score,active\\n1,95.5,true\\n2,87.3,false\",\n    )\n    const resource = { path: csvPath, format: \"csv\" as const }\n    const table = await loadTable(resource)\n    const outputPath = await writeTempFile(\"\")\n    await unlink(outputPath)\n\n    assert(table, \"table is not defined\")\n    const savedPath = await saveTable(table, {\n      path: outputPath,\n      format: \"csv\" as const,\n    })\n\n    expect(savedPath).toBeDefined()\n    expect(\n      await access(savedPath)\n        .then(() => true)\n        .catch(() => false),\n    ).toBe(true)\n    await unlink(savedPath)\n  })\n\n  it(\"should save table with custom delimiter\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\\n2,bob\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n    const table = await loadTable(resource)\n    const outputPath = await writeTempFile(\"\")\n    await unlink(outputPath)\n\n    assert(table, \"table is not defined\")\n    const savedPath = await saveTable(table, {\n      path: outputPath,\n      format: \"csv\" as const,\n      delimiter: \"|\",\n    })\n\n    expect(savedPath).toBeDefined()\n    expect(\n      await access(savedPath)\n        .then(() => true)\n        .catch(() => false),\n    ).toBe(true)\n    await unlink(savedPath)\n  })\n\n  it(\"should save table from inline data\", async () => {\n    const resource = {\n      name: \"test-resource\",\n      type: \"table\" as const,\n      data: [\n        { id: 1, name: \"alice\" },\n        { id: 2, name: \"bob\" },\n      ],\n    }\n    const table = await loadTable(resource)\n    const outputPath = await writeTempFile(\"\")\n    await unlink(outputPath)\n\n    assert(table, \"table is not defined\")\n    const savedPath = await saveTable(table, {\n      path: outputPath,\n      format: \"csv\" as const,\n    })\n\n    expect(savedPath).toBeDefined()\n    expect(\n      await access(savedPath)\n        .then(() => true)\n        .catch(() => false),\n    ).toBe(true)\n    await unlink(savedPath)\n  })\n\n  it(\"should save table with special characters\", async () => {\n    const csvPath = await writeTempFile(\n      'id,name,note\\n1,\"alice\",\"Test, data\"\\n2,\"bob\",\"Normal\"',\n    )\n    const resource = { path: csvPath, format: \"csv\" as const }\n    const table = await loadTable(resource)\n    const outputPath = await writeTempFile(\"\")\n    await unlink(outputPath)\n\n    assert(table, \"table is not defined\")\n    const savedPath = await saveTable(table, {\n      path: outputPath,\n      format: \"csv\" as const,\n    })\n\n    expect(savedPath).toBeDefined()\n    expect(\n      await access(savedPath)\n        .then(() => true)\n        .catch(() => false),\n    ).toBe(true)\n    await unlink(savedPath)\n  })\n\n  it(\"should save table with numeric values\", async () => {\n    const csvPath = await writeTempFile(\"id,value\\n1,100\\n2,200.5\\n3,300\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n    const table = await loadTable(resource)\n    const outputPath = await writeTempFile(\"\")\n    await unlink(outputPath)\n\n    assert(table, \"table is not defined\")\n    const savedPath = await saveTable(table, {\n      path: outputPath,\n      format: \"csv\" as const,\n    })\n\n    expect(savedPath).toBeDefined()\n    expect(\n      await access(savedPath)\n        .then(() => true)\n        .catch(() => false),\n    ).toBe(true)\n    await unlink(savedPath)\n  })\n\n  it(\"should save table with boolean values\", async () => {\n    const csvPath = await writeTempFile(\"id,active\\n1,true\\n2,false\\n3,true\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n    const table = await loadTable(resource)\n    const outputPath = await writeTempFile(\"\")\n    await unlink(outputPath)\n\n    assert(table, \"table is not defined\")\n    const savedPath = await saveTable(table, {\n      path: outputPath,\n      format: \"csv\" as const,\n    })\n\n    expect(savedPath).toBeDefined()\n    expect(\n      await access(savedPath)\n        .then(() => true)\n        .catch(() => false),\n    ).toBe(true)\n    await unlink(savedPath)\n  })\n\n  it(\"should save table with date values\", async () => {\n    const csvPath = await writeTempFile(\n      \"id,created\\n1,2024-01-01\\n2,2024-01-02\",\n    )\n    const resource = { path: csvPath, format: \"csv\" as const }\n    const table = await loadTable(resource)\n    const outputPath = await writeTempFile(\"\")\n    await unlink(outputPath)\n\n    assert(table, \"table is not defined\")\n    const savedPath = await saveTable(table, {\n      path: outputPath,\n      format: \"csv\" as const,\n    })\n\n    expect(savedPath).toBeDefined()\n    expect(\n      await access(savedPath)\n        .then(() => true)\n        .catch(() => false),\n    ).toBe(true)\n    await unlink(savedPath)\n  })\n})\n"]}

package/build/table/validate.d.ts

@@ -0,0 +1,9 @@
+import type { Resource } from "@frictionless-ts/metadata";
+import type { UnboundError } from "@frictionless-ts/metadata";
+import type { LoadTableOptions } from "@frictionless-ts/table";
+export declare function validateTable(resource: Partial<Resource>, options?: LoadTableOptions & {
+    maxErrors?: number;
+}): Promise<{
+    errors: UnboundError[];
+    valid: boolean;
+}>;

package/build/table/validate.js

@@ -0,0 +1,26 @@
+import { resolveSchema } from "@frictionless-ts/metadata";
+import { createReport } from "@frictionless-ts/metadata";
+import { inspectTable } from "@frictionless-ts/table";
+import { inferSchema } from "../schema/index.js";
+import { loadTable } from "./load.js";
+export async function validateTable(resource, options) {
+    const { maxErrors } = options ?? {};
+    const errors = [];
+    const table = await loadTable(resource, { denormalized: true });
+    if (table) {
+        let schema = await resolveSchema(resource.schema);
+        if (!schema)
+            schema = await inferSchema(resource, options);
+        const tableErrors = await inspectTable(table, { schema, maxErrors });
+        errors.push(...tableErrors);
+    }
+    // TODO: review
+    if (!table && resource.schema) {
+        errors.push({
+            type: "data",
+            message: `missing ${resource.name} table`,
+        });
+    }
+    return createReport(errors, { maxErrors });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "frictionless-ts",
+  "type": "module",
+  "version": "1.0.1",
+  "exports": "./build/index.js",
+  "sideEffects": false,
+  "files": [
+    "build"
+  ],
+  "license": "MIT",
+  "author": "Evgeny Karev",
+  "repository": "https://github.com/frictionlessdata/frictionless-ts",
+  "description": "Fast TypeScript data management framework built on top of the Data Package standard and Polars DataFrames",
+  "keywords": [
+    "frictionless",
+    "data",
+    "polars",
+    "dataframe",
+    "datapackage",
+    "tableschema",
+    "typescript",
+    "validation",
+    "quality",
+    "fair",
+    "lib"
+  ],
+  "dependencies": {
+    "p-all": "^5.0.1",
+    "@frictionless-ts/dataset": "1.0.1",
+    "@frictionless-ts/database": "1.0.1",
+    "@frictionless-ts/document": "1.0.1",
+    "@frictionless-ts/table": "1.0.1",
+    "@frictionless-ts/metadata": "1.0.1"
+  },
+  "scripts": {
+    "build": "tsc"
+  }
+}