frictionless-ts 1.0.1

package/build/resource/index.d.ts

@@ -0,0 +1,2 @@
+export { inferResource } from "./infer.ts";
+export { validateResource, validateResourceData } from "./validate.ts";

package/build/resource/index.js

@@ -0,0 +1,3 @@
+export { inferResource } from "./infer.js";
+export { validateResource, validateResourceData } from "./validate.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9yZXNvdXJjZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sWUFBWSxDQUFBO0FBQzFDLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxvQkFBb0IsRUFBRSxNQUFNLGVBQWUsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IGluZmVyUmVzb3VyY2UgfSBmcm9tIFwiLi9pbmZlci50c1wiXG5leHBvcnQgeyB2YWxpZGF0ZVJlc291cmNlLCB2YWxpZGF0ZVJlc291cmNlRGF0YSB9IGZyb20gXCIuL3ZhbGlkYXRlLnRzXCJcbiJdfQ==

package/build/resource/infer.d.ts

@@ -0,0 +1,22 @@
+import type { Resource } from "@frictionless-ts/metadata";
+import type { InferDialectOptions } from "@frictionless-ts/table";
+import type { InferSchemaOptions } from "@frictionless-ts/table";
+export declare function inferResource(resource: Partial<Resource>, options?: InferDialectOptions & InferSchemaOptions): Promise<{
+    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;
+}>;

package/build/resource/infer.js

@@ -0,0 +1,49 @@
+import { prefetchFile } from "@frictionless-ts/dataset";
+import { inferBytes, inferEncoding, inferHash } from "@frictionless-ts/dataset";
+import { inferFormat, inferName } from "@frictionless-ts/metadata";
+import { inferDialect } from "../dialect/index.js";
+import { inferSchema } from "../schema/index.js";
+export async function inferResource(resource, options) {
+    const result = {
+        ...resource,
+        name: resource.name ?? inferName(resource),
+    };
+    if (!result.format) {
+        result.format = inferFormat(resource);
+    }
+    if (typeof resource.path === "string") {
+        const localPath = await prefetchFile(resource.path);
+        const localResource = { ...resource, path: localPath };
+        if (!result.encoding) {
+            const encoding = await inferEncoding(localResource);
+            if (encoding) {
+                result.encoding = encoding;
+            }
+        }
+        if (!result.bytes) {
+            result.bytes = await inferBytes(localResource);
+        }
+        if (!result.hash) {
+            result.hash = await inferHash(localResource);
+        }
+        if (!result.dialect) {
+            try {
+                result.dialect = await inferDialect(localResource, options);
+            }
+            catch { }
+        }
+        if (!result.schema) {
+            try {
+                result.schema = await inferSchema(localResource, options);
+            }
+            catch { }
+        }
+    }
+    if (!result.type) {
+        if (result.schema) {
+            result.type = "table";
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/build/resource/infer.spec.js

@@ -0,0 +1,164 @@
+import { writeTempFile } from "@frictionless-ts/dataset";
+import { describe, expect, it } from "vitest";
+import { inferResource } from "./infer.js";
+describe("inferResource", () => {
+    it("should infer name from path", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n2,bob");
+        const resource = { path: csvPath, format: "csv" };
+        const result = await inferResource(resource);
+        expect(result.name).toBeDefined();
+        expect(typeof result.name).toBe("string");
+    });
+    it("should infer bytes (file size)", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n2,bob");
+        const resource = { path: csvPath, format: "csv" };
+        const result = await inferResource(resource);
+        expect(result.bytes).toBeGreaterThan(0);
+    });
+    it("should infer hash", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n2,bob");
+        const resource = { path: csvPath, format: "csv" };
+        const result = await inferResource(resource);
+        expect(result.hash).toBeDefined();
+        expect(typeof result.hash).toBe("string");
+        expect(result.hash?.length).toBeGreaterThan(0);
+    });
+    it("should infer dialect for CSV files", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n2,bob");
+        const resource = { path: csvPath, format: "csv" };
+        const result = await inferResource(resource);
+        expect(result.dialect).toBeDefined();
+    });
+    it("should infer schema for tabular data", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n2,bob");
+        const resource = { path: csvPath, format: "csv" };
+        const result = await inferResource(resource);
+        expect(result.schema).toBeDefined();
+        expect(typeof result.schema === "object" &&
+            "fields" in result.schema &&
+            result.schema.fields).toBeDefined();
+        expect(typeof result.schema === "object" &&
+            "fields" in result.schema &&
+            result.schema.fields?.length).toBeGreaterThan(0);
+    });
+    it("should set type to table when schema is inferred", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n2,bob");
+        const resource = { path: csvPath, format: "csv" };
+        const result = await inferResource(resource);
+        expect(result.type).toBe("table");
+    });
+    it("should preserve existing properties", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n2,bob");
+        const resource = {
+            path: csvPath,
+            format: "csv",
+            name: "custom-name",
+            title: "Custom Title",
+            description: "Custom description",
+        };
+        const result = await inferResource(resource);
+        expect(result.name).toBe("custom-name");
+        expect(result.title).toBe("Custom Title");
+        expect(result.description).toBe("Custom description");
+    });
+    it("should not override existing format", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n2,bob");
+        const resource = {
+            path: csvPath,
+            format: "json",
+        };
+        const result = await inferResource(resource);
+        expect(result.format).toBe("json");
+    });
+    it("should handle inline data without path", async () => {
+        const resource = {
+            name: "test-resource",
+            data: [
+                { id: 1, name: "alice" },
+                { id: 2, name: "bob" },
+            ],
+        };
+        const result = await inferResource(resource);
+        expect(result.name).toBe("test-resource");
+        expect(result.data).toEqual(resource.data);
+        expect(result.bytes).toBeUndefined();
+        expect(result.hash).toBeUndefined();
+    });
+    it("should infer dialect with custom options", async () => {
+        const csvPath = await writeTempFile("id|name\n1|alice\n2|bob");
+        const resource = { path: csvPath, format: "csv" };
+        const result = await inferResource(resource, { delimiter: "|" });
+        expect(result.dialect).toBeDefined();
+    });
+    it("should infer schema with custom delimiter", async () => {
+        const csvPath = await writeTempFile("id|name\n1|alice\n2|bob");
+        const resource = { path: csvPath, format: "csv" };
+        const result = await inferResource(resource, { delimiter: "|" });
+        expect(result.schema).toBeDefined();
+        expect(typeof result.schema === "object" &&
+            "fields" in result.schema &&
+            result.schema.fields).toBeDefined();
+        expect(typeof result.schema === "object" &&
+            "fields" in result.schema &&
+            result.schema.fields?.length).toBe(2);
+    });
+    it("should not override existing encoding", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n2,bob");
+        const resource = {
+            path: csvPath,
+            format: "csv",
+            encoding: "iso-8859-1",
+        };
+        const result = await inferResource(resource);
+        expect(result.encoding).toBe("iso-8859-1");
+    });
+    it("should not override existing bytes", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n2,bob");
+        const resource = {
+            path: csvPath,
+            format: "csv",
+            bytes: 12345,
+        };
+        const result = await inferResource(resource);
+        expect(result.bytes).toBe(12345);
+    });
+    it("should not override existing hash", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n2,bob");
+        const resource = {
+            path: csvPath,
+            format: "csv",
+            hash: "custom-hash",
+        };
+        const result = await inferResource(resource);
+        expect(result.hash).toBe("custom-hash");
+    });
+    it("should not override existing dialect", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n2,bob");
+        const resource = {
+            path: csvPath,
+            format: "csv",
+            dialect: { delimiter: ";" },
+        };
+        const result = await inferResource(resource);
+        expect(typeof result.dialect === "object" &&
+            "delimiter" in result.dialect &&
+            result.dialect.delimiter).toBe(";");
+    });
+    it("should not override existing schema", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n2,bob");
+        const customSchema = {
+            fields: [
+                { name: "custom1", type: "string" },
+                { name: "custom2", type: "string" },
+            ],
+        };
+        const resource = {
+            path: csvPath,
+            format: "csv",
+            schema: customSchema,
+        };
+        const result = await inferResource(resource);
+        expect(result.schema).toEqual(customSchema);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"infer.spec.js","sourceRoot":"","sources":["../../resource/infer.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import { writeTempFile } from \"@frictionless-ts/dataset\"\nimport { describe, expect, it } from \"vitest\"\nimport { inferResource } from \"./infer.ts\"\n\ndescribe(\"inferResource\", () => {\n  it(\"should infer name from path\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\\n2,bob\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const result = await inferResource(resource)\n\n    expect(result.name).toBeDefined()\n    expect(typeof result.name).toBe(\"string\")\n  })\n\n  it(\"should infer bytes (file size)\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\\n2,bob\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const result = await inferResource(resource)\n\n    expect(result.bytes).toBeGreaterThan(0)\n  })\n\n  it(\"should infer hash\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\\n2,bob\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const result = await inferResource(resource)\n\n    expect(result.hash).toBeDefined()\n    expect(typeof result.hash).toBe(\"string\")\n    expect(result.hash?.length).toBeGreaterThan(0)\n  })\n\n  it(\"should infer dialect for CSV files\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\\n2,bob\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const result = await inferResource(resource)\n\n    expect(result.dialect).toBeDefined()\n  })\n\n  it(\"should infer schema for tabular data\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\\n2,bob\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const result = await inferResource(resource)\n\n    expect(result.schema).toBeDefined()\n    expect(\n      typeof result.schema === \"object\" &&\n        \"fields\" in result.schema &&\n        result.schema.fields,\n    ).toBeDefined()\n    expect(\n      typeof result.schema === \"object\" &&\n        \"fields\" in result.schema &&\n        result.schema.fields?.length,\n    ).toBeGreaterThan(0)\n  })\n\n  it(\"should set type to table when schema is inferred\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\\n2,bob\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const result = await inferResource(resource)\n\n    expect(result.type).toBe(\"table\")\n  })\n\n  it(\"should preserve existing properties\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\\n2,bob\")\n    const resource = {\n      path: csvPath,\n      format: \"csv\" as const,\n      name: \"custom-name\",\n      title: \"Custom Title\",\n      description: \"Custom description\",\n    }\n\n    const result = await inferResource(resource)\n\n    expect(result.name).toBe(\"custom-name\")\n    expect(result.title).toBe(\"Custom Title\")\n    expect(result.description).toBe(\"Custom description\")\n  })\n\n  it(\"should not override existing format\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\\n2,bob\")\n    const resource = {\n      path: csvPath,\n      format: \"json\" as const,\n    }\n\n    const result = await inferResource(resource)\n\n    expect(result.format).toBe(\"json\")\n  })\n\n  it(\"should handle inline data 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 result = await inferResource(resource)\n\n    expect(result.name).toBe(\"test-resource\")\n    expect(result.data).toEqual(resource.data)\n    expect(result.bytes).toBeUndefined()\n    expect(result.hash).toBeUndefined()\n  })\n\n  it(\"should infer dialect with custom options\", async () => {\n    const csvPath = await writeTempFile(\"id|name\\n1|alice\\n2|bob\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const result = await inferResource(resource, { delimiter: \"|\" })\n\n    expect(result.dialect).toBeDefined()\n  })\n\n  it(\"should infer schema 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\n    const result = await inferResource(resource, { delimiter: \"|\" })\n\n    expect(result.schema).toBeDefined()\n    expect(\n      typeof result.schema === \"object\" &&\n        \"fields\" in result.schema &&\n        result.schema.fields,\n    ).toBeDefined()\n    expect(\n      typeof result.schema === \"object\" &&\n        \"fields\" in result.schema &&\n        result.schema.fields?.length,\n    ).toBe(2)\n  })\n\n  it(\"should not override existing encoding\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\\n2,bob\")\n    const resource = {\n      path: csvPath,\n      format: \"csv\" as const,\n      encoding: \"iso-8859-1\",\n    }\n\n    const result = await inferResource(resource)\n\n    expect(result.encoding).toBe(\"iso-8859-1\")\n  })\n\n  it(\"should not override existing bytes\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\\n2,bob\")\n    const resource = {\n      path: csvPath,\n      format: \"csv\" as const,\n      bytes: 12345,\n    }\n\n    const result = await inferResource(resource)\n\n    expect(result.bytes).toBe(12345)\n  })\n\n  it(\"should not override existing hash\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\\n2,bob\")\n    const resource = {\n      path: csvPath,\n      format: \"csv\" as const,\n      hash: \"custom-hash\",\n    }\n\n    const result = await inferResource(resource)\n\n    expect(result.hash).toBe(\"custom-hash\")\n  })\n\n  it(\"should not override existing dialect\", 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 result = await inferResource(resource)\n\n    expect(\n      typeof result.dialect === \"object\" &&\n        \"delimiter\" in result.dialect &&\n        result.dialect.delimiter,\n    ).toBe(\";\")\n  })\n\n  it(\"should not override existing schema\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\\n2,bob\")\n    const customSchema = {\n      fields: [\n        { name: \"custom1\", type: \"string\" as const },\n        { name: \"custom2\", type: \"string\" as const },\n      ],\n    }\n    const resource = {\n      path: csvPath,\n      format: \"csv\" as const,\n      schema: customSchema,\n    }\n\n    const result = await inferResource(resource)\n\n    expect(result.schema).toEqual(customSchema)\n  })\n})\n"]}

package/build/resource/validate.d.ts

@@ -0,0 +1,12 @@
+import type { Descriptor, Resource } from "@frictionless-ts/metadata";
+import type { InferSchemaOptions } from "@frictionless-ts/table";
+export declare function validateResource(source: string | Descriptor | Partial<Resource>, options?: InferSchemaOptions & {
+    basepath?: string;
+}): Promise<{
+    errors: import("@frictionless-ts/metadata").UnboundError[];
+    valid: boolean;
+}>;
+export declare function validateResourceData(resource: Partial<Resource>, options?: InferSchemaOptions): Promise<{
+    errors: import("@frictionless-ts/metadata").UnboundError[];
+    valid: boolean;
+}>;

package/build/resource/validate.js

@@ -0,0 +1,35 @@
+import { validateFile } from "@frictionless-ts/dataset";
+import { validateDocument } from "@frictionless-ts/document";
+import { createReport } from "@frictionless-ts/metadata";
+import { loadDescriptor, validateResourceMetadata, } from "@frictionless-ts/metadata";
+import { resolveBasepath } from "@frictionless-ts/metadata";
+import { validateTable } from "../table/index.js";
+export async function validateResource(source, options) {
+    let descriptor = source;
+    let basepath = options?.basepath;
+    if (typeof descriptor === "string") {
+        basepath = await resolveBasepath(descriptor);
+        descriptor = await loadDescriptor(descriptor);
+    }
+    const report = await validateResourceMetadata(descriptor, { basepath });
+    if (!report.resource) {
+        return report;
+    }
+    return await validateResourceData(report.resource, options);
+}
+export async function validateResourceData(resource, options) {
+    const fileReport = await validateFile(resource);
+    if (!fileReport.valid) {
+        return fileReport;
+    }
+    const tableReport = await validateTable(resource, options);
+    if (!tableReport.valid) {
+        return tableReport;
+    }
+    const documentReport = await validateDocument(resource);
+    if (!documentReport.valid) {
+        return documentReport;
+    }
+    return createReport();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/resource/validate.spec.d.ts

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

package/build/resource/validate.spec.js

@@ -0,0 +1,147 @@
+import { describe, expect, it } from "vitest";
+import { validateResource } from "./validate.js";
+describe("validateResource", () => {
+    it("should catch validation errors for invalid tabular data", async () => {
+        const resource = {
+            name: "test",
+            type: "table",
+            data: [
+                { id: 1, name: "Alice", active: true },
+                { id: 2, name: "Bob", active: 123 },
+            ],
+            schema: {
+                fields: [
+                    { name: "id", type: "integer" },
+                    { name: "name", type: "string" },
+                    { name: "active", type: "boolean" },
+                ],
+            },
+        };
+        const report = await validateResource(resource);
+        expect(report.valid).toBe(false);
+        expect(report.errors.length).toEqual(1);
+    });
+    it("should validate correct tabular data", async () => {
+        const resource = {
+            name: "test",
+            type: "table",
+            data: [
+                { name: "Alice", active: true },
+                { name: "Bob", active: false },
+            ],
+            schema: {
+                fields: [
+                    { name: "name", type: "string" },
+                    { name: "active", type: "boolean" },
+                ],
+            },
+        };
+        const report = await validateResource(resource);
+        expect(report.valid).toBe(true);
+        expect(report.errors).toEqual([]);
+    });
+    it("should catch multiple validation errors", async () => {
+        const resource = {
+            name: "test",
+            type: "table",
+            data: [
+                { id: 1, name: "Alice", age: 25 },
+                { id: "not-a-number", name: "Bob", age: "not-a-number" },
+                { id: 3, name: "Charlie", age: -5 },
+            ],
+            schema: {
+                fields: [
+                    { name: "id", type: "integer" },
+                    { name: "name", type: "string" },
+                    {
+                        name: "age",
+                        type: "integer",
+                        constraints: { minimum: 0 },
+                    },
+                ],
+            },
+        };
+        const report = await validateResource(resource);
+        expect(report.valid).toBe(false);
+        expect(report.errors.length).toEqual(3);
+    });
+    it("should catch missing table error when schema is defined but table cannot be loaded", async () => {
+        const resource = {
+            name: "test",
+            path: "table.bad",
+            schema: {
+                fields: [
+                    { name: "id", type: "integer" },
+                    { name: "name", type: "string" },
+                ],
+            },
+        };
+        const report = await validateResource(resource);
+        expect(report.valid).toBe(false);
+        expect(report.errors).toEqual([
+            {
+                type: "data",
+                message: "missing test table",
+            },
+        ]);
+    });
+    it("should validate document with jsonSchema", async () => {
+        const resource = {
+            name: "test-document",
+            data: {
+                name: "test-package",
+                version: "1.0.0",
+                author: {
+                    name: "John Doe",
+                    email: "john@example.com",
+                },
+            },
+            jsonSchema: {
+                type: "object",
+                required: ["name", "version", "author"],
+                properties: {
+                    name: { type: "string" },
+                    version: { type: "string" },
+                    author: {
+                        type: "object",
+                        required: ["name", "email"],
+                        properties: {
+                            name: { type: "string" },
+                            email: { type: "string" },
+                        },
+                    },
+                },
+            },
+        };
+        const report = await validateResource(resource);
+        expect(report.valid).toBe(true);
+        expect(report.errors).toEqual([]);
+    });
+    it("should catch validation errors for document with invalid jsonSchema data", async () => {
+        const resource = {
+            name: "test-document",
+            data: {
+                name: "test-package",
+                version: 123,
+            },
+            jsonSchema: {
+                type: "object",
+                required: ["name", "version"],
+                properties: {
+                    name: { type: "string" },
+                    version: { type: "string" },
+                },
+            },
+        };
+        const report = await validateResource(resource);
+        expect(report.valid).toBe(false);
+        expect(report.errors).toEqual([
+            {
+                type: "document/json",
+                pointer: "/version",
+                message: "must be string",
+            },
+        ]);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validate.spec.js","sourceRoot":"","sources":["../../resource/validate.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import { describe, expect, it } from \"vitest\"\nimport { validateResource } from \"./validate.ts\"\n\ndescribe(\"validateResource\", () => {\n  it(\"should catch validation errors for invalid tabular data\", async () => {\n    const resource = {\n      name: \"test\",\n      type: \"table\" as const,\n      data: [\n        { id: 1, name: \"Alice\", active: true },\n        { id: 2, name: \"Bob\", active: 123 },\n      ],\n      schema: {\n        fields: [\n          { name: \"id\", type: \"integer\" as const },\n          { name: \"name\", type: \"string\" as const },\n          { name: \"active\", type: \"boolean\" as const },\n        ],\n      },\n    }\n\n    const report = await validateResource(resource)\n\n    expect(report.valid).toBe(false)\n    expect(report.errors.length).toEqual(1)\n  })\n\n  it(\"should validate correct tabular data\", async () => {\n    const resource = {\n      name: \"test\",\n      type: \"table\" as const,\n      data: [\n        { name: \"Alice\", active: true },\n        { name: \"Bob\", active: false },\n      ],\n      schema: {\n        fields: [\n          { name: \"name\", type: \"string\" as const },\n          { name: \"active\", type: \"boolean\" as const },\n        ],\n      },\n    }\n\n    const report = await validateResource(resource)\n\n    expect(report.valid).toBe(true)\n    expect(report.errors).toEqual([])\n  })\n\n  it(\"should catch multiple validation errors\", async () => {\n    const resource = {\n      name: \"test\",\n      type: \"table\" as const,\n      data: [\n        { id: 1, name: \"Alice\", age: 25 },\n        { id: \"not-a-number\", name: \"Bob\", age: \"not-a-number\" },\n        { id: 3, name: \"Charlie\", age: -5 },\n      ],\n      schema: {\n        fields: [\n          { name: \"id\", type: \"integer\" as const },\n          { name: \"name\", type: \"string\" as const },\n          {\n            name: \"age\",\n            type: \"integer\" as const,\n            constraints: { minimum: 0 },\n          },\n        ],\n      },\n    }\n\n    const report = await validateResource(resource)\n\n    expect(report.valid).toBe(false)\n    expect(report.errors.length).toEqual(3)\n  })\n\n  it(\"should catch missing table error when schema is defined but table cannot be loaded\", async () => {\n    const resource = {\n      name: \"test\",\n      path: \"table.bad\",\n      schema: {\n        fields: [\n          { name: \"id\", type: \"integer\" as const },\n          { name: \"name\", type: \"string\" as const },\n        ],\n      },\n    }\n\n    const report = await validateResource(resource)\n\n    expect(report.valid).toBe(false)\n    expect(report.errors).toEqual([\n      {\n        type: \"data\",\n        message: \"missing test table\",\n      },\n    ])\n  })\n\n  it(\"should validate document with jsonSchema\", async () => {\n    const resource = {\n      name: \"test-document\",\n      data: {\n        name: \"test-package\",\n        version: \"1.0.0\",\n        author: {\n          name: \"John Doe\",\n          email: \"john@example.com\",\n        },\n      },\n      jsonSchema: {\n        type: \"object\",\n        required: [\"name\", \"version\", \"author\"],\n        properties: {\n          name: { type: \"string\" },\n          version: { type: \"string\" },\n          author: {\n            type: \"object\",\n            required: [\"name\", \"email\"],\n            properties: {\n              name: { type: \"string\" },\n              email: { type: \"string\" },\n            },\n          },\n        },\n      },\n    }\n\n    const report = await validateResource(resource)\n\n    expect(report.valid).toBe(true)\n    expect(report.errors).toEqual([])\n  })\n\n  it(\"should catch validation errors for document with invalid jsonSchema data\", async () => {\n    const resource = {\n      name: \"test-document\",\n      data: {\n        name: \"test-package\",\n        version: 123,\n      },\n      jsonSchema: {\n        type: \"object\",\n        required: [\"name\", \"version\"],\n        properties: {\n          name: { type: \"string\" },\n          version: { type: \"string\" },\n        },\n      },\n    }\n\n    const report = await validateResource(resource)\n\n    expect(report.valid).toBe(false)\n    expect(report.errors).toEqual([\n      {\n        type: \"document/json\",\n        pointer: \"/version\",\n        message: \"must be string\",\n      },\n    ])\n  })\n})\n"]}

package/build/schema/index.d.ts

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

package/build/schema/index.js

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

package/build/schema/infer.d.ts

@@ -0,0 +1,3 @@
+import type { Resource } from "@frictionless-ts/metadata";
+import type { InferSchemaOptions } from "@frictionless-ts/table";
+export declare function inferSchema(resource: Partial<Resource>, options?: InferSchemaOptions): Promise<import("@frictionless-ts/metadata").Schema | undefined>;

package/build/schema/infer.js

@@ -0,0 +1,18 @@
+import { inferSchemaFromTable } from "@frictionless-ts/table";
+import { system } from "../system.js";
+import { loadTable } from "../table/index.js";
+export async function inferSchema(resource, options) {
+    for (const plugin of system.plugins) {
+        const schema = await plugin.inferSchema?.(resource, options);
+        if (schema) {
+            return schema;
+        }
+    }
+    const table = await loadTable(resource, { denormalized: true });
+    if (!table) {
+        return undefined;
+    }
+    const schema = await inferSchemaFromTable(table, options);
+    return schema;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5mZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zY2hlbWEvaW5mZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sd0JBQXdCLENBQUE7QUFDN0QsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLGNBQWMsQ0FBQTtBQUNyQyxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sbUJBQW1CLENBQUE7QUFFN0MsTUFBTSxDQUFDLEtBQUssVUFBVSxXQUFXLENBQy9CLFFBQTJCLEVBQzNCLE9BQTRCO0lBRTVCLEtBQUssTUFBTSxNQUFNLElBQUksTUFBTSxDQUFDLE9BQU8sRUFBRSxDQUFDO1FBQ3BDLE1BQU0sTUFBTSxHQUFHLE1BQU0sTUFBTSxDQUFDLFdBQVcsRUFBRSxDQUFDLFFBQVEsRUFBRSxPQUFPLENBQUMsQ0FBQTtRQUM1RCxJQUFJLE1BQU0sRUFBRSxDQUFDO1lBQ1gsT0FBTyxNQUFNLENBQUE7UUFDZixDQUFDO0lBQ0gsQ0FBQztJQUVELE1BQU0sS0FBSyxHQUFHLE1BQU0sU0FBUyxDQUFDLFFBQVEsRUFBRSxFQUFFLFlBQVksRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFBO0lBQy9ELElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUNYLE9BQU8sU0FBUyxDQUFBO0lBQ2xCLENBQUM7SUFFRCxNQUFNLE1BQU0sR0FBRyxNQUFNLG9CQUFvQixDQUFDLEtBQUssRUFBRSxPQUFPLENBQUMsQ0FBQTtJQUN6RCxPQUFPLE1BQU0sQ0FBQTtBQUNmLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFJlc291cmNlIH0gZnJvbSBcIkBmcmljdGlvbmxlc3MtdHMvbWV0YWRhdGFcIlxuaW1wb3J0IHR5cGUgeyBJbmZlclNjaGVtYU9wdGlvbnMgfSBmcm9tIFwiQGZyaWN0aW9ubGVzcy10cy90YWJsZVwiXG5pbXBvcnQgeyBpbmZlclNjaGVtYUZyb21UYWJsZSB9IGZyb20gXCJAZnJpY3Rpb25sZXNzLXRzL3RhYmxlXCJcbmltcG9ydCB7IHN5c3RlbSB9IGZyb20gXCIuLi9zeXN0ZW0udHNcIlxuaW1wb3J0IHsgbG9hZFRhYmxlIH0gZnJvbSBcIi4uL3RhYmxlL2luZGV4LnRzXCJcblxuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGluZmVyU2NoZW1hKFxuICByZXNvdXJjZTogUGFydGlhbDxSZXNvdXJjZT4sXG4gIG9wdGlvbnM/OiBJbmZlclNjaGVtYU9wdGlvbnMsXG4pIHtcbiAgZm9yIChjb25zdCBwbHVnaW4gb2Ygc3lzdGVtLnBsdWdpbnMpIHtcbiAgICBjb25zdCBzY2hlbWEgPSBhd2FpdCBwbHVnaW4uaW5mZXJTY2hlbWE/LihyZXNvdXJjZSwgb3B0aW9ucylcbiAgICBpZiAoc2NoZW1hKSB7XG4gICAgICByZXR1cm4gc2NoZW1hXG4gICAgfVxuICB9XG5cbiAgY29uc3QgdGFibGUgPSBhd2FpdCBsb2FkVGFibGUocmVzb3VyY2UsIHsgZGVub3JtYWxpemVkOiB0cnVlIH0pXG4gIGlmICghdGFibGUpIHtcbiAgICByZXR1cm4gdW5kZWZpbmVkXG4gIH1cblxuICBjb25zdCBzY2hlbWEgPSBhd2FpdCBpbmZlclNjaGVtYUZyb21UYWJsZSh0YWJsZSwgb3B0aW9ucylcbiAgcmV0dXJuIHNjaGVtYVxufVxuIl19

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

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