@frictionless-ts/metadata 1.0.1

package/build/schema/convert/toJsonSchema.spec.js

@@ -0,0 +1,403 @@
+import { describe, expect, it } from "vitest";
+import { convertSchemaToJsonSchema } from "./toJsonSchema.js";
+describe("convertSchemaToJsonSchema", () => {
+    it("converts Table Schema to JSONSchema object", () => {
+        const tableSchema = {
+            title: "User Schema",
+            description: "Schema for user data",
+            fields: [
+                {
+                    name: "id",
+                    type: "integer",
+                    title: "User ID",
+                    description: "Unique identifier",
+                    constraints: {
+                        required: true,
+                        minimum: 1,
+                    },
+                },
+                {
+                    name: "name",
+                    type: "string",
+                    title: "Full Name",
+                    constraints: {
+                        required: true,
+                        maxLength: 100,
+                    },
+                },
+                {
+                    name: "email",
+                    type: "string",
+                    constraints: {
+                        pattern: "^[^@]+@[^@]+\\.[^@]+$",
+                    },
+                },
+                {
+                    name: "age",
+                    type: "integer",
+                    constraints: {
+                        minimum: 0,
+                        maximum: 150,
+                    },
+                },
+                {
+                    name: "isActive",
+                    type: "boolean",
+                },
+                {
+                    name: "tags",
+                    type: "array",
+                    constraints: {
+                        minLength: 0,
+                        maxLength: 10,
+                    },
+                },
+                {
+                    name: "metadata",
+                    type: "object",
+                    constraints: {
+                        jsonSchema: {
+                            type: "object",
+                            properties: {
+                                category: { type: "string" },
+                            },
+                        },
+                    },
+                },
+            ],
+        };
+        const jsonSchema = convertSchemaToJsonSchema(tableSchema);
+        expect(jsonSchema.title).toBe("User Schema");
+        expect(jsonSchema.description).toBe("Schema for user data");
+        expect(jsonSchema.type).toBe("object");
+        expect(jsonSchema.required).toEqual(["id", "name"]);
+        expect(Object.keys(jsonSchema.properties || {})).toHaveLength(7);
+        expect(jsonSchema.properties?.id).toEqual({
+            type: "integer",
+            title: "User ID",
+            description: "Unique identifier",
+            minimum: 1,
+        });
+        expect(jsonSchema.properties?.name).toEqual({
+            type: "string",
+            title: "Full Name",
+            maxLength: 100,
+        });
+        expect(jsonSchema.properties?.email).toEqual({
+            type: "string",
+            pattern: "^[^@]+@[^@]+\\.[^@]+$",
+        });
+        expect(jsonSchema.properties?.age).toEqual({
+            type: "integer",
+            minimum: 0,
+            maximum: 150,
+        });
+        expect(jsonSchema.properties?.isActive).toEqual({
+            type: "boolean",
+        });
+        expect(jsonSchema.properties?.tags).toEqual({
+            type: "array",
+            minItems: 0,
+            maxItems: 10,
+        });
+        expect(jsonSchema.properties?.metadata).toEqual({
+            type: "object",
+            properties: {
+                category: { type: "string" },
+            },
+        });
+    });
+    it("handles string field types with various constraints", () => {
+        const tableSchema = {
+            fields: [
+                {
+                    name: "basicString",
+                    type: "string",
+                },
+                {
+                    name: "constrainedString",
+                    type: "string",
+                    constraints: {
+                        minLength: 5,
+                        maxLength: 50,
+                        pattern: "^[A-Z]",
+                        enum: ["Option1", "Option2", "Option3"],
+                    },
+                },
+            ],
+        };
+        const jsonSchema = convertSchemaToJsonSchema(tableSchema);
+        expect(jsonSchema.properties?.basicString).toEqual({
+            type: "string",
+        });
+        expect(jsonSchema.properties?.constrainedString).toEqual({
+            type: "string",
+            minLength: 5,
+            maxLength: 50,
+            pattern: "^[A-Z]",
+            enum: ["Option1", "Option2", "Option3"],
+        });
+    });
+    it("handles numeric field types", () => {
+        const tableSchema = {
+            fields: [
+                {
+                    name: "simpleNumber",
+                    type: "number",
+                },
+                {
+                    name: "constrainedNumber",
+                    type: "number",
+                    constraints: {
+                        minimum: 0.1,
+                        maximum: 99.9,
+                    },
+                },
+                {
+                    name: "simpleInteger",
+                    type: "integer",
+                },
+                {
+                    name: "constrainedInteger",
+                    type: "integer",
+                    constraints: {
+                        minimum: 1,
+                        maximum: 100,
+                    },
+                },
+            ],
+        };
+        const jsonSchema = convertSchemaToJsonSchema(tableSchema);
+        expect(jsonSchema.properties?.simpleNumber).toEqual({
+            type: "number",
+        });
+        expect(jsonSchema.properties?.constrainedNumber).toEqual({
+            type: "number",
+            minimum: 0.1,
+            maximum: 99.9,
+        });
+        expect(jsonSchema.properties?.simpleInteger).toEqual({
+            type: "integer",
+        });
+        expect(jsonSchema.properties?.constrainedInteger).toEqual({
+            type: "integer",
+            minimum: 1,
+            maximum: 100,
+        });
+    });
+    it("handles array and object field types", () => {
+        const tableSchema = {
+            fields: [
+                {
+                    name: "simpleArray",
+                    type: "array",
+                },
+                {
+                    name: "constrainedArray",
+                    type: "array",
+                    constraints: {
+                        minLength: 1,
+                        maxLength: 5,
+                        jsonSchema: {
+                            type: "string",
+                        },
+                    },
+                },
+                {
+                    name: "simpleObject",
+                    type: "object",
+                },
+                {
+                    name: "constrainedObject",
+                    type: "object",
+                    constraints: {
+                        jsonSchema: {
+                            type: "object",
+                            properties: {
+                                nested: { type: "string" },
+                            },
+                            required: ["nested"],
+                        },
+                    },
+                },
+            ],
+        };
+        const jsonSchema = convertSchemaToJsonSchema(tableSchema);
+        expect(jsonSchema.properties?.simpleArray).toEqual({
+            type: "array",
+        });
+        expect(jsonSchema.properties?.constrainedArray).toEqual({
+            type: "array",
+            minItems: 1,
+            maxItems: 5,
+            items: {
+                type: "string",
+            },
+        });
+        expect(jsonSchema.properties?.simpleObject).toEqual({
+            type: "object",
+        });
+        expect(jsonSchema.properties?.constrainedObject).toEqual({
+            type: "object",
+            properties: {
+                nested: { type: "string" },
+            },
+            required: ["nested"],
+        });
+    });
+    it("handles date and time field types", () => {
+        const tableSchema = {
+            fields: [
+                {
+                    name: "dateField",
+                    type: "date",
+                    title: "Date Field",
+                },
+                {
+                    name: "datetimeField",
+                    type: "datetime",
+                    description: "DateTime Field",
+                },
+                {
+                    name: "timeField",
+                    type: "time",
+                },
+                {
+                    name: "yearField",
+                    type: "year",
+                },
+                {
+                    name: "yearmonthField",
+                    type: "yearmonth",
+                },
+                {
+                    name: "durationField",
+                    type: "duration",
+                },
+            ],
+        };
+        const jsonSchema = convertSchemaToJsonSchema(tableSchema);
+        expect(jsonSchema.properties?.dateField).toEqual({
+            type: "string",
+            format: "date",
+            title: "Date Field",
+        });
+        expect(jsonSchema.properties?.datetimeField).toEqual({
+            type: "string",
+            format: "date-time",
+            description: "DateTime Field",
+        });
+        expect(jsonSchema.properties?.timeField).toEqual({
+            type: "string",
+            format: "time",
+        });
+        expect(jsonSchema.properties?.yearField).toEqual({
+            type: "string",
+            format: "year",
+        });
+        expect(jsonSchema.properties?.yearmonthField).toEqual({
+            type: "string",
+            format: "yearmonth",
+        });
+        expect(jsonSchema.properties?.durationField).toEqual({
+            type: "string",
+            format: "duration",
+        });
+    });
+    it("handles geospatial field types", () => {
+        const tableSchema = {
+            fields: [
+                {
+                    name: "geopointField",
+                    type: "geopoint",
+                },
+                {
+                    name: "geojsonField",
+                    type: "geojson",
+                },
+            ],
+        };
+        const jsonSchema = convertSchemaToJsonSchema(tableSchema);
+        expect(jsonSchema.properties?.geopointField).toEqual({
+            type: "string",
+            format: "geopoint",
+        });
+        expect(jsonSchema.properties?.geojsonField).toEqual({
+            type: "object",
+            format: "geojson",
+        });
+    });
+    it("handles special field types", () => {
+        const tableSchema = {
+            fields: [
+                {
+                    name: "listField",
+                    type: "list",
+                },
+                {
+                    name: "anyField",
+                    type: "any",
+                },
+            ],
+        };
+        const jsonSchema = convertSchemaToJsonSchema(tableSchema);
+        expect(jsonSchema.properties?.listField).toEqual({
+            type: "array",
+            format: "list",
+        });
+        expect(jsonSchema.properties?.anyField).toEqual({
+            type: "string",
+        });
+    });
+    it("handles schema without title and description", () => {
+        const tableSchema = {
+            fields: [
+                {
+                    name: "field1",
+                    type: "string",
+                },
+            ],
+        };
+        const jsonSchema = convertSchemaToJsonSchema(tableSchema);
+        expect(jsonSchema.title).toBeUndefined();
+        expect(jsonSchema.description).toBeUndefined();
+        expect(jsonSchema.type).toBe("object");
+        expect(jsonSchema.properties?.field1).toEqual({
+            type: "string",
+        });
+    });
+    it("handles schema with no required fields", () => {
+        const tableSchema = {
+            fields: [
+                {
+                    name: "optionalField1",
+                    type: "string",
+                },
+                {
+                    name: "optionalField2",
+                    type: "integer",
+                },
+            ],
+        };
+        const jsonSchema = convertSchemaToJsonSchema(tableSchema);
+        expect(jsonSchema.required).toBeUndefined();
+        expect(jsonSchema.properties?.optionalField1).toEqual({
+            type: "string",
+        });
+        expect(jsonSchema.properties?.optionalField2).toEqual({
+            type: "integer",
+        });
+    });
+    it("handles empty schema", () => {
+        const tableSchema = {
+            fields: [],
+        };
+        const jsonSchema = convertSchemaToJsonSchema(tableSchema);
+        expect(jsonSchema.type).toBe("object");
+        expect(jsonSchema.properties).toEqual({});
+        expect(jsonSchema.required).toBeUndefined();
+        expect(jsonSchema.title).toBeUndefined();
+        expect(jsonSchema.description).toBeUndefined();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toJsonSchema.spec.js","sourceRoot":"","sources":["../../../schema/convert/toJsonSchema.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import { describe, expect, it } from \"vitest\"\nimport type { Schema } from \"../Schema.ts\"\nimport { convertSchemaToJsonSchema } from \"./toJsonSchema.ts\"\n\ndescribe(\"convertSchemaToJsonSchema\", () => {\n  it(\"converts Table Schema to JSONSchema object\", () => {\n    const tableSchema: Schema & { title?: string; description?: string } = {\n      title: \"User Schema\",\n      description: \"Schema for user data\",\n      fields: [\n        {\n          name: \"id\",\n          type: \"integer\",\n          title: \"User ID\",\n          description: \"Unique identifier\",\n          constraints: {\n            required: true,\n            minimum: 1,\n          },\n        },\n        {\n          name: \"name\",\n          type: \"string\",\n          title: \"Full Name\",\n          constraints: {\n            required: true,\n            maxLength: 100,\n          },\n        },\n        {\n          name: \"email\",\n          type: \"string\",\n          constraints: {\n            pattern: \"^[^@]+@[^@]+\\\\.[^@]+$\",\n          },\n        },\n        {\n          name: \"age\",\n          type: \"integer\",\n          constraints: {\n            minimum: 0,\n            maximum: 150,\n          },\n        },\n        {\n          name: \"isActive\",\n          type: \"boolean\",\n        },\n        {\n          name: \"tags\",\n          type: \"array\",\n          constraints: {\n            minLength: 0,\n            maxLength: 10,\n          },\n        },\n        {\n          name: \"metadata\",\n          type: \"object\",\n          constraints: {\n            jsonSchema: {\n              type: \"object\",\n              properties: {\n                category: { type: \"string\" },\n              },\n            },\n          },\n        },\n      ],\n    }\n\n    const jsonSchema = convertSchemaToJsonSchema(tableSchema)\n\n    expect(jsonSchema.title).toBe(\"User Schema\")\n    expect(jsonSchema.description).toBe(\"Schema for user data\")\n    expect(jsonSchema.type).toBe(\"object\")\n    expect(jsonSchema.required).toEqual([\"id\", \"name\"])\n    expect(Object.keys(jsonSchema.properties || {})).toHaveLength(7)\n\n    expect((jsonSchema.properties as any)?.id).toEqual({\n      type: \"integer\",\n      title: \"User ID\",\n      description: \"Unique identifier\",\n      minimum: 1,\n    })\n\n    expect((jsonSchema.properties as any)?.name).toEqual({\n      type: \"string\",\n      title: \"Full Name\",\n      maxLength: 100,\n    })\n\n    expect((jsonSchema.properties as any)?.email).toEqual({\n      type: \"string\",\n      pattern: \"^[^@]+@[^@]+\\\\.[^@]+$\",\n    })\n\n    expect((jsonSchema.properties as any)?.age).toEqual({\n      type: \"integer\",\n      minimum: 0,\n      maximum: 150,\n    })\n\n    expect((jsonSchema.properties as any)?.isActive).toEqual({\n      type: \"boolean\",\n    })\n\n    expect((jsonSchema.properties as any)?.tags).toEqual({\n      type: \"array\",\n      minItems: 0,\n      maxItems: 10,\n    })\n\n    expect((jsonSchema.properties as any)?.metadata).toEqual({\n      type: \"object\",\n      properties: {\n        category: { type: \"string\" },\n      },\n    })\n  })\n\n  it(\"handles string field types with various constraints\", () => {\n    const tableSchema: Schema = {\n      fields: [\n        {\n          name: \"basicString\",\n          type: \"string\",\n        },\n        {\n          name: \"constrainedString\",\n          type: \"string\",\n          constraints: {\n            minLength: 5,\n            maxLength: 50,\n            pattern: \"^[A-Z]\",\n            enum: [\"Option1\", \"Option2\", \"Option3\"],\n          },\n        },\n      ],\n    }\n\n    const jsonSchema = convertSchemaToJsonSchema(tableSchema)\n\n    expect((jsonSchema.properties as any)?.basicString).toEqual({\n      type: \"string\",\n    })\n\n    expect((jsonSchema.properties as any)?.constrainedString).toEqual({\n      type: \"string\",\n      minLength: 5,\n      maxLength: 50,\n      pattern: \"^[A-Z]\",\n      enum: [\"Option1\", \"Option2\", \"Option3\"],\n    })\n  })\n\n  it(\"handles numeric field types\", () => {\n    const tableSchema: Schema = {\n      fields: [\n        {\n          name: \"simpleNumber\",\n          type: \"number\",\n        },\n        {\n          name: \"constrainedNumber\",\n          type: \"number\",\n          constraints: {\n            minimum: 0.1,\n            maximum: 99.9,\n          },\n        },\n        {\n          name: \"simpleInteger\",\n          type: \"integer\",\n        },\n        {\n          name: \"constrainedInteger\",\n          type: \"integer\",\n          constraints: {\n            minimum: 1,\n            maximum: 100,\n          },\n        },\n      ],\n    }\n\n    const jsonSchema = convertSchemaToJsonSchema(tableSchema)\n\n    expect((jsonSchema.properties as any)?.simpleNumber).toEqual({\n      type: \"number\",\n    })\n\n    expect((jsonSchema.properties as any)?.constrainedNumber).toEqual({\n      type: \"number\",\n      minimum: 0.1,\n      maximum: 99.9,\n    })\n\n    expect((jsonSchema.properties as any)?.simpleInteger).toEqual({\n      type: \"integer\",\n    })\n\n    expect((jsonSchema.properties as any)?.constrainedInteger).toEqual({\n      type: \"integer\",\n      minimum: 1,\n      maximum: 100,\n    })\n  })\n\n  it(\"handles array and object field types\", () => {\n    const tableSchema: Schema = {\n      fields: [\n        {\n          name: \"simpleArray\",\n          type: \"array\",\n        },\n        {\n          name: \"constrainedArray\",\n          type: \"array\",\n          constraints: {\n            minLength: 1,\n            maxLength: 5,\n            jsonSchema: {\n              type: \"string\",\n            },\n          },\n        },\n        {\n          name: \"simpleObject\",\n          type: \"object\",\n        },\n        {\n          name: \"constrainedObject\",\n          type: \"object\",\n          constraints: {\n            jsonSchema: {\n              type: \"object\",\n              properties: {\n                nested: { type: \"string\" },\n              },\n              required: [\"nested\"],\n            },\n          },\n        },\n      ],\n    }\n\n    const jsonSchema = convertSchemaToJsonSchema(tableSchema)\n\n    expect((jsonSchema.properties as any)?.simpleArray).toEqual({\n      type: \"array\",\n    })\n\n    expect((jsonSchema.properties as any)?.constrainedArray).toEqual({\n      type: \"array\",\n      minItems: 1,\n      maxItems: 5,\n      items: {\n        type: \"string\",\n      },\n    })\n\n    expect((jsonSchema.properties as any)?.simpleObject).toEqual({\n      type: \"object\",\n    })\n\n    expect((jsonSchema.properties as any)?.constrainedObject).toEqual({\n      type: \"object\",\n      properties: {\n        nested: { type: \"string\" },\n      },\n      required: [\"nested\"],\n    })\n  })\n\n  it(\"handles date and time field types\", () => {\n    const tableSchema: Schema = {\n      fields: [\n        {\n          name: \"dateField\",\n          type: \"date\",\n          title: \"Date Field\",\n        },\n        {\n          name: \"datetimeField\",\n          type: \"datetime\",\n          description: \"DateTime Field\",\n        },\n        {\n          name: \"timeField\",\n          type: \"time\",\n        },\n        {\n          name: \"yearField\",\n          type: \"year\",\n        },\n        {\n          name: \"yearmonthField\",\n          type: \"yearmonth\",\n        },\n        {\n          name: \"durationField\",\n          type: \"duration\",\n        },\n      ],\n    }\n\n    const jsonSchema = convertSchemaToJsonSchema(tableSchema)\n\n    expect((jsonSchema.properties as any)?.dateField).toEqual({\n      type: \"string\",\n      format: \"date\",\n      title: \"Date Field\",\n    })\n\n    expect((jsonSchema.properties as any)?.datetimeField).toEqual({\n      type: \"string\",\n      format: \"date-time\",\n      description: \"DateTime Field\",\n    })\n\n    expect((jsonSchema.properties as any)?.timeField).toEqual({\n      type: \"string\",\n      format: \"time\",\n    })\n\n    expect((jsonSchema.properties as any)?.yearField).toEqual({\n      type: \"string\",\n      format: \"year\",\n    })\n\n    expect((jsonSchema.properties as any)?.yearmonthField).toEqual({\n      type: \"string\",\n      format: \"yearmonth\",\n    })\n\n    expect((jsonSchema.properties as any)?.durationField).toEqual({\n      type: \"string\",\n      format: \"duration\",\n    })\n  })\n\n  it(\"handles geospatial field types\", () => {\n    const tableSchema: Schema = {\n      fields: [\n        {\n          name: \"geopointField\",\n          type: \"geopoint\",\n        },\n        {\n          name: \"geojsonField\",\n          type: \"geojson\",\n        },\n      ],\n    }\n\n    const jsonSchema = convertSchemaToJsonSchema(tableSchema)\n\n    expect((jsonSchema.properties as any)?.geopointField).toEqual({\n      type: \"string\",\n      format: \"geopoint\",\n    })\n\n    expect((jsonSchema.properties as any)?.geojsonField).toEqual({\n      type: \"object\",\n      format: \"geojson\",\n    })\n  })\n\n  it(\"handles special field types\", () => {\n    const tableSchema: Schema = {\n      fields: [\n        {\n          name: \"listField\",\n          type: \"list\",\n        },\n        {\n          name: \"anyField\",\n          type: \"any\",\n        },\n      ],\n    }\n\n    const jsonSchema = convertSchemaToJsonSchema(tableSchema)\n\n    expect((jsonSchema.properties as any)?.listField).toEqual({\n      type: \"array\",\n      format: \"list\",\n    })\n\n    expect((jsonSchema.properties as any)?.anyField).toEqual({\n      type: \"string\",\n    })\n  })\n\n  it(\"handles schema without title and description\", () => {\n    const tableSchema: Schema = {\n      fields: [\n        {\n          name: \"field1\",\n          type: \"string\",\n        },\n      ],\n    }\n\n    const jsonSchema = convertSchemaToJsonSchema(tableSchema)\n\n    expect(jsonSchema.title).toBeUndefined()\n    expect(jsonSchema.description).toBeUndefined()\n    expect(jsonSchema.type).toBe(\"object\")\n    expect((jsonSchema.properties as any)?.field1).toEqual({\n      type: \"string\",\n    })\n  })\n\n  it(\"handles schema with no required fields\", () => {\n    const tableSchema: Schema = {\n      fields: [\n        {\n          name: \"optionalField1\",\n          type: \"string\",\n        },\n        {\n          name: \"optionalField2\",\n          type: \"integer\",\n        },\n      ],\n    }\n\n    const jsonSchema = convertSchemaToJsonSchema(tableSchema)\n\n    expect(jsonSchema.required).toBeUndefined()\n    expect((jsonSchema.properties as any)?.optionalField1).toEqual({\n      type: \"string\",\n    })\n    expect((jsonSchema.properties as any)?.optionalField2).toEqual({\n      type: \"integer\",\n    })\n  })\n\n  it(\"handles empty schema\", () => {\n    const tableSchema: Schema = {\n      fields: [],\n    }\n\n    const jsonSchema = convertSchemaToJsonSchema(tableSchema)\n\n    expect(jsonSchema.type).toBe(\"object\")\n    expect(jsonSchema.properties).toEqual({})\n    expect(jsonSchema.required).toBeUndefined()\n    expect(jsonSchema.title).toBeUndefined()\n    expect(jsonSchema.description).toBeUndefined()\n  })\n})\n"]}

package/build/schema/index.d.ts

@@ -0,0 +1,11 @@
+export type { Schema } from "./Schema.ts";
+export type { ForeignKey } from "./ForeignKey.ts";
+export { assertSchema } from "./assert.ts";
+export { loadSchema } from "./load.ts";
+export { saveSchema } from "./save.ts";
+export { validateSchema } from "./validate.ts";
+export { convertSchemaFromDescriptor } from "./convert/fromDescriptor.ts";
+export { convertSchemaToDescriptor } from "./convert/toDescriptor.ts";
+export { convertSchemaFromJsonSchema } from "./convert/fromJsonSchema.ts";
+export { convertSchemaToJsonSchema } from "./convert/toJsonSchema.ts";
+export { resolveSchema } from "./resolve.ts";

package/build/schema/index.js

@@ -0,0 +1,10 @@
+export { assertSchema } from "./assert.js";
+export { loadSchema } from "./load.js";
+export { saveSchema } from "./save.js";
+export { validateSchema } from "./validate.js";
+export { convertSchemaFromDescriptor } from "./convert/fromDescriptor.js";
+export { convertSchemaToDescriptor } from "./convert/toDescriptor.js";
+export { convertSchemaFromJsonSchema } from "./convert/fromJsonSchema.js";
+export { convertSchemaToJsonSchema } from "./convert/toJsonSchema.js";
+export { resolveSchema } from "./resolve.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zY2hlbWEvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGFBQWEsQ0FBQTtBQUMxQyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sV0FBVyxDQUFBO0FBQ3RDLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxXQUFXLENBQUE7QUFDdEMsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQTtBQUM5QyxPQUFPLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQTtBQUN6RSxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQTtBQUNyRSxPQUFPLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQTtBQUN6RSxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQTtBQUNyRSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sY0FBYyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHR5cGUgeyBTY2hlbWEgfSBmcm9tIFwiLi9TY2hlbWEudHNcIlxuZXhwb3J0IHR5cGUgeyBGb3JlaWduS2V5IH0gZnJvbSBcIi4vRm9yZWlnbktleS50c1wiXG5leHBvcnQgeyBhc3NlcnRTY2hlbWEgfSBmcm9tIFwiLi9hc3NlcnQudHNcIlxuZXhwb3J0IHsgbG9hZFNjaGVtYSB9IGZyb20gXCIuL2xvYWQudHNcIlxuZXhwb3J0IHsgc2F2ZVNjaGVtYSB9IGZyb20gXCIuL3NhdmUudHNcIlxuZXhwb3J0IHsgdmFsaWRhdGVTY2hlbWEgfSBmcm9tIFwiLi92YWxpZGF0ZS50c1wiXG5leHBvcnQgeyBjb252ZXJ0U2NoZW1hRnJvbURlc2NyaXB0b3IgfSBmcm9tIFwiLi9jb252ZXJ0L2Zyb21EZXNjcmlwdG9yLnRzXCJcbmV4cG9ydCB7IGNvbnZlcnRTY2hlbWFUb0Rlc2NyaXB0b3IgfSBmcm9tIFwiLi9jb252ZXJ0L3RvRGVzY3JpcHRvci50c1wiXG5leHBvcnQgeyBjb252ZXJ0U2NoZW1hRnJvbUpzb25TY2hlbWEgfSBmcm9tIFwiLi9jb252ZXJ0L2Zyb21Kc29uU2NoZW1hLnRzXCJcbmV4cG9ydCB7IGNvbnZlcnRTY2hlbWFUb0pzb25TY2hlbWEgfSBmcm9tIFwiLi9jb252ZXJ0L3RvSnNvblNjaGVtYS50c1wiXG5leHBvcnQgeyByZXNvbHZlU2NoZW1hIH0gZnJvbSBcIi4vcmVzb2x2ZS50c1wiXG4iXX0=

package/build/schema/load.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Load a Schema descriptor (JSON Object) from a file or URL
+ * Ensures the descriptor is valid against its profile
+ */
+export declare function loadSchema(path: string): Promise<import("./Schema.ts").Schema>;

package/build/schema/load.js

@@ -0,0 +1,12 @@
+import { loadDescriptor } from "../descriptor/index.js";
+import { assertSchema } from "./assert.js";
+/**
+ * Load a Schema descriptor (JSON Object) from a file or URL
+ * Ensures the descriptor is valid against its profile
+ */
+export async function loadSchema(path) {
+    const descriptor = await loadDescriptor(path);
+    const schema = await assertSchema(descriptor);
+    return schema;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NjaGVtYS9sb2FkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQTtBQUN2RCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sYUFBYSxDQUFBO0FBRTFDOzs7R0FHRztBQUNILE1BQU0sQ0FBQyxLQUFLLFVBQVUsVUFBVSxDQUFDLElBQVk7SUFDM0MsTUFBTSxVQUFVLEdBQUcsTUFBTSxjQUFjLENBQUMsSUFBSSxDQUFDLENBQUE7SUFDN0MsTUFBTSxNQUFNLEdBQUcsTUFBTSxZQUFZLENBQUMsVUFBVSxDQUFDLENBQUE7SUFDN0MsT0FBTyxNQUFNLENBQUE7QUFDZixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgbG9hZERlc2NyaXB0b3IgfSBmcm9tIFwiLi4vZGVzY3JpcHRvci9pbmRleC50c1wiXG5pbXBvcnQgeyBhc3NlcnRTY2hlbWEgfSBmcm9tIFwiLi9hc3NlcnQudHNcIlxuXG4vKipcbiAqIExvYWQgYSBTY2hlbWEgZGVzY3JpcHRvciAoSlNPTiBPYmplY3QpIGZyb20gYSBmaWxlIG9yIFVSTFxuICogRW5zdXJlcyB0aGUgZGVzY3JpcHRvciBpcyB2YWxpZCBhZ2FpbnN0IGl0cyBwcm9maWxlXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBsb2FkU2NoZW1hKHBhdGg6IHN0cmluZykge1xuICBjb25zdCBkZXNjcmlwdG9yID0gYXdhaXQgbG9hZERlc2NyaXB0b3IocGF0aClcbiAgY29uc3Qgc2NoZW1hID0gYXdhaXQgYXNzZXJ0U2NoZW1hKGRlc2NyaXB0b3IpXG4gIHJldHVybiBzY2hlbWFcbn1cbiJdfQ==

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

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

package/build/schema/load.spec.js

@@ -0,0 +1,55 @@
+import { join } from "node:path";
+import { describe, expect, expectTypeOf, it } from "vitest";
+import { loadSchema } from "./load.js";
+describe("loadSchema", () => {
+    const getFixturePath = (name) => join(import.meta.dirname, "fixtures", name);
+    const expectedSchema = {
+        fields: [
+            {
+                name: "id",
+                type: "integer",
+            },
+            {
+                name: "name",
+                type: "string",
+            },
+        ],
+    };
+    it("loads a schema from a local file path", async () => {
+        const schema = await loadSchema(getFixturePath("schema.json"));
+        expectTypeOf(schema).toEqualTypeOf();
+        expect(schema).toEqual(expectedSchema);
+    });
+    it("throws an error when schema is invalid", async () => {
+        await expect(loadSchema(getFixturePath("schema-invalid.json"))).rejects.toThrow();
+    });
+    it("loads a full schema with all features", async () => {
+        const schema = await loadSchema(getFixturePath("schema-full.json"));
+        expectTypeOf(schema).toEqualTypeOf();
+        expect(schema).toBeDefined();
+        expect(schema.$schema).toBe("https://datapackage.org/profiles/2.0/tableschema.json");
+        expect(schema.name).toBe("users");
+        expect(schema.title).toBe("User Data Schema");
+        expect(schema.description).toBe("A comprehensive schema for user data");
+        expect(schema.fields).toHaveLength(9);
+        expect(schema.fields[0]?.name).toBe("id");
+        expect(schema.fields[0]?.type).toBe("integer");
+        expect(schema.fields[0]?.constraints?.required).toBe(true);
+        expect(schema.fields[0]?.constraints?.unique).toBe(true);
+        expect(schema.fields[1]?.name).toBe("email");
+        expect(schema.fields[1]?.type).toBe("string");
+        expect(schema.fields[1]?.format).toBe("email");
+        expect(schema.fields[6]?.name).toBe("created_at");
+        expect(schema.fields[6]?.type).toBe("datetime");
+        expect(schema.primaryKey).toEqual(["id"]);
+        expect(schema.uniqueKeys).toHaveLength(2);
+        expect(schema.uniqueKeys?.[0]).toEqual(["email"]);
+        expect(schema.uniqueKeys?.[1]).toEqual(["name", "department_id"]);
+        expect(schema.foreignKeys).toHaveLength(1);
+        expect(schema.foreignKeys?.[0]?.fields).toEqual(["department_id"]);
+        expect(schema.foreignKeys?.[0]?.reference?.resource).toBe("departments");
+        expect(schema.foreignKeys?.[0]?.reference?.fields).toEqual(["id"]);
+        expect(schema.missingValues).toEqual(["", "NA", "N/A", "null"]);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/schema/resolve.d.ts

@@ -0,0 +1,2 @@
+import type { Schema } from "./Schema.ts";
+export declare function resolveSchema(schema?: Schema | string): Promise<Schema | undefined>;

package/build/schema/resolve.js

@@ -0,0 +1,11 @@
+import { loadSchema } from "../schema/index.js";
+export async function resolveSchema(schema) {
+    if (!schema) {
+        return undefined;
+    }
+    if (typeof schema !== "string") {
+        return schema;
+    }
+    return await loadSchema(schema);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzb2x2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NjaGVtYS9yZXNvbHZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQTtBQUcvQyxNQUFNLENBQUMsS0FBSyxVQUFVLGFBQWEsQ0FBQyxNQUF3QjtJQUMxRCxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUM7UUFDWixPQUFPLFNBQVMsQ0FBQTtJQUNsQixDQUFDO0lBRUQsSUFBSSxPQUFPLE1BQU0sS0FBSyxRQUFRLEVBQUUsQ0FBQztRQUMvQixPQUFPLE1BQU0sQ0FBQTtJQUNmLENBQUM7SUFFRCxPQUFPLE1BQU0sVUFBVSxDQUFDLE1BQU0sQ0FBQyxDQUFBO0FBQ2pDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBsb2FkU2NoZW1hIH0gZnJvbSBcIi4uL3NjaGVtYS9pbmRleC50c1wiXG5pbXBvcnQgdHlwZSB7IFNjaGVtYSB9IGZyb20gXCIuL1NjaGVtYS50c1wiXG5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiByZXNvbHZlU2NoZW1hKHNjaGVtYT86IFNjaGVtYSB8IHN0cmluZykge1xuICBpZiAoIXNjaGVtYSkge1xuICAgIHJldHVybiB1bmRlZmluZWRcbiAgfVxuXG4gIGlmICh0eXBlb2Ygc2NoZW1hICE9PSBcInN0cmluZ1wiKSB7XG4gICAgcmV0dXJuIHNjaGVtYVxuICB9XG5cbiAgcmV0dXJuIGF3YWl0IGxvYWRTY2hlbWEoc2NoZW1hKVxufVxuIl19

package/build/schema/save.d.ts

@@ -0,0 +1,9 @@
+import type { Schema } from "./Schema.ts";
+/**
+ * Save a Schema to a file path
+ * Works in Node.js environments
+ */
+export declare function saveSchema(schema: Schema, options: {
+    path: string;
+    overwrite?: boolean;
+}): Promise<void>;

package/build/schema/save.js

@@ -0,0 +1,16 @@
+import { saveDescriptor } from "../descriptor/index.js";
+import { convertSchemaToDescriptor } from "./convert/toDescriptor.js";
+const CURRENT_PROFILE = "https://datapackage.org/profiles/2.0/tableschema.json";
+/**
+ * Save a Schema to a file path
+ * Works in Node.js environments
+ */
+export async function saveSchema(schema, options) {
+    const descriptor = convertSchemaToDescriptor(schema);
+    descriptor.$schema = descriptor.$schema ?? CURRENT_PROFILE;
+    await saveDescriptor(descriptor, {
+        path: options.path,
+        overwrite: options.overwrite,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2F2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NjaGVtYS9zYXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQTtBQUV2RCxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQTtBQUVyRSxNQUFNLGVBQWUsR0FBRyx1REFBdUQsQ0FBQTtBQUUvRTs7O0dBR0c7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLFVBQVUsQ0FDOUIsTUFBYyxFQUNkLE9BR0M7SUFFRCxNQUFNLFVBQVUsR0FBRyx5QkFBeUIsQ0FBQyxNQUFNLENBQUMsQ0FBQTtJQUNwRCxVQUFVLENBQUMsT0FBTyxHQUFHLFVBQVUsQ0FBQyxPQUFPLElBQUksZUFBZSxDQUFBO0lBRTFELE1BQU0sY0FBYyxDQUFDLFVBQVUsRUFBRTtRQUMvQixJQUFJLEVBQUUsT0FBTyxDQUFDLElBQUk7UUFDbEIsU0FBUyxFQUFFLE9BQU8sQ0FBQyxTQUFTO0tBQzdCLENBQUMsQ0FBQTtBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBzYXZlRGVzY3JpcHRvciB9IGZyb20gXCIuLi9kZXNjcmlwdG9yL2luZGV4LnRzXCJcbmltcG9ydCB0eXBlIHsgU2NoZW1hIH0gZnJvbSBcIi4vU2NoZW1hLnRzXCJcbmltcG9ydCB7IGNvbnZlcnRTY2hlbWFUb0Rlc2NyaXB0b3IgfSBmcm9tIFwiLi9jb252ZXJ0L3RvRGVzY3JpcHRvci50c1wiXG5cbmNvbnN0IENVUlJFTlRfUFJPRklMRSA9IFwiaHR0cHM6Ly9kYXRhcGFja2FnZS5vcmcvcHJvZmlsZXMvMi4wL3RhYmxlc2NoZW1hLmpzb25cIlxuXG4vKipcbiAqIFNhdmUgYSBTY2hlbWEgdG8gYSBmaWxlIHBhdGhcbiAqIFdvcmtzIGluIE5vZGUuanMgZW52aXJvbm1lbnRzXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBzYXZlU2NoZW1hKFxuICBzY2hlbWE6IFNjaGVtYSxcbiAgb3B0aW9uczoge1xuICAgIHBhdGg6IHN0cmluZ1xuICAgIG92ZXJ3cml0ZT86IGJvb2xlYW5cbiAgfSxcbikge1xuICBjb25zdCBkZXNjcmlwdG9yID0gY29udmVydFNjaGVtYVRvRGVzY3JpcHRvcihzY2hlbWEpXG4gIGRlc2NyaXB0b3IuJHNjaGVtYSA9IGRlc2NyaXB0b3IuJHNjaGVtYSA/PyBDVVJSRU5UX1BST0ZJTEVcblxuICBhd2FpdCBzYXZlRGVzY3JpcHRvcihkZXNjcmlwdG9yLCB7XG4gICAgcGF0aDogb3B0aW9ucy5wYXRoLFxuICAgIG92ZXJ3cml0ZTogb3B0aW9ucy5vdmVyd3JpdGUsXG4gIH0pXG59XG4iXX0=

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

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