frictionless-ts 1.0.1

package/LICENSE.md

@@ -0,0 +1,9 @@
+# The MIT License (MIT)
+
+Copyright © `2025` `Evgeny Karev`
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# @frictionless-ts
+
+frictionless-ts is a fast TypeScript data management framework built on top of the Data Package standard and Polars DataFrames. It supports various formats like CSV, JSON, and Parquet and integrates with data platforms such as CKAN, Zenodo, and GitHub. For more information, please read the [project's documentation](https://frictionlessdata.github.io/frictionless-ts/).

package/build/dialect/index.d.ts

@@ -0,0 +1 @@
+export { inferDialect } from "./infer.ts";

package/build/dialect/index.js

@@ -0,0 +1,2 @@
+export { inferDialect } from "./infer.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9kaWFsZWN0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxZQUFZLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBpbmZlckRpYWxlY3QgfSBmcm9tIFwiLi9pbmZlci50c1wiXG4iXX0=

package/build/dialect/infer.d.ts

@@ -0,0 +1,3 @@
+import type { Dialect, Resource } from "@frictionless-ts/metadata";
+import type { InferDialectOptions } from "@frictionless-ts/table";
+export declare function inferDialect(resource: Partial<Resource>, options?: InferDialectOptions): Promise<Dialect>;

package/build/dialect/infer.js

@@ -0,0 +1,13 @@
+import { system } from "../system.js";
+// TODO: review default values being {} vs undefined
+export async function inferDialect(resource, options) {
+    let dialect = {};
+    for (const plugin of system.plugins) {
+        const result = await plugin.inferDialect?.(resource, options);
+        if (result) {
+            dialect = result;
+        }
+    }
+    return dialect;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5mZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9kaWFsZWN0L2luZmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxjQUFjLENBQUE7QUFFckMsb0RBQW9EO0FBRXBELE1BQU0sQ0FBQyxLQUFLLFVBQVUsWUFBWSxDQUNoQyxRQUEyQixFQUMzQixPQUE2QjtJQUU3QixJQUFJLE9BQU8sR0FBWSxFQUFFLENBQUE7SUFFekIsS0FBSyxNQUFNLE1BQU0sSUFBSSxNQUFNLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDcEMsTUFBTSxNQUFNLEdBQUcsTUFBTSxNQUFNLENBQUMsWUFBWSxFQUFFLENBQUMsUUFBUSxFQUFFLE9BQU8sQ0FBQyxDQUFBO1FBQzdELElBQUksTUFBTSxFQUFFLENBQUM7WUFDWCxPQUFPLEdBQUcsTUFBTSxDQUFBO1FBQ2xCLENBQUM7SUFDSCxDQUFDO0lBRUQsT0FBTyxPQUFPLENBQUE7QUFDaEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgRGlhbGVjdCwgUmVzb3VyY2UgfSBmcm9tIFwiQGZyaWN0aW9ubGVzcy10cy9tZXRhZGF0YVwiXG5pbXBvcnQgdHlwZSB7IEluZmVyRGlhbGVjdE9wdGlvbnMgfSBmcm9tIFwiQGZyaWN0aW9ubGVzcy10cy90YWJsZVwiXG5pbXBvcnQgeyBzeXN0ZW0gfSBmcm9tIFwiLi4vc3lzdGVtLnRzXCJcblxuLy8gVE9ETzogcmV2aWV3IGRlZmF1bHQgdmFsdWVzIGJlaW5nIHt9IHZzIHVuZGVmaW5lZFxuXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gaW5mZXJEaWFsZWN0KFxuICByZXNvdXJjZTogUGFydGlhbDxSZXNvdXJjZT4sXG4gIG9wdGlvbnM/OiBJbmZlckRpYWxlY3RPcHRpb25zLFxuKSB7XG4gIGxldCBkaWFsZWN0OiBEaWFsZWN0ID0ge31cblxuICBmb3IgKGNvbnN0IHBsdWdpbiBvZiBzeXN0ZW0ucGx1Z2lucykge1xuICAgIGNvbnN0IHJlc3VsdCA9IGF3YWl0IHBsdWdpbi5pbmZlckRpYWxlY3Q/LihyZXNvdXJjZSwgb3B0aW9ucylcbiAgICBpZiAocmVzdWx0KSB7XG4gICAgICBkaWFsZWN0ID0gcmVzdWx0XG4gICAgfVxuICB9XG5cbiAgcmV0dXJuIGRpYWxlY3Rcbn1cbiJdfQ==

package/build/dialect/infer.spec.d.ts

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

package/build/dialect/infer.spec.js

@@ -0,0 +1,89 @@
+import { writeTempFile } from "@frictionless-ts/dataset";
+import { describe, expect, it } from "vitest";
+import { inferDialect } from "./infer.js";
+// TODO: fix this test/implementation
+describe.skip("inferDialect", () => {
+    it("should infer dialect from CSV file with comma delimiter", async () => {
+        const csvPath = await writeTempFile("id,name,age\n1,alice,25\n2,bob,30");
+        const resource = { path: csvPath, format: "csv" };
+        const dialect = await inferDialect(resource);
+        expect(dialect).toEqual({ delimiter: "|" });
+    });
+    it("should infer dialect from CSV file with pipe delimiter", async () => {
+        const csvPath = await writeTempFile("id|name|age\n1|alice|25\n2|bob|30");
+        const resource = { path: csvPath, format: "csv" };
+        const dialect = await inferDialect(resource);
+        expect(dialect).toEqual({ delimiter: "|" });
+    });
+    it("should infer dialect from CSV file with semicolon delimiter", async () => {
+        const csvPath = await writeTempFile("id;name;age\n1;alice;25\n2;bob;30");
+        const resource = { path: csvPath, format: "csv" };
+        const dialect = await inferDialect(resource);
+        expect(dialect).toEqual({ delimiter: ";" });
+    });
+    it("should infer dialect from CSV file with tab delimiter", async () => {
+        const csvPath = await writeTempFile("id\tname\tage\n1\talice\t25\n2\tbob\t30");
+        const resource = { path: csvPath, format: "csv" };
+        const dialect = await inferDialect(resource, { delimiter: "\t" });
+        expect(dialect).toBeDefined();
+    });
+    it("should handle CSV with quoted fields", async () => {
+        const csvPath = await writeTempFile('id,name,description\n1,"alice","Description with, comma"\n2,"bob","Normal text"');
+        const resource = { path: csvPath, format: "csv" };
+        const dialect = await inferDialect(resource);
+        expect(dialect).toBeDefined();
+    });
+    it("should handle CSV with different quote character", async () => {
+        const csvPath = await writeTempFile("id,name,description\n1,'alice','Description text'\n2,'bob','Normal text'");
+        const resource = { path: csvPath, format: "csv" };
+        const dialect = await inferDialect(resource);
+        expect(dialect).toBeDefined();
+    });
+    it("should handle resources without path", async () => {
+        const resource = {
+            name: "test-resource",
+            data: [
+                { id: 1, name: "alice" },
+                { id: 2, name: "bob" },
+            ],
+        };
+        const dialect = await inferDialect(resource);
+        expect(dialect).toBeDefined();
+    });
+    it("should return empty object for non-CSV resources", async () => {
+        const resource = {
+            name: "test-resource",
+            format: "json",
+            data: [{ id: 1 }],
+        };
+        const dialect = await inferDialect(resource);
+        expect(dialect).toBeDefined();
+        expect(typeof dialect).toBe("object");
+    });
+    it("should handle CSV with custom line terminator", async () => {
+        const csvPath = await writeTempFile("id,name\r\n1,alice\r\n2,bob\r\n");
+        const resource = { path: csvPath, format: "csv" };
+        const dialect = await inferDialect(resource);
+        expect(dialect).toBeDefined();
+    });
+    it("should handle CSV with header row only", async () => {
+        const csvPath = await writeTempFile("id,name,age");
+        const resource = { path: csvPath, format: "csv" };
+        const dialect = await inferDialect(resource);
+        expect(dialect).toBeDefined();
+    });
+    it("should handle empty CSV file", async () => {
+        const csvPath = await writeTempFile("");
+        const resource = { path: csvPath, format: "csv" };
+        const dialect = await inferDialect(resource);
+        expect(dialect).toBeDefined();
+        expect(typeof dialect).toBe("object");
+    });
+    it("should respect provided delimiter option", async () => {
+        const csvPath = await writeTempFile("id|name|age\n1|alice|25\n2|bob|30");
+        const resource = { path: csvPath, format: "csv" };
+        const dialect = await inferDialect(resource, { delimiter: "|" });
+        expect(dialect).toBeDefined();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"infer.spec.js","sourceRoot":"","sources":["../../dialect/infer.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import { writeTempFile } from \"@frictionless-ts/dataset\"\nimport { describe, expect, it } from \"vitest\"\nimport { inferDialect } from \"./infer.ts\"\n\n// TODO: fix this test/implementation\ndescribe.skip(\"inferDialect\", () => {\n  it(\"should infer dialect from CSV file with comma delimiter\", async () => {\n    const csvPath = await writeTempFile(\"id,name,age\\n1,alice,25\\n2,bob,30\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const dialect = await inferDialect(resource)\n\n    expect(dialect).toEqual({ delimiter: \"|\" })\n  })\n\n  it(\"should infer dialect from CSV file with pipe delimiter\", async () => {\n    const csvPath = await writeTempFile(\"id|name|age\\n1|alice|25\\n2|bob|30\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const dialect = await inferDialect(resource)\n\n    expect(dialect).toEqual({ delimiter: \"|\" })\n  })\n\n  it(\"should infer dialect from CSV file with semicolon delimiter\", async () => {\n    const csvPath = await writeTempFile(\"id;name;age\\n1;alice;25\\n2;bob;30\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const dialect = await inferDialect(resource)\n\n    expect(dialect).toEqual({ delimiter: \";\" })\n  })\n\n  it(\"should infer dialect from CSV file with tab delimiter\", async () => {\n    const csvPath = await writeTempFile(\n      \"id\\tname\\tage\\n1\\talice\\t25\\n2\\tbob\\t30\",\n    )\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const dialect = await inferDialect(resource, { delimiter: \"\\t\" })\n\n    expect(dialect).toBeDefined()\n  })\n\n  it(\"should handle CSV with quoted fields\", async () => {\n    const csvPath = await writeTempFile(\n      'id,name,description\\n1,\"alice\",\"Description with, comma\"\\n2,\"bob\",\"Normal text\"',\n    )\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const dialect = await inferDialect(resource)\n\n    expect(dialect).toBeDefined()\n  })\n\n  it(\"should handle CSV with different quote character\", async () => {\n    const csvPath = await writeTempFile(\n      \"id,name,description\\n1,'alice','Description text'\\n2,'bob','Normal text'\",\n    )\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const dialect = await inferDialect(resource)\n\n    expect(dialect).toBeDefined()\n  })\n\n  it(\"should handle resources without path\", async () => {\n    const resource = {\n      name: \"test-resource\",\n      data: [\n        { id: 1, name: \"alice\" },\n        { id: 2, name: \"bob\" },\n      ],\n    }\n\n    const dialect = await inferDialect(resource)\n\n    expect(dialect).toBeDefined()\n  })\n\n  it(\"should return empty object for non-CSV resources\", async () => {\n    const resource = {\n      name: \"test-resource\",\n      format: \"json\" as const,\n      data: [{ id: 1 }],\n    }\n\n    const dialect = await inferDialect(resource)\n\n    expect(dialect).toBeDefined()\n    expect(typeof dialect).toBe(\"object\")\n  })\n\n  it(\"should handle CSV with custom line terminator\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\r\\n1,alice\\r\\n2,bob\\r\\n\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const dialect = await inferDialect(resource)\n\n    expect(dialect).toBeDefined()\n  })\n\n  it(\"should handle CSV with header row only\", async () => {\n    const csvPath = await writeTempFile(\"id,name,age\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const dialect = await inferDialect(resource)\n\n    expect(dialect).toBeDefined()\n  })\n\n  it(\"should handle empty CSV file\", async () => {\n    const csvPath = await writeTempFile(\"\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const dialect = await inferDialect(resource)\n\n    expect(dialect).toBeDefined()\n    expect(typeof dialect).toBe(\"object\")\n  })\n\n  it(\"should respect provided delimiter option\", async () => {\n    const csvPath = await writeTempFile(\"id|name|age\\n1|alice|25\\n2|bob|30\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const dialect = await inferDialect(resource, { delimiter: \"|\" })\n\n    expect(dialect).toBeDefined()\n  })\n})\n"]}

package/build/index.d.ts

@@ -0,0 +1,19 @@
+export * from "@frictionless-ts/dataset";
+export * from "@frictionless-ts/database";
+export * from "@frictionless-ts/document";
+export * from "@frictionless-ts/metadata";
+export * from "@frictionless-ts/table";
+export type { Plugin } from "./plugin.ts";
+export { System } from "./system.ts";
+export { inferDialect } from "./dialect/index.ts";
+export { inferPackage } from "./package/index.ts";
+export { inferResource } from "./resource/index.ts";
+export { inferSchema } from "./schema/index.ts";
+export { loadPackage } from "./package/index.ts";
+export { loadTable } from "./table/index.ts";
+export { savePackage } from "./package/index.ts";
+export { saveTable } from "./table/index.ts";
+export { system } from "./system.ts";
+export { validatePackage } from "./package/index.ts";
+export { validateResource } from "./resource/index.ts";
+export { validateTable } from "./table/index.ts";

package/build/index.js

@@ -0,0 +1,19 @@
+export * from "@frictionless-ts/dataset";
+export * from "@frictionless-ts/database";
+export * from "@frictionless-ts/document";
+export * from "@frictionless-ts/metadata";
+export * from "@frictionless-ts/table";
+export { System } from "./system.js";
+export { inferDialect } from "./dialect/index.js";
+export { inferPackage } from "./package/index.js";
+export { inferResource } from "./resource/index.js";
+export { inferSchema } from "./schema/index.js";
+export { loadPackage } from "./package/index.js";
+export { loadTable } from "./table/index.js";
+export { savePackage } from "./package/index.js";
+export { saveTable } from "./table/index.js";
+export { system } from "./system.js";
+export { validatePackage } from "./package/index.js";
+export { validateResource } from "./resource/index.js";
+export { validateTable } from "./table/index.js";
+//# sourceMappingURL=data:application/json;base64,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

package/build/package/index.d.ts

@@ -0,0 +1,4 @@
+export { loadPackage } from "./load.ts";
+export { savePackage } from "./save.ts";
+export { inferPackage } from "./infer.ts";
+export { validatePackage, validatePackageData } from "./validate.ts";

package/build/package/index.js

@@ -0,0 +1,5 @@
+export { loadPackage } from "./load.js";
+export { savePackage } from "./save.js";
+export { inferPackage } from "./infer.js";
+export { validatePackage, validatePackageData } from "./validate.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9wYWNrYWdlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxXQUFXLENBQUE7QUFDdkMsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLFdBQVcsQ0FBQTtBQUN2QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sWUFBWSxDQUFBO0FBQ3pDLE9BQU8sRUFBRSxlQUFlLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxlQUFlLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBsb2FkUGFja2FnZSB9IGZyb20gXCIuL2xvYWQudHNcIlxuZXhwb3J0IHsgc2F2ZVBhY2thZ2UgfSBmcm9tIFwiLi9zYXZlLnRzXCJcbmV4cG9ydCB7IGluZmVyUGFja2FnZSB9IGZyb20gXCIuL2luZmVyLnRzXCJcbmV4cG9ydCB7IHZhbGlkYXRlUGFja2FnZSwgdmFsaWRhdGVQYWNrYWdlRGF0YSB9IGZyb20gXCIuL3ZhbGlkYXRlLnRzXCJcbiJdfQ==

package/build/package/infer.d.ts

@@ -0,0 +1,40 @@
+import type { Package, Resource } from "@frictionless-ts/metadata";
+import type { InferDialectOptions } from "@frictionless-ts/table";
+import type { InferSchemaOptions } from "@frictionless-ts/table";
+interface PartialPackage extends Omit<Package, "resources"> {
+    resources: Partial<Resource>[];
+}
+export declare function inferPackage(dataPackage: PartialPackage, options?: InferDialectOptions & InferSchemaOptions): Promise<{
+    resources: {
+        name: string;
+        $schema?: string | undefined;
+        path?: string | string[] | undefined;
+        data?: unknown | unknown[][] | Record<string, unknown>[];
+        type?: "table" | undefined;
+        format?: string | undefined;
+        mediatype?: string | undefined;
+        encoding?: string | undefined;
+        title?: string | undefined;
+        description?: string | undefined;
+        bytes?: number | undefined;
+        hash?: string | undefined;
+        sources?: import("@frictionless-ts/metadata").Source[] | undefined;
+        licenses?: import("@frictionless-ts/metadata").License[] | undefined;
+        dialect?: (string | import("@frictionless-ts/metadata").Dialect) | undefined;
+        schema?: (string | import("@frictionless-ts/metadata").Schema) | undefined;
+        jsonSchema?: (string | import("@frictionless-ts/metadata").Descriptor) | undefined;
+    }[];
+    $schema?: string | undefined;
+    name?: string | undefined;
+    title?: string | undefined;
+    description?: string | undefined;
+    sources?: import("@frictionless-ts/metadata").Source[] | undefined;
+    licenses?: import("@frictionless-ts/metadata").License[] | undefined;
+    homepage?: string | undefined;
+    version?: string | undefined;
+    contributors?: import("@frictionless-ts/metadata").Contributor[] | undefined;
+    keywords?: string[] | undefined;
+    created?: string | undefined;
+    image?: string | undefined;
+}>;
+export {};

package/build/package/infer.js

@@ -0,0 +1,13 @@
+import os from "node:os";
+import pAll from "p-all";
+import { inferResource } from "../resource/index.js";
+export async function inferPackage(dataPackage, options) {
+    const concurrency = os.cpus().length;
+    const resources = await pAll(dataPackage.resources.map(resource => () => inferResource(resource, options)), { concurrency });
+    const result = {
+        ...dataPackage,
+        resources,
+    };
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5mZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9wYWNrYWdlL2luZmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxNQUFNLFNBQVMsQ0FBQTtBQUl4QixPQUFPLElBQUksTUFBTSxPQUFPLENBQUE7QUFDeEIsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLHNCQUFzQixDQUFBO0FBUXBELE1BQU0sQ0FBQyxLQUFLLFVBQVUsWUFBWSxDQUNoQyxXQUEyQixFQUMzQixPQUFrRDtJQUVsRCxNQUFNLFdBQVcsR0FBRyxFQUFFLENBQUMsSUFBSSxFQUFFLENBQUMsTUFBTSxDQUFBO0lBRXBDLE1BQU0sU0FBUyxHQUFHLE1BQU0sSUFBSSxDQUMxQixXQUFXLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FDdkIsUUFBUSxDQUFDLEVBQUUsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxhQUFhLENBQUMsUUFBUSxFQUFFLE9BQU8sQ0FBQyxDQUNuRCxFQUNELEVBQUUsV0FBVyxFQUFFLENBQ2hCLENBQUE7SUFFRCxNQUFNLE1BQU0sR0FBRztRQUNiLEdBQUcsV0FBVztRQUNkLFNBQVM7S0FDVixDQUFBO0lBRUQsT0FBTyxNQUFNLENBQUE7QUFDZixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IG9zIGZyb20gXCJub2RlOm9zXCJcbmltcG9ydCB0eXBlIHsgUGFja2FnZSwgUmVzb3VyY2UgfSBmcm9tIFwiQGZyaWN0aW9ubGVzcy10cy9tZXRhZGF0YVwiXG5pbXBvcnQgdHlwZSB7IEluZmVyRGlhbGVjdE9wdGlvbnMgfSBmcm9tIFwiQGZyaWN0aW9ubGVzcy10cy90YWJsZVwiXG5pbXBvcnQgdHlwZSB7IEluZmVyU2NoZW1hT3B0aW9ucyB9IGZyb20gXCJAZnJpY3Rpb25sZXNzLXRzL3RhYmxlXCJcbmltcG9ydCBwQWxsIGZyb20gXCJwLWFsbFwiXG5pbXBvcnQgeyBpbmZlclJlc291cmNlIH0gZnJvbSBcIi4uL3Jlc291cmNlL2luZGV4LnRzXCJcblxuLy8gVE9ETzogTW92ZSBQYXJ0aWFsUGFja2FnZS9SZXNvdXJjZSB0byBAZnJpY3Rpb25sZXNzLXRzL21ldGFkYXRhP1xuXG5pbnRlcmZhY2UgUGFydGlhbFBhY2thZ2UgZXh0ZW5kcyBPbWl0PFBhY2thZ2UsIFwicmVzb3VyY2VzXCI+IHtcbiAgcmVzb3VyY2VzOiBQYXJ0aWFsPFJlc291cmNlPltdXG59XG5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBpbmZlclBhY2thZ2UoXG4gIGRhdGFQYWNrYWdlOiBQYXJ0aWFsUGFja2FnZSxcbiAgb3B0aW9ucz86IEluZmVyRGlhbGVjdE9wdGlvbnMgJiBJbmZlclNjaGVtYU9wdGlvbnMsXG4pIHtcbiAgY29uc3QgY29uY3VycmVuY3kgPSBvcy5jcHVzKCkubGVuZ3RoXG5cbiAgY29uc3QgcmVzb3VyY2VzID0gYXdhaXQgcEFsbChcbiAgICBkYXRhUGFja2FnZS5yZXNvdXJjZXMubWFwKFxuICAgICAgcmVzb3VyY2UgPT4gKCkgPT4gaW5mZXJSZXNvdXJjZShyZXNvdXJjZSwgb3B0aW9ucyksXG4gICAgKSxcbiAgICB7IGNvbmN1cnJlbmN5IH0sXG4gIClcblxuICBjb25zdCByZXN1bHQgPSB7XG4gICAgLi4uZGF0YVBhY2thZ2UsXG4gICAgcmVzb3VyY2VzLFxuICB9XG5cbiAgcmV0dXJuIHJlc3VsdFxufVxuIl19

package/build/package/infer.spec.d.ts

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

package/build/package/infer.spec.js

@@ -0,0 +1,121 @@
+import { writeTempFile } from "@frictionless-ts/dataset";
+import { describe, expect, it } from "vitest";
+import { inferPackage } from "./infer.js";
+describe("inferPackage", () => {
+    it("should infer package with single resource", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n2,bob");
+        const dataPackage = {
+            name: "test-package",
+            resources: [{ path: csvPath, format: "csv" }],
+        };
+        const result = await inferPackage(dataPackage);
+        expect(result.name).toBe("test-package");
+        expect(result.resources).toBeDefined();
+        expect(result.resources.length).toBe(1);
+        expect(result.resources?.[0]?.schema).toBeDefined();
+    });
+    it("should infer package with multiple resources", async () => {
+        const csv1Path = await writeTempFile("id,name\n1,alice\n2,bob");
+        const csv2Path = await writeTempFile("id,value\n1,100\n2,200");
+        const dataPackage = {
+            name: "test-package",
+            resources: [
+                { path: csv1Path, format: "csv" },
+                { path: csv2Path, format: "csv" },
+            ],
+        };
+        const result = await inferPackage(dataPackage);
+        expect(result.name).toBe("test-package");
+        expect(result.resources.length).toBe(2);
+        expect(result.resources?.[0]?.schema).toBeDefined();
+        expect(result.resources?.[1]?.schema).toBeDefined();
+    });
+    it("should preserve package-level properties", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n2,bob");
+        const dataPackage = {
+            name: "test-package",
+            title: "Test Package",
+            description: "A test package",
+            version: "1.0.0",
+            resources: [{ path: csvPath, format: "csv" }],
+        };
+        const result = await inferPackage(dataPackage);
+        expect(result.name).toBe("test-package");
+        expect(result.title).toBe("Test Package");
+        expect(result.description).toBe("A test package");
+        expect(result.version).toBe("1.0.0");
+    });
+    it("should pass options to resource inference", async () => {
+        const csvPath = await writeTempFile("id|name\n1|alice\n2|bob");
+        const dataPackage = {
+            name: "test-package",
+            resources: [{ path: csvPath, format: "csv" }],
+        };
+        const result = await inferPackage(dataPackage, { delimiter: "|" });
+        expect(result.resources?.[0]?.dialect).toBeDefined();
+        expect(result.resources?.[0]?.schema).toBeDefined();
+    });
+    it("should handle empty resources array", async () => {
+        const dataPackage = {
+            name: "test-package",
+            resources: [],
+        };
+        const result = await inferPackage(dataPackage);
+        expect(result.name).toBe("test-package");
+        expect(result.resources).toEqual([]);
+    });
+    it("should preserve existing resource properties", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n2,bob");
+        const dataPackage = {
+            name: "test-package",
+            resources: [
+                {
+                    path: csvPath,
+                    format: "csv",
+                    name: "custom-name",
+                    title: "Custom Resource",
+                },
+            ],
+        };
+        const result = await inferPackage(dataPackage);
+        expect(result.resources?.[0]?.name).toBe("custom-name");
+        expect(result.resources?.[0]?.title).toBe("Custom Resource");
+    });
+    it("should infer package with inline data resources", async () => {
+        const dataPackage = {
+            name: "test-package",
+            resources: [
+                {
+                    name: "test-resource",
+                    data: [
+                        { id: 1, name: "alice" },
+                        { id: 2, name: "bob" },
+                    ],
+                },
+            ],
+        };
+        const result = await inferPackage(dataPackage);
+        expect(result.name).toBe("test-package");
+        expect(result.resources.length).toBe(1);
+        expect(result.resources?.[0]?.name).toBe("test-resource");
+        expect(result.resources?.[0]?.data).toBeDefined();
+    });
+    it("should handle mixed file and inline resources", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n2,bob");
+        const dataPackage = {
+            name: "test-package",
+            resources: [
+                { path: csvPath, format: "csv" },
+                {
+                    name: "inline-resource",
+                    data: [{ id: 1, value: 100 }],
+                },
+            ],
+        };
+        const result = await inferPackage(dataPackage);
+        expect(result.resources.length).toBe(2);
+        expect(result.resources?.[0]?.path).toBe(csvPath);
+        expect(result.resources?.[1]?.data).toBeDefined();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"infer.spec.js","sourceRoot":"","sources":["../../package/infer.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import { writeTempFile } from \"@frictionless-ts/dataset\"\nimport { describe, expect, it } from \"vitest\"\nimport { inferPackage } from \"./infer.ts\"\n\ndescribe(\"inferPackage\", () => {\n  it(\"should infer package with single resource\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\\n2,bob\")\n    const dataPackage = {\n      name: \"test-package\",\n      resources: [{ path: csvPath, format: \"csv\" as const }],\n    }\n\n    const result = await inferPackage(dataPackage)\n\n    expect(result.name).toBe(\"test-package\")\n    expect(result.resources).toBeDefined()\n    expect(result.resources.length).toBe(1)\n    expect(result.resources?.[0]?.schema).toBeDefined()\n  })\n\n  it(\"should infer package with multiple resources\", async () => {\n    const csv1Path = await writeTempFile(\"id,name\\n1,alice\\n2,bob\")\n    const csv2Path = await writeTempFile(\"id,value\\n1,100\\n2,200\")\n    const dataPackage = {\n      name: \"test-package\",\n      resources: [\n        { path: csv1Path, format: \"csv\" as const },\n        { path: csv2Path, format: \"csv\" as const },\n      ],\n    }\n\n    const result = await inferPackage(dataPackage)\n\n    expect(result.name).toBe(\"test-package\")\n    expect(result.resources.length).toBe(2)\n    expect(result.resources?.[0]?.schema).toBeDefined()\n    expect(result.resources?.[1]?.schema).toBeDefined()\n  })\n\n  it(\"should preserve package-level properties\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\\n2,bob\")\n    const dataPackage = {\n      name: \"test-package\",\n      title: \"Test Package\",\n      description: \"A test package\",\n      version: \"1.0.0\",\n      resources: [{ path: csvPath, format: \"csv\" as const }],\n    }\n\n    const result = await inferPackage(dataPackage)\n\n    expect(result.name).toBe(\"test-package\")\n    expect(result.title).toBe(\"Test Package\")\n    expect(result.description).toBe(\"A test package\")\n    expect(result.version).toBe(\"1.0.0\")\n  })\n\n  it(\"should pass options to resource inference\", async () => {\n    const csvPath = await writeTempFile(\"id|name\\n1|alice\\n2|bob\")\n    const dataPackage = {\n      name: \"test-package\",\n      resources: [{ path: csvPath, format: \"csv\" as const }],\n    }\n\n    const result = await inferPackage(dataPackage, { delimiter: \"|\" })\n\n    expect(result.resources?.[0]?.dialect).toBeDefined()\n    expect(result.resources?.[0]?.schema).toBeDefined()\n  })\n\n  it(\"should handle empty resources array\", async () => {\n    const dataPackage = {\n      name: \"test-package\",\n      resources: [],\n    }\n\n    const result = await inferPackage(dataPackage)\n\n    expect(result.name).toBe(\"test-package\")\n    expect(result.resources).toEqual([])\n  })\n\n  it(\"should preserve existing resource properties\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\\n2,bob\")\n    const dataPackage = {\n      name: \"test-package\",\n      resources: [\n        {\n          path: csvPath,\n          format: \"csv\" as const,\n          name: \"custom-name\",\n          title: \"Custom Resource\",\n        },\n      ],\n    }\n\n    const result = await inferPackage(dataPackage)\n\n    expect(result.resources?.[0]?.name).toBe(\"custom-name\")\n    expect(result.resources?.[0]?.title).toBe(\"Custom Resource\")\n  })\n\n  it(\"should infer package with inline data resources\", async () => {\n    const dataPackage = {\n      name: \"test-package\",\n      resources: [\n        {\n          name: \"test-resource\",\n          data: [\n            { id: 1, name: \"alice\" },\n            { id: 2, name: \"bob\" },\n          ],\n        },\n      ],\n    }\n\n    const result = await inferPackage(dataPackage)\n\n    expect(result.name).toBe(\"test-package\")\n    expect(result.resources.length).toBe(1)\n    expect(result.resources?.[0]?.name).toBe(\"test-resource\")\n    expect(result.resources?.[0]?.data).toBeDefined()\n  })\n\n  it(\"should handle mixed file and inline resources\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\\n2,bob\")\n    const dataPackage = {\n      name: \"test-package\",\n      resources: [\n        { path: csvPath, format: \"csv\" as const },\n        {\n          name: \"inline-resource\",\n          data: [{ id: 1, value: 100 }],\n        },\n      ],\n    }\n\n    const result = await inferPackage(dataPackage)\n\n    expect(result.resources.length).toBe(2)\n    expect(result.resources?.[0]?.path).toBe(csvPath)\n    expect(result.resources?.[1]?.data).toBeDefined()\n  })\n})\n"]}

package/build/package/integrity.d.ts

@@ -0,0 +1,8 @@
+import type { Package } from "@frictionless-ts/metadata";
+import type { BoundError } from "@frictionless-ts/metadata";
+export declare function validatePackageIntegrity(dataPackage: Package, options?: {
+    maxErrors?: number;
+}): Promise<{
+    errors: BoundError[];
+    valid: boolean;
+}>;

package/build/package/integrity.js

@@ -0,0 +1,69 @@
+import { createReport } from "@frictionless-ts/metadata";
+import { resolveSchema } from "@frictionless-ts/metadata";
+import { loadTable } from "../table/index.js";
+// TODO: foreign key fields definition should be validated as well (metadata/here?)
+// TODO: review temporary files creation from validatePackage call
+export async function validatePackageIntegrity(dataPackage, options) {
+    const { maxErrors = 1000 } = options ?? {};
+    const errors = [];
+    const tables = {};
+    for (const resource of dataPackage.resources) {
+        const schema = await resolveSchema(resource.schema);
+        if (!schema)
+            continue;
+        const foreignKeys = schema.foreignKeys;
+        if (!foreignKeys)
+            continue;
+        const names = [
+            resource.name,
+            ...foreignKeys.map(it => it.reference.resource),
+        ].filter(Boolean);
+        for (const name of names) {
+            const resource = dataPackage.resources.find(r => r.name === name);
+            if (!resource) {
+                errors.push({
+                    type: "data",
+                    message: `missing ${name} resource`,
+                    resource: name,
+                });
+                continue;
+            }
+            if (!tables[name]) {
+                const table = await loadTable(resource);
+                if (!table) {
+                    errors.push({
+                        type: "data",
+                        message: `missing ${resource.name} table`,
+                        resource: name,
+                    });
+                    continue;
+                }
+                tables[name] = table;
+            }
+        }
+        for (const foreignKey of foreignKeys) {
+            const left = tables[resource.name];
+            const right = tables[foreignKey.reference.resource ?? resource.name];
+            const foreignKeyCheckTable = left
+                .select(...foreignKey.fields)
+                .join(right, {
+                how: "anti",
+                leftOn: foreignKey.fields,
+                rightOn: foreignKey.reference.fields,
+            });
+            const foreignKeyCheckFrame = await foreignKeyCheckTable
+                .head(maxErrors)
+                .collect();
+            for (const row of foreignKeyCheckFrame.toRecords()) {
+                errors.push({
+                    type: "foreignKey",
+                    foreignKey,
+                    cells: Object.values(row).map(String),
+                    resource: resource.name,
+                });
+            }
+        }
+    }
+    return createReport(errors, { maxErrors });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/package/integrity.spec.d.ts

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