@frictionless-ts/metadata 1.0.1

package/build/resource/save.spec.js

@@ -0,0 +1,170 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { temporaryDirectory } from "tempy";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { saveResourceDescriptor } from "./save.js";
+describe("saveResourceDescriptor", () => {
+    let testDir;
+    let testPath;
+    let testResource;
+    beforeEach(() => {
+        testDir = temporaryDirectory();
+        testPath = path.join(testDir, "resource.json");
+        testResource = {
+            name: "test-resource",
+            path: path.join(testDir, "data.csv"),
+        };
+    });
+    afterEach(async () => {
+        try {
+            await fs.rm(testDir, { recursive: true, force: true });
+        }
+        catch (error) {
+            if (error instanceof Error && !error.message.includes("ENOENT")) {
+                console.error(`Failed to clean up test directory: ${testDir}`, error);
+            }
+        }
+    });
+    it("should save a resource descriptor to a file and maintain its structure", async () => {
+        await saveResourceDescriptor(testResource, { path: testPath });
+        const fileExists = await fs
+            .stat(testPath)
+            .then(() => true)
+            .catch(() => false);
+        expect(fileExists).toBe(true);
+        const content = await fs.readFile(testPath, "utf-8");
+        const parsedContent = JSON.parse(content);
+        const { $schema, ...resourceWithoutSchema } = parsedContent;
+        expect(resourceWithoutSchema.name).toEqual(testResource.name);
+        expect(resourceWithoutSchema.path).toBe("data.csv");
+        expect($schema).toBe("https://datapackage.org/profiles/2.0/dataresource.json");
+    });
+    it("should add $schema property if not present", async () => {
+        await saveResourceDescriptor(testResource, { path: testPath });
+        const content = await fs.readFile(testPath, "utf-8");
+        const parsedContent = JSON.parse(content);
+        expect(parsedContent.$schema).toBe("https://datapackage.org/profiles/2.0/dataresource.json");
+    });
+    it("should preserve existing $schema property", async () => {
+        const resourceWithSchema = {
+            name: "test-resource",
+            path: path.join(testDir, "data.csv"),
+            $schema: "https://custom.schema.url",
+        };
+        await saveResourceDescriptor(resourceWithSchema, { path: testPath });
+        const content = await fs.readFile(testPath, "utf-8");
+        const parsedContent = JSON.parse(content);
+        expect(parsedContent.$schema).toBe("https://custom.schema.url");
+    });
+    it("should use pretty formatting with 2-space indentation", async () => {
+        await saveResourceDescriptor(testResource, { path: testPath });
+        const content = await fs.readFile(testPath, "utf-8");
+        const lines = content.split("\n");
+        expect(lines.length).toBeGreaterThan(1);
+        if (lines.length > 1 && lines[1]) {
+            expect(lines[1].startsWith("  ")).toBe(true);
+        }
+    });
+    it("should save resource with schema", async () => {
+        const resourceWithSchema = {
+            name: "test-resource",
+            path: path.join(testDir, "data.csv"),
+            schema: {
+                fields: [
+                    { name: "id", type: "integer" },
+                    { name: "name", type: "string" },
+                ],
+            },
+        };
+        await saveResourceDescriptor(resourceWithSchema, { path: testPath });
+        const content = await fs.readFile(testPath, "utf-8");
+        const parsedContent = JSON.parse(content);
+        expect(parsedContent.schema).toEqual(resourceWithSchema.schema);
+    });
+    it("should save resource with dialect", async () => {
+        const resourceWithDialect = {
+            name: "test-resource",
+            path: path.join(testDir, "data.csv"),
+            dialect: {
+                delimiter: ";",
+                lineTerminator: "\n",
+            },
+        };
+        await saveResourceDescriptor(resourceWithDialect, { path: testPath });
+        const content = await fs.readFile(testPath, "utf-8");
+        const parsedContent = JSON.parse(content);
+        expect(parsedContent.dialect).toEqual(resourceWithDialect.dialect);
+    });
+    it("should save resource to a nested directory path", async () => {
+        const nestedPath = path.join(testDir, "nested", "dir", "resource.json");
+        const nestedResource = {
+            name: "test-resource",
+            path: path.join(testDir, "nested", "dir", "data.csv"),
+        };
+        await saveResourceDescriptor(nestedResource, { path: nestedPath });
+        const fileExists = await fs
+            .stat(nestedPath)
+            .then(() => true)
+            .catch(() => false);
+        expect(fileExists).toBe(true);
+        const content = await fs.readFile(nestedPath, "utf-8");
+        const parsedContent = JSON.parse(content);
+        expect(parsedContent.name).toBe(nestedResource.name);
+    });
+    it("should throw an error when file exists and overwrite is false", async () => {
+        await saveResourceDescriptor(testResource, { path: testPath });
+        await expect(saveResourceDescriptor(testResource, {
+            path: testPath,
+            overwrite: false,
+        })).rejects.toThrow();
+    });
+    it("should throw an error when file exists and overwrite is not specified", async () => {
+        await saveResourceDescriptor(testResource, { path: testPath });
+        await expect(saveResourceDescriptor(testResource, { path: testPath })).rejects.toThrow();
+    });
+    it("should overwrite existing file when overwrite is true", async () => {
+        const initialResource = {
+            name: "initial",
+            path: path.join(testDir, "data1.csv"),
+        };
+        const updatedResource = {
+            name: "updated",
+            path: path.join(testDir, "data2.csv"),
+            description: "Updated resource",
+        };
+        await saveResourceDescriptor(initialResource, { path: testPath });
+        const initialContent = await fs.readFile(testPath, "utf-8");
+        const initialParsed = JSON.parse(initialContent);
+        expect(initialParsed.name).toBe("initial");
+        await saveResourceDescriptor(updatedResource, {
+            path: testPath,
+            overwrite: true,
+        });
+        const updatedContent = await fs.readFile(testPath, "utf-8");
+        const updatedParsed = JSON.parse(updatedContent);
+        expect(updatedParsed.name).toBe("updated");
+        expect(updatedParsed.description).toBe("Updated resource");
+    });
+    it("should save resource with all metadata fields", async () => {
+        const fullResource = {
+            name: "full-resource",
+            path: path.join(testDir, "data.csv"),
+            title: "Full Resource",
+            description: "A resource with all fields",
+            format: "csv",
+            mediatype: "text/csv",
+            encoding: "utf-8",
+            bytes: 1024,
+            hash: "abc123",
+        };
+        await saveResourceDescriptor(fullResource, { path: testPath });
+        const content = await fs.readFile(testPath, "utf-8");
+        const parsedContent = JSON.parse(content);
+        expect(parsedContent.name).toBe(fullResource.name);
+        expect(parsedContent.title).toBe(fullResource.title);
+        expect(parsedContent.description).toBe(fullResource.description);
+        expect(parsedContent.format).toBe(fullResource.format);
+        expect(parsedContent.bytes).toBe(fullResource.bytes);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"save.spec.js","sourceRoot":"","sources":["../../resource/save.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from \"node:fs/promises\"\nimport * as path from \"node:path\"\nimport { temporaryDirectory } from \"tempy\"\nimport { afterEach, beforeEach, describe, expect, it } from \"vitest\"\nimport type { Resource } from \"./Resource.ts\"\nimport { saveResourceDescriptor } from \"./save.ts\"\n\ndescribe(\"saveResourceDescriptor\", () => {\n  let testDir: string\n  let testPath: string\n  let testResource: Resource\n\n  beforeEach(() => {\n    testDir = temporaryDirectory()\n    testPath = path.join(testDir, \"resource.json\")\n    testResource = {\n      name: \"test-resource\",\n      path: path.join(testDir, \"data.csv\"),\n    }\n  })\n\n  afterEach(async () => {\n    try {\n      await fs.rm(testDir, { recursive: true, force: true })\n    } catch (error) {\n      if (error instanceof Error && !error.message.includes(\"ENOENT\")) {\n        console.error(`Failed to clean up test directory: ${testDir}`, error)\n      }\n    }\n  })\n\n  it(\"should save a resource descriptor to a file and maintain its structure\", async () => {\n    await saveResourceDescriptor(testResource, { path: testPath })\n\n    const fileExists = await fs\n      .stat(testPath)\n      .then(() => true)\n      .catch(() => false)\n    expect(fileExists).toBe(true)\n\n    const content = await fs.readFile(testPath, \"utf-8\")\n    const parsedContent = JSON.parse(content)\n\n    const { $schema, ...resourceWithoutSchema } = parsedContent\n    expect(resourceWithoutSchema.name).toEqual(testResource.name)\n    expect(resourceWithoutSchema.path).toBe(\"data.csv\")\n    expect($schema).toBe(\n      \"https://datapackage.org/profiles/2.0/dataresource.json\",\n    )\n  })\n\n  it(\"should add $schema property if not present\", async () => {\n    await saveResourceDescriptor(testResource, { path: testPath })\n\n    const content = await fs.readFile(testPath, \"utf-8\")\n    const parsedContent = JSON.parse(content)\n    expect(parsedContent.$schema).toBe(\n      \"https://datapackage.org/profiles/2.0/dataresource.json\",\n    )\n  })\n\n  it(\"should preserve existing $schema property\", async () => {\n    const resourceWithSchema: Resource = {\n      name: \"test-resource\",\n      path: path.join(testDir, \"data.csv\"),\n      $schema: \"https://custom.schema.url\",\n    }\n\n    await saveResourceDescriptor(resourceWithSchema, { path: testPath })\n\n    const content = await fs.readFile(testPath, \"utf-8\")\n    const parsedContent = JSON.parse(content)\n    expect(parsedContent.$schema).toBe(\"https://custom.schema.url\")\n  })\n\n  it(\"should use pretty formatting with 2-space indentation\", async () => {\n    await saveResourceDescriptor(testResource, { path: testPath })\n\n    const content = await fs.readFile(testPath, \"utf-8\")\n    const lines = content.split(\"\\n\")\n    expect(lines.length).toBeGreaterThan(1)\n\n    if (lines.length > 1 && lines[1]) {\n      expect(lines[1].startsWith(\"  \")).toBe(true)\n    }\n  })\n\n  it(\"should save resource with schema\", async () => {\n    const resourceWithSchema: Resource = {\n      name: \"test-resource\",\n      path: path.join(testDir, \"data.csv\"),\n      schema: {\n        fields: [\n          { name: \"id\", type: \"integer\" },\n          { name: \"name\", type: \"string\" },\n        ],\n      },\n    }\n\n    await saveResourceDescriptor(resourceWithSchema, { path: testPath })\n\n    const content = await fs.readFile(testPath, \"utf-8\")\n    const parsedContent = JSON.parse(content)\n    expect(parsedContent.schema).toEqual(resourceWithSchema.schema)\n  })\n\n  it(\"should save resource with dialect\", async () => {\n    const resourceWithDialect: Resource = {\n      name: \"test-resource\",\n      path: path.join(testDir, \"data.csv\"),\n      dialect: {\n        delimiter: \";\",\n        lineTerminator: \"\\n\",\n      },\n    }\n\n    await saveResourceDescriptor(resourceWithDialect, { path: testPath })\n\n    const content = await fs.readFile(testPath, \"utf-8\")\n    const parsedContent = JSON.parse(content)\n    expect(parsedContent.dialect).toEqual(resourceWithDialect.dialect)\n  })\n\n  it(\"should save resource to a nested directory path\", async () => {\n    const nestedPath = path.join(testDir, \"nested\", \"dir\", \"resource.json\")\n    const nestedResource: Resource = {\n      name: \"test-resource\",\n      path: path.join(testDir, \"nested\", \"dir\", \"data.csv\"),\n    }\n\n    await saveResourceDescriptor(nestedResource, { path: nestedPath })\n\n    const fileExists = await fs\n      .stat(nestedPath)\n      .then(() => true)\n      .catch(() => false)\n    expect(fileExists).toBe(true)\n\n    const content = await fs.readFile(nestedPath, \"utf-8\")\n    const parsedContent = JSON.parse(content)\n    expect(parsedContent.name).toBe(nestedResource.name)\n  })\n\n  it(\"should throw an error when file exists and overwrite is false\", async () => {\n    await saveResourceDescriptor(testResource, { path: testPath })\n\n    await expect(\n      saveResourceDescriptor(testResource, {\n        path: testPath,\n        overwrite: false,\n      }),\n    ).rejects.toThrow()\n  })\n\n  it(\"should throw an error when file exists and overwrite is not specified\", async () => {\n    await saveResourceDescriptor(testResource, { path: testPath })\n\n    await expect(\n      saveResourceDescriptor(testResource, { path: testPath }),\n    ).rejects.toThrow()\n  })\n\n  it(\"should overwrite existing file when overwrite is true\", async () => {\n    const initialResource: Resource = {\n      name: \"initial\",\n      path: path.join(testDir, \"data1.csv\"),\n    }\n\n    const updatedResource: Resource = {\n      name: \"updated\",\n      path: path.join(testDir, \"data2.csv\"),\n      description: \"Updated resource\",\n    }\n\n    await saveResourceDescriptor(initialResource, { path: testPath })\n\n    const initialContent = await fs.readFile(testPath, \"utf-8\")\n    const initialParsed = JSON.parse(initialContent)\n    expect(initialParsed.name).toBe(\"initial\")\n\n    await saveResourceDescriptor(updatedResource, {\n      path: testPath,\n      overwrite: true,\n    })\n\n    const updatedContent = await fs.readFile(testPath, \"utf-8\")\n    const updatedParsed = JSON.parse(updatedContent)\n    expect(updatedParsed.name).toBe(\"updated\")\n    expect(updatedParsed.description).toBe(\"Updated resource\")\n  })\n\n  it(\"should save resource with all metadata fields\", async () => {\n    const fullResource: Resource = {\n      name: \"full-resource\",\n      path: path.join(testDir, \"data.csv\"),\n      title: \"Full Resource\",\n      description: \"A resource with all fields\",\n      format: \"csv\",\n      mediatype: \"text/csv\",\n      encoding: \"utf-8\",\n      bytes: 1024,\n      hash: \"abc123\",\n    }\n\n    await saveResourceDescriptor(fullResource, { path: testPath })\n\n    const content = await fs.readFile(testPath, \"utf-8\")\n    const parsedContent = JSON.parse(content)\n    expect(parsedContent.name).toBe(fullResource.name)\n    expect(parsedContent.title).toBe(fullResource.title)\n    expect(parsedContent.description).toBe(fullResource.description)\n    expect(parsedContent.format).toBe(fullResource.format)\n    expect(parsedContent.bytes).toBe(fullResource.bytes)\n  })\n})\n"]}

package/build/resource/validate.d.ts

@@ -0,0 +1,13 @@
+import type { Descriptor } from "../descriptor/index.ts";
+import type { MetadataError } from "../error/index.ts";
+import type { Resource } from "./Resource.ts";
+/**
+ * Validate a Resource descriptor (JSON Object) against its profile
+ */
+export declare function validateResourceMetadata(source: Resource | Descriptor | string, options?: {
+    basepath?: string;
+}): Promise<{
+    resource: Resource | undefined;
+    errors: MetadataError[];
+    valid: boolean;
+}>;

package/build/resource/validate.js

@@ -0,0 +1,57 @@
+import { loadDescriptor } from "../descriptor/index.js";
+import { validateDialect } from "../dialect/index.js";
+import { validateDescriptor } from "../profile/index.js";
+import { validateSchema } from "../schema/index.js";
+import { convertResourceFromDescriptor } from "./convert/fromDescriptor.js";
+const DEFAULT_PROFILE = "https://datapackage.org/profiles/1.0/dataresource.json";
+/**
+ * Validate a Resource descriptor (JSON Object) against its profile
+ */
+export async function validateResourceMetadata(source, options) {
+    const descriptor = typeof source === "string"
+        ? await loadDescriptor(source)
+        : source;
+    const profile = typeof descriptor.$schema === "string"
+        ? descriptor.$schema
+        : DEFAULT_PROFILE;
+    const report = await validateDescriptor(descriptor, {
+        profile,
+    });
+    let resource = undefined;
+    if (report.valid) {
+        // Validation + normalization = we can cast it
+        resource = convertResourceFromDescriptor(descriptor, {
+            basepath: options?.basepath,
+        });
+    }
+    if (resource) {
+        const dialectErorrs = await inspectDialectIfExternal(resource);
+        report.errors.push(...dialectErorrs);
+        const schemaErorrs = await inspectSchemaIfExternal(resource);
+        report.errors.push(...schemaErorrs);
+        // TODO: Support external JSON Schema validation as well
+        // https://github.com/frictionlessdata/datapackage/issues/937
+        if (report.errors.length) {
+            resource = undefined;
+            report.valid = false;
+        }
+    }
+    return { ...report, resource };
+}
+async function inspectDialectIfExternal(resource) {
+    const errors = [];
+    if (typeof resource.dialect === "string") {
+        const report = await validateDialect(resource.dialect);
+        errors.push(...report.errors);
+    }
+    return errors;
+}
+async function inspectSchemaIfExternal(resource) {
+    const errors = [];
+    if (typeof resource.schema === "string") {
+        const report = await validateSchema(resource.schema);
+        errors.push(...report.errors);
+    }
+    return errors;
+}
+//# 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,30 @@
+import { describe, expect, it } from "vitest";
+import { validateResourceMetadata } from "./validate.js";
+describe("validateResourceMetadata", () => {
+    it("returns valid report for valid resource", async () => {
+        const descriptor = {
+            name: "example-resource",
+            path: "data.csv",
+            format: "csv",
+            encoding: "utf-8",
+        };
+        const report = await validateResourceMetadata(descriptor);
+        expect(report.valid).toBe(true);
+        expect(report.errors).toEqual([]);
+    });
+    it("returns validation errors for invalid resource", async () => {
+        const invalidResource = {
+            name: 123, // Should be a string
+            path: true, // Should be a string or array of strings
+        };
+        const report = await validateResourceMetadata(invalidResource);
+        expect(report.valid).toBe(false);
+        expect(report.errors.length).toBeGreaterThan(0);
+        const error = report.errors[0];
+        expect(error).toBeDefined();
+        if (error) {
+            expect(error.pointer).toBe("/name");
+        }
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/schema/ForeignKey.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Foreign key definition for Table Schema
+ * Based on the specification at https://datapackage.org/standard/table-schema/#foreign-keys
+ */
+export interface ForeignKey {
+    /**
+     * Source field(s) in this schema
+     */
+    fields: string[];
+    /**
+     * Reference to fields in another resource
+     */
+    reference: {
+        /**
+         * Target resource name (optional)
+         */
+        resource?: string;
+        /**
+         * Target field(s) in the referenced resource
+         */
+        fields: string[];
+    };
+}

package/build/schema/ForeignKey.js

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

package/build/schema/Schema.d.ts

@@ -0,0 +1,56 @@
+import type { Field } from "../field/index.ts";
+import type { Metadata } from "../metadata/index.ts";
+import type { ForeignKey } from "./ForeignKey.ts";
+/**
+ * Table Schema definition
+ * Based on the specification at https://datapackage.org/standard/table-schema/
+ */
+export interface Schema extends Metadata {
+    /**
+     * URL of profile (optional)
+     */
+    $schema?: string;
+    /**
+     * Name of schema (optional)
+     */
+    name?: string;
+    /**
+     * Title of schema (optional)
+     */
+    title?: string;
+    /**
+     * Description of schema (optional)
+     */
+    description?: string;
+    /**
+     * Fields in this schema (required)
+     */
+    fields: Field[];
+    /**
+     * Field matching rule (optional)
+     * Default: "exact"
+     */
+    fieldsMatch?: "exact" | "equal" | "subset" | "superset" | "partial";
+    /**
+     * Values representing missing data (optional)
+     * Default: [""]
+     * Can be a simple array of strings or an array of {value, label} objects
+     * where label provides context for why the data is missing
+     */
+    missingValues?: (string | {
+        value: string;
+        label: string;
+    })[];
+    /**
+     * Fields uniquely identifying each row (optional)
+     */
+    primaryKey?: string[];
+    /**
+     * Field combinations that must be unique (optional)
+     */
+    uniqueKeys?: string[][];
+    /**
+     * Foreign key relationships (optional)
+     */
+    foreignKeys?: ForeignKey[];
+}

package/build/schema/Schema.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/build/schema/assert.d.ts

@@ -0,0 +1,6 @@
+import type { Descriptor } from "../descriptor/index.ts";
+import type { Schema } from "./Schema.ts";
+/**
+ * Assert a Schema descriptor (JSON Object) against its profile
+ */
+export declare function assertSchema(source: Descriptor | Schema): Promise<Schema>;

package/build/schema/assert.js

@@ -0,0 +1,12 @@
+import { validateSchema } from "./validate.js";
+/**
+ * Assert a Schema descriptor (JSON Object) against its profile
+ */
+export async function assertSchema(source) {
+    const report = await validateSchema(source);
+    if (!report.schema) {
+        throw new Error(`Schema "${JSON.stringify(source).slice(0, 100)}" is not valid`);
+    }
+    return report.schema;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXNzZXJ0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc2NoZW1hL2Fzc2VydC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFBO0FBRTlDOztHQUVHO0FBQ0gsTUFBTSxDQUFDLEtBQUssVUFBVSxZQUFZLENBQUMsTUFBMkI7SUFDNUQsTUFBTSxNQUFNLEdBQUcsTUFBTSxjQUFjLENBQUMsTUFBTSxDQUFDLENBQUE7SUFFM0MsSUFBSSxDQUFDLE1BQU0sQ0FBQyxNQUFNLEVBQUUsQ0FBQztRQUNuQixNQUFNLElBQUksS0FBSyxDQUNiLFdBQVcsSUFBSSxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFFLEdBQUcsQ0FBQyxnQkFBZ0IsQ0FDaEUsQ0FBQTtJQUNILENBQUM7SUFFRCxPQUFPLE1BQU0sQ0FBQyxNQUFNLENBQUE7QUFDdEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgRGVzY3JpcHRvciB9IGZyb20gXCIuLi9kZXNjcmlwdG9yL2luZGV4LnRzXCJcbmltcG9ydCB0eXBlIHsgU2NoZW1hIH0gZnJvbSBcIi4vU2NoZW1hLnRzXCJcbmltcG9ydCB7IHZhbGlkYXRlU2NoZW1hIH0gZnJvbSBcIi4vdmFsaWRhdGUudHNcIlxuXG4vKipcbiAqIEFzc2VydCBhIFNjaGVtYSBkZXNjcmlwdG9yIChKU09OIE9iamVjdCkgYWdhaW5zdCBpdHMgcHJvZmlsZVxuICovXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gYXNzZXJ0U2NoZW1hKHNvdXJjZTogRGVzY3JpcHRvciB8IFNjaGVtYSkge1xuICBjb25zdCByZXBvcnQgPSBhd2FpdCB2YWxpZGF0ZVNjaGVtYShzb3VyY2UpXG5cbiAgaWYgKCFyZXBvcnQuc2NoZW1hKSB7XG4gICAgdGhyb3cgbmV3IEVycm9yKFxuICAgICAgYFNjaGVtYSBcIiR7SlNPTi5zdHJpbmdpZnkoc291cmNlKS5zbGljZSgwLCAxMDApfVwiIGlzIG5vdCB2YWxpZGAsXG4gICAgKVxuICB9XG5cbiAgcmV0dXJuIHJlcG9ydC5zY2hlbWFcbn1cbiJdfQ==

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

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

package/build/schema/assert.spec.js

@@ -0,0 +1,34 @@
+import { describe, expect, expectTypeOf, it } from "vitest";
+import { assertSchema } from "./assert.js";
+describe("assertSchema", () => {
+    it("returns typed schema when valid", async () => {
+        const descriptor = {
+            fields: [
+                {
+                    name: "id",
+                    type: "integer",
+                },
+                {
+                    name: "name",
+                    type: "string",
+                },
+            ],
+            primaryKey: ["id"],
+        };
+        const schema = await assertSchema(descriptor);
+        expectTypeOf(schema).toEqualTypeOf();
+        expect(schema).toEqual(descriptor);
+    });
+    it("throws Error when schema is invalid", async () => {
+        const descriptor = {
+            fields: [
+                {
+                    name: "id",
+                    type: 123,
+                },
+            ],
+        };
+        await expect(assertSchema(descriptor)).rejects.toThrow(Error);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/schema/convert/fromDescriptor.d.ts

@@ -0,0 +1,2 @@
+import type { Descriptor } from "../../descriptor/index.ts";
+export declare function convertSchemaFromDescriptor(descriptor: Descriptor): Descriptor;

package/build/schema/convert/fromDescriptor.js

@@ -0,0 +1,70 @@
+import invariant from "tiny-invariant";
+import { convertFieldFromDescriptor } from "../../field/index.js";
+export function convertSchemaFromDescriptor(descriptor) {
+    descriptor = globalThis.structuredClone(descriptor);
+    convertProfile(descriptor);
+    convertFields(descriptor);
+    convertPrimaryKey(descriptor);
+    convertForeignKeys(descriptor);
+    convertUniqueKeys(descriptor);
+    return descriptor;
+}
+function convertProfile(descriptor) {
+    descriptor.$schema = descriptor.$schema ?? descriptor.profile;
+}
+function convertFields(descriptor) {
+    const fields = descriptor.fields;
+    if (!fields) {
+        return;
+    }
+    invariant(Array.isArray(fields), "Fields being an array is guaranteed by the validation");
+    for (const field of fields) {
+        convertFieldFromDescriptor(field);
+    }
+}
+function convertPrimaryKey(descriptor) {
+    const primaryKey = descriptor.primaryKey;
+    if (!primaryKey) {
+        return;
+    }
+    if (typeof primaryKey === "string") {
+        descriptor.primaryKey = [primaryKey];
+    }
+}
+function convertForeignKeys(descriptor) {
+    const foreignKeys = descriptor.foreignKeys;
+    if (!foreignKeys) {
+        return;
+    }
+    if (Array.isArray(foreignKeys)) {
+        for (const foreignKey of foreignKeys) {
+            const fields = foreignKey.fields;
+            if (typeof fields === "string") {
+                foreignKey.fields = [fields];
+            }
+            const referenceFields = foreignKey.reference?.fields;
+            if (typeof referenceFields === "string") {
+                foreignKey.reference.fields = [referenceFields];
+            }
+        }
+    }
+}
+function convertUniqueKeys(descriptor) {
+    const uniqueKeys = descriptor.uniqueKeys;
+    if (!uniqueKeys) {
+        return;
+    }
+    if (!Array.isArray(uniqueKeys)) {
+        descriptor.uniqueKeys = undefined;
+        console.warn(`Ignoring v2.0 incompatible uniqueKeys: ${uniqueKeys}`);
+        return;
+    }
+    for (const uniqueKey of uniqueKeys) {
+        if (!Array.isArray(uniqueKey)) {
+            descriptor.uniqueKeys = undefined;
+            console.warn(`Ignoring v2.0 incompatible uniqueKey: ${uniqueKey}`);
+            break;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/schema/convert/fromJsonSchema.d.ts

@@ -0,0 +1,3 @@
+import type { JSONSchema7 } from "json-schema";
+import type { Schema } from "../Schema.ts";
+export declare function convertSchemaFromJsonSchema(jsonSchema: JSONSchema7): Schema;