@fairspec/agent 0.9.0

package/LICENSE.md

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

package/README.md

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

package/build/actions/tableSchema/asHtml.d.ts

@@ -0,0 +1,4 @@
+import type { TableSchema } from "@fairspec/metadata";
+export declare function renderTableSchemaAsHtml(schema: TableSchema, options?: {
+    frontmatter?: boolean;
+}): string;

package/build/actions/tableSchema/asHtml.js

@@ -0,0 +1,82 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { getColumns } from "@fairspec/metadata";
+import { prettify } from "htmlfy";
+import { renderToStaticMarkup } from "react-dom/server";
+export function renderTableSchemaAsHtml(schema, options) {
+    let html = prettify(renderToStaticMarkup(_jsx(SchemaTable, { schema: schema })));
+    if (options?.frontmatter) {
+        if (schema.title) {
+            html = `---\ntitle: ${schema.title}\n---\n\n${html}`;
+        }
+    }
+    return html;
+}
+function SchemaTable(props) {
+    const { schema } = props;
+    return (_jsxs(_Fragment, { children: [schema.primaryKey && _jsx(PrimaryKey, { fields: schema.primaryKey }), schema.foreignKeys && schema.foreignKeys.length > 0 && (_jsx(ForeignKeys, { foreignKeys: schema.foreignKeys })), _jsx(FieldsTable, { schema: schema })] }));
+}
+function FieldsTable(props) {
+    const { schema } = props;
+    const columns = getColumns(schema);
+    const required = schema.required ?? [];
+    return (_jsxs(_Fragment, { children: [_jsx("h2", { children: "Columns" }), _jsxs("table", { children: [_jsxs("colgroup", { children: [_jsx("col", { width: "20%" }), _jsx("col", { width: "65%" }), _jsx("col", { width: "15%" })] }), _jsx("thead", { children: _jsxs("tr", { children: [_jsx("th", { children: "Name" }), _jsx("th", { children: "Definition" }), _jsx("th", { children: "Type" })] }) }), _jsx("tbody", { children: columns.map(column => (_jsx(FieldRow, { column: column, isRequired: required.includes(column.name) }, column.name))) })] })] }));
+}
+function FieldRow(props) {
+    const { column, isRequired } = props;
+    const { name, type, property } = column;
+    const columnDescription = property.description ?? "";
+    const constraints = extractConstraints(property);
+    return (_jsxs("tr", { children: [_jsx("td", { id: sanitizeId(name), children: _jsx("code", { children: _jsxs("strong", { children: [name, !isRequired && "?"] }) }) }), _jsxs("td", { children: [columnDescription && _jsx("p", { children: columnDescription }), constraints.length > 0 && (_jsx(ConstraintsList, { constraints: constraints })), "categories" in property && property.categories !== undefined && (_jsx(CategoriesList, { categories: property.categories }))] }), _jsx("td", { children: _jsx("code", { children: type }) })] }));
+}
+function ConstraintsList(props) {
+    const { constraints } = props;
+    return (_jsxs(_Fragment, { children: [_jsx("strong", { children: "Constraints" }), _jsx("ul", { children: constraints.map((constraint, index) => (_jsxs("li", { children: [constraint.name, ": ", _jsx("code", { children: constraint.value })] }, index))) })] }));
+}
+function CategoriesList(props) {
+    const { categories } = props;
+    return (_jsxs(_Fragment, { children: [_jsx("strong", { children: "Categories" }), _jsx("ul", { children: categories.map((category, index) => {
+                    const value = typeof category === "object" ? category.value : category;
+                    const label = typeof category === "object" ? category.label : undefined;
+                    return (_jsxs("li", { children: [_jsx("code", { children: String(value) }), label && ` - ${label}`] }, index));
+                }) })] }));
+}
+function extractConstraints(property) {
+    const constraints = [];
+    if ("minimum" in property && property.minimum !== undefined) {
+        constraints.push({ name: "minimum", value: String(property.minimum) });
+    }
+    if ("maximum" in property && property.maximum !== undefined) {
+        constraints.push({ name: "maximum", value: String(property.maximum) });
+    }
+    if ("minLength" in property && property.minLength !== undefined) {
+        constraints.push({ name: "minLength", value: String(property.minLength) });
+    }
+    if ("maxLength" in property && property.maxLength !== undefined) {
+        constraints.push({ name: "maxLength", value: String(property.maxLength) });
+    }
+    if ("pattern" in property && property.pattern) {
+        constraints.push({ name: "pattern", value: property.pattern });
+    }
+    if ("enum" in property && property.enum) {
+        const enumValues = property.enum.map(v => String(v)).join(", ");
+        constraints.push({ name: "enum", value: enumValues });
+    }
+    return constraints;
+}
+function PrimaryKey(props) {
+    const { fields } = props;
+    return (_jsxs(_Fragment, { children: [_jsx("h2", { children: "Primary Key" }), _jsx("p", { children: _jsx("code", { children: fields.join(", ") }) })] }));
+}
+function ForeignKeys(props) {
+    const { foreignKeys } = props;
+    if (!foreignKeys)
+        return null;
+    return (_jsxs(_Fragment, { children: [_jsx("h2", { children: "Foreign Keys" }), _jsxs("table", { children: [_jsxs("colgroup", { children: [_jsx("col", { width: "40%" }), _jsx("col", { width: "30%" }), _jsx("col", { width: "30%" })] }), _jsx("thead", { children: _jsxs("tr", { children: [_jsx("th", { children: "Columns" }), _jsx("th", { children: "Reference Resource" }), _jsx("th", { children: "Reference Columns" })] }) }), _jsx("tbody", { children: foreignKeys.map((fk, index) => (_jsxs("tr", { children: [_jsx("td", { children: _jsx("code", { children: fk.columns.join(", ") }) }), _jsx("td", { children: _jsx("code", { children: fk.reference.resource || "-" }) }), _jsx("td", { children: _jsx("code", { children: fk.reference.columns.join(", ") }) })] }, index))) })] })] }));
+}
+function sanitizeId(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-|-$/g, "");
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"asHtml.js","sourceRoot":"","sources":["../../../actions/tableSchema/asHtml.tsx"],"names":[],"mappings":"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","sourcesContent":["import type { Column, TableSchema } from \"@fairspec/metadata\"\nimport { getColumns } from \"@fairspec/metadata\"\nimport { prettify } from \"htmlfy\"\nimport { renderToStaticMarkup } from \"react-dom/server\"\n\nexport function renderTableSchemaAsHtml(\n  schema: TableSchema,\n  options?: { frontmatter?: boolean },\n): string {\n  let html = prettify(renderToStaticMarkup(<SchemaTable schema={schema} />))\n\n  if (options?.frontmatter) {\n    if (schema.title) {\n      html = `---\\ntitle: ${schema.title}\\n---\\n\\n${html}`\n    }\n  }\n\n  return html\n}\n\nfunction SchemaTable(props: { schema: TableSchema }) {\n  const { schema } = props\n\n  return (\n    <>\n      {schema.primaryKey && <PrimaryKey fields={schema.primaryKey} />}\n      {schema.foreignKeys && schema.foreignKeys.length > 0 && (\n        <ForeignKeys foreignKeys={schema.foreignKeys} />\n      )}\n      <FieldsTable schema={schema} />\n    </>\n  )\n}\n\nfunction FieldsTable(props: { schema: TableSchema }) {\n  const { schema } = props\n  const columns = getColumns(schema)\n  const required = schema.required ?? []\n\n  return (\n    <>\n      <h2>Columns</h2>\n      <table>\n        <colgroup>\n          <col width=\"20%\" />\n          <col width=\"65%\" />\n          <col width=\"15%\" />\n        </colgroup>\n        <thead>\n          <tr>\n            <th>Name</th>\n            <th>Definition</th>\n            <th>Type</th>\n          </tr>\n        </thead>\n        <tbody>\n          {columns.map(column => (\n            <FieldRow\n              key={column.name}\n              column={column}\n              isRequired={required.includes(column.name)}\n            />\n          ))}\n        </tbody>\n      </table>\n    </>\n  )\n}\n\nfunction FieldRow(props: { column: Column; isRequired: boolean }) {\n  const { column, isRequired } = props\n  const { name, type, property } = column\n  const columnDescription = property.description ?? \"\"\n\n  const constraints = extractConstraints(property)\n\n  return (\n    <tr>\n      <td id={sanitizeId(name)}>\n        <code>\n          <strong>\n            {name}\n            {!isRequired && \"?\"}\n          </strong>\n        </code>\n      </td>\n      <td>\n        {columnDescription && <p>{columnDescription}</p>}\n        {constraints.length > 0 && (\n          <ConstraintsList constraints={constraints} />\n        )}\n        {\"categories\" in property && property.categories !== undefined && (\n          <CategoriesList categories={property.categories} />\n        )}\n      </td>\n      <td>\n        <code>{type}</code>\n      </td>\n    </tr>\n  )\n}\n\nfunction ConstraintsList(props: { constraints: Constraint[] }) {\n  const { constraints } = props\n  return (\n    <>\n      <strong>Constraints</strong>\n      <ul>\n        {constraints.map((constraint, index) => (\n          <li key={index}>\n            {constraint.name}: <code>{constraint.value}</code>\n          </li>\n        ))}\n      </ul>\n    </>\n  )\n}\n\nfunction CategoriesList(props: { categories: any[] }) {\n  const { categories } = props\n  return (\n    <>\n      <strong>Categories</strong>\n      <ul>\n        {categories.map((category, index) => {\n          const value = typeof category === \"object\" ? category.value : category\n          const label =\n            typeof category === \"object\" ? category.label : undefined\n          return (\n            <li key={index}>\n              <code>{String(value)}</code>\n              {label && ` - ${label}`}\n            </li>\n          )\n        })}\n      </ul>\n    </>\n  )\n}\n\nfunction extractConstraints(property: Column[\"property\"]): Constraint[] {\n  const constraints: Constraint[] = []\n\n  if (\"minimum\" in property && property.minimum !== undefined) {\n    constraints.push({ name: \"minimum\", value: String(property.minimum) })\n  }\n  if (\"maximum\" in property && property.maximum !== undefined) {\n    constraints.push({ name: \"maximum\", value: String(property.maximum) })\n  }\n  if (\"minLength\" in property && property.minLength !== undefined) {\n    constraints.push({ name: \"minLength\", value: String(property.minLength) })\n  }\n  if (\"maxLength\" in property && property.maxLength !== undefined) {\n    constraints.push({ name: \"maxLength\", value: String(property.maxLength) })\n  }\n  if (\"pattern\" in property && property.pattern) {\n    constraints.push({ name: \"pattern\", value: property.pattern })\n  }\n  if (\"enum\" in property && property.enum) {\n    const enumValues = property.enum.map(v => String(v)).join(\", \")\n    constraints.push({ name: \"enum\", value: enumValues })\n  }\n\n  return constraints\n}\n\nfunction PrimaryKey(props: { fields: string[] }) {\n  const { fields } = props\n  return (\n    <>\n      <h2>Primary Key</h2>\n      <p>\n        <code>{fields.join(\", \")}</code>\n      </p>\n    </>\n  )\n}\n\nfunction ForeignKeys(props: { foreignKeys: TableSchema[\"foreignKeys\"] }) {\n  const { foreignKeys } = props\n  if (!foreignKeys) return null\n\n  return (\n    <>\n      <h2>Foreign Keys</h2>\n      <table>\n        <colgroup>\n          <col width=\"40%\" />\n          <col width=\"30%\" />\n          <col width=\"30%\" />\n        </colgroup>\n        <thead>\n          <tr>\n            <th>Columns</th>\n            <th>Reference Resource</th>\n            <th>Reference Columns</th>\n          </tr>\n        </thead>\n        <tbody>\n          {foreignKeys.map((fk, index) => (\n            <tr key={index}>\n              <td>\n                <code>{fk.columns.join(\", \")}</code>\n              </td>\n              <td>\n                <code>{fk.reference.resource || \"-\"}</code>\n              </td>\n              <td>\n                <code>{fk.reference.columns.join(\", \")}</code>\n              </td>\n            </tr>\n          ))}\n        </tbody>\n      </table>\n    </>\n  )\n}\n\nfunction sanitizeId(text: string): string {\n  return text\n    .toLowerCase()\n    .replace(/[^a-z0-9]+/g, \"-\")\n    .replace(/^-|-$/g, \"\")\n}\n\ninterface Constraint {\n  name: string\n  value: string\n}\n"]}

package/build/actions/tableSchema/asHtml.spec.d.ts

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

package/build/actions/tableSchema/asHtml.spec.js

@@ -0,0 +1,356 @@
+import { describe, expect, it } from "vitest";
+import { renderTableSchemaAsHtml } from "./asHtml.js";
+describe("renderTableSchemaAsHtml", () => {
+    it("converts a simple schema to html table", () => {
+        const schema = {
+            properties: {
+                id: {
+                    type: "integer",
+                    title: "Identifier",
+                    description: "Unique identifier",
+                },
+                name: {
+                    type: "string",
+                    title: "Name",
+                    description: "Person name",
+                },
+            },
+        };
+        const result = renderTableSchemaAsHtml(schema);
+        expect(result).toContain("<h2>Columns</h2>");
+        expect(result).toContain("<table>");
+        expect(result).toContain("<th>Name</th>");
+        expect(result).toContain("<th>Definition</th>");
+        expect(result).toContain("<th>Type</th>");
+        expect(result).toContain("<strong>id?</strong>");
+        expect(result).toContain("<strong>name?</strong>");
+        expect(result).toContain("<p>Unique identifier</p>");
+        expect(result).toContain("<p>Person name</p>");
+        expect(result).toContain("<code>integer</code>");
+        expect(result).toContain("<code>string</code>");
+    });
+    it("handles column constraints", () => {
+        const schema = {
+            properties: {
+                age: {
+                    type: "integer",
+                    minimum: 0,
+                    maximum: 120,
+                },
+                email: {
+                    type: "string",
+                    pattern: "^[a-z]+@[a-z]+\\.[a-z]+$",
+                },
+            },
+            required: ["age", "email"],
+        };
+        const result = renderTableSchemaAsHtml(schema);
+        expect(result).toContain("<strong>Constraints</strong>");
+        expect(result).toContain("minimum:");
+        expect(result).toContain("<code>0</code>");
+        expect(result).toContain("maximum:");
+        expect(result).toContain("<code>120</code>");
+        expect(result).toContain("pattern:");
+    });
+    it("handles required field indicator", () => {
+        const schema = {
+            properties: {
+                requiredField: {
+                    type: "string",
+                },
+                optionalField: {
+                    type: "string",
+                },
+            },
+            required: ["requiredField"],
+        };
+        const result = renderTableSchemaAsHtml(schema);
+        expect(result).toContain("<strong>requiredField</strong>");
+        expect(result).not.toContain("requiredField?");
+        expect(result).toContain("<strong>optionalField?</strong>");
+    });
+    it("handles empty properties object", () => {
+        const schema = {
+            properties: {},
+        };
+        const result = renderTableSchemaAsHtml(schema);
+        expect(result).toContain("<h2>Columns</h2>");
+        expect(result).toContain("<table>");
+        expect(result).toContain("</table>");
+    });
+    it("escapes HTML special characters", () => {
+        const schema = {
+            properties: {
+                field: {
+                    type: "string",
+                    description: "Description with <script>alert('xss')</script>",
+                },
+            },
+        };
+        const result = renderTableSchemaAsHtml(schema);
+        expect(result).toContain("Description with &lt;script&gt;alert(&#x27;xss&#x27;)&lt;/script&gt;");
+    });
+    it("handles columns with enum constraints", () => {
+        const schema = {
+            properties: {
+                status: {
+                    type: "string",
+                    enum: ["active", "inactive", "pending"],
+                },
+            },
+        };
+        const result = renderTableSchemaAsHtml(schema);
+        expect(result).toContain("enum:");
+        expect(result).toContain("<code>active, inactive, pending</code>");
+    });
+    it("handles multiple constraint types", () => {
+        const schema = {
+            properties: {
+                username: {
+                    type: "string",
+                    minLength: 3,
+                    maxLength: 20,
+                    pattern: "^[a-zA-Z0-9_]+$",
+                },
+            },
+            required: ["username"],
+        };
+        const result = renderTableSchemaAsHtml(schema);
+        expect(result).toContain("minLength:");
+        expect(result).toContain("<code>3</code>");
+        expect(result).toContain("maxLength:");
+        expect(result).toContain("<code>20</code>");
+        expect(result).toContain("pattern:");
+    });
+    it("handles different column types", () => {
+        const schema = {
+            properties: {
+                field1: { type: "string" },
+                field2: { type: "integer" },
+                field3: { type: "number" },
+                field4: { type: "boolean" },
+                field5: { type: "string", format: "date-time" },
+                field6: { type: "array" },
+            },
+        };
+        const result = renderTableSchemaAsHtml(schema);
+        expect(result).toContain("<code>string</code>");
+        expect(result).toContain("<code>integer</code>");
+        expect(result).toContain("<code>number</code>");
+        expect(result).toContain("<code>boolean</code>");
+        expect(result).toContain("<code>array</code>");
+    });
+    it("sanitizes IDs for anchors", () => {
+        const schema = {
+            properties: {
+                "field-with-dashes": {
+                    type: "string",
+                },
+                "Field With Spaces": {
+                    type: "string",
+                },
+            },
+        };
+        const result = renderTableSchemaAsHtml(schema);
+        expect(result).toContain('id="field-with-dashes"');
+        expect(result).toContain('id="field-with-spaces"');
+    });
+    it("does not include top-level html tags", () => {
+        const schema = {
+            properties: {
+                field1: { type: "string" },
+            },
+        };
+        const result = renderTableSchemaAsHtml(schema);
+        expect(result).not.toContain("<!DOCTYPE");
+        expect(result).not.toContain("<html>");
+        expect(result).not.toContain("<head>");
+        expect(result).not.toContain("<body>");
+        expect(result).not.toContain("<style>");
+    });
+    it("handles column without description", () => {
+        const schema = {
+            properties: {
+                field1: {
+                    type: "string",
+                },
+            },
+        };
+        const result = renderTableSchemaAsHtml(schema);
+        expect(result).toContain("<strong>field1?</strong>");
+        expect(result).toContain("<code>string</code>");
+    });
+    it("uses frontmatter when frontmatter option is true", () => {
+        const schema = {
+            title: "Table Schema",
+            properties: {
+                field1: {
+                    type: "string",
+                },
+            },
+        };
+        const result = renderTableSchemaAsHtml(schema, { frontmatter: true });
+        expect(result).toContain("---");
+        expect(result).toContain("title: Table Schema");
+    });
+    it("handles schema with primary key", () => {
+        const schema = {
+            properties: {
+                id: {
+                    type: "integer",
+                },
+                name: {
+                    type: "string",
+                },
+            },
+            primaryKey: ["id"],
+        };
+        const result = renderTableSchemaAsHtml(schema);
+        expect(result).toContain("<h2>Primary Key</h2>");
+        expect(result).toContain("<code>id</code>");
+    });
+    it("handles schema with composite primary key", () => {
+        const schema = {
+            properties: {
+                user_id: {
+                    type: "integer",
+                },
+                project_id: {
+                    type: "integer",
+                },
+            },
+            primaryKey: ["user_id", "project_id"],
+        };
+        const result = renderTableSchemaAsHtml(schema);
+        expect(result).toContain("<h2>Primary Key</h2>");
+        expect(result).toContain("<code>user_id, project_id</code>");
+    });
+    it("handles schema with foreign keys", () => {
+        const schema = {
+            properties: {
+                user_id: {
+                    type: "integer",
+                },
+            },
+            foreignKeys: [
+                {
+                    columns: ["user_id"],
+                    reference: {
+                        resource: "users",
+                        columns: ["id"],
+                    },
+                },
+            ],
+        };
+        const result = renderTableSchemaAsHtml(schema);
+        expect(result).toContain("<h2>Foreign Keys</h2>");
+        expect(result).toContain("<th>Columns</th>");
+        expect(result).toContain("<th>Reference Resource</th>");
+        expect(result).toContain("<th>Reference Columns</th>");
+        expect(result).toContain("<code>user_id</code>");
+        expect(result).toContain("<code>users</code>");
+        expect(result).toContain("<code>id</code>");
+    });
+    it("handles schema with multiple foreign keys", () => {
+        const schema = {
+            properties: {
+                user_id: {
+                    type: "integer",
+                },
+                project_id: {
+                    type: "integer",
+                },
+            },
+            foreignKeys: [
+                {
+                    columns: ["user_id"],
+                    reference: {
+                        resource: "users",
+                        columns: ["id"],
+                    },
+                },
+                {
+                    columns: ["project_id"],
+                    reference: {
+                        resource: "projects",
+                        columns: ["id"],
+                    },
+                },
+            ],
+        };
+        const result = renderTableSchemaAsHtml(schema);
+        expect(result).toContain("<h2>Foreign Keys</h2>");
+        expect(result).toContain("<code>user_id</code>");
+        expect(result).toContain("<code>users</code>");
+        expect(result).toContain("<code>project_id</code>");
+        expect(result).toContain("<code>projects</code>");
+    });
+    it("handles foreign key without resource specified", () => {
+        const schema = {
+            properties: {
+                parent_id: {
+                    type: "integer",
+                },
+            },
+            foreignKeys: [
+                {
+                    columns: ["parent_id"],
+                    reference: {
+                        columns: ["id"],
+                    },
+                },
+            ],
+        };
+        const result = renderTableSchemaAsHtml(schema);
+        expect(result).toContain("<h2>Foreign Keys</h2>");
+        expect(result).toContain("<code>parent_id</code>");
+        expect(result).toContain("<code>-</code>");
+        expect(result).toContain("<code>id</code>");
+    });
+    it("does not render primary key or foreign keys sections when not present", () => {
+        const schema = {
+            properties: {
+                field1: {
+                    type: "string",
+                },
+            },
+        };
+        const result = renderTableSchemaAsHtml(schema);
+        expect(result).not.toContain("<h2>Primary Key</h2>");
+        expect(result).not.toContain("<h2>Foreign Keys</h2>");
+    });
+    it("handles string categories", () => {
+        const schema = {
+            properties: {
+                status: {
+                    type: "string",
+                    categories: ["active", "inactive"],
+                },
+            },
+        };
+        const result = renderTableSchemaAsHtml(schema);
+        expect(result).toContain("<strong>Categories</strong>");
+        expect(result).toContain("<code>active</code>");
+        expect(result).toContain("<code>inactive</code>");
+    });
+    it("handles integer categories with labels", () => {
+        const schema = {
+            properties: {
+                level: {
+                    type: "integer",
+                    categories: [
+                        { value: 1, label: "Beginner" },
+                        { value: 2, label: "Advanced" },
+                    ],
+                },
+            },
+        };
+        const result = renderTableSchemaAsHtml(schema);
+        expect(result).toContain("<strong>Categories</strong>");
+        expect(result).toContain("<code>1</code>");
+        expect(result).toContain(" - Beginner");
+        expect(result).toContain("<code>2</code>");
+        expect(result).toContain(" - Advanced");
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"asHtml.spec.js","sourceRoot":"","sources":["../../../actions/tableSchema/asHtml.spec.tsx"],"names":[],"mappings":"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","sourcesContent":["import type { TableSchema } from \"@fairspec/metadata\"\nimport { describe, expect, it } from \"vitest\"\nimport { renderTableSchemaAsHtml } from \"./asHtml.tsx\"\n\ndescribe(\"renderTableSchemaAsHtml\", () => {\n  it(\"converts a simple schema to html table\", () => {\n    const schema: TableSchema = {\n      properties: {\n        id: {\n          type: \"integer\",\n          title: \"Identifier\",\n          description: \"Unique identifier\",\n        },\n        name: {\n          type: \"string\",\n          title: \"Name\",\n          description: \"Person name\",\n        },\n      },\n    }\n\n    const result = renderTableSchemaAsHtml(schema)\n\n    expect(result).toContain(\"<h2>Columns</h2>\")\n    expect(result).toContain(\"<table>\")\n    expect(result).toContain(\"<th>Name</th>\")\n    expect(result).toContain(\"<th>Definition</th>\")\n    expect(result).toContain(\"<th>Type</th>\")\n    expect(result).toContain(\"<strong>id?</strong>\")\n    expect(result).toContain(\"<strong>name?</strong>\")\n    expect(result).toContain(\"<p>Unique identifier</p>\")\n    expect(result).toContain(\"<p>Person name</p>\")\n    expect(result).toContain(\"<code>integer</code>\")\n    expect(result).toContain(\"<code>string</code>\")\n  })\n\n  it(\"handles column constraints\", () => {\n    const schema: TableSchema = {\n      properties: {\n        age: {\n          type: \"integer\",\n\n          minimum: 0,\n          maximum: 120,\n        },\n        email: {\n          type: \"string\",\n          pattern: \"^[a-z]+@[a-z]+\\\\.[a-z]+$\",\n        },\n      },\n      required: [\"age\", \"email\"],\n    }\n\n    const result = renderTableSchemaAsHtml(schema)\n\n    expect(result).toContain(\"<strong>Constraints</strong>\")\n    expect(result).toContain(\"minimum:\")\n    expect(result).toContain(\"<code>0</code>\")\n    expect(result).toContain(\"maximum:\")\n    expect(result).toContain(\"<code>120</code>\")\n    expect(result).toContain(\"pattern:\")\n  })\n\n  it(\"handles required field indicator\", () => {\n    const schema: TableSchema = {\n      properties: {\n        requiredField: {\n          type: \"string\",\n        },\n        optionalField: {\n          type: \"string\",\n        },\n      },\n      required: [\"requiredField\"],\n    }\n\n    const result = renderTableSchemaAsHtml(schema)\n\n    expect(result).toContain(\"<strong>requiredField</strong>\")\n    expect(result).not.toContain(\"requiredField?\")\n    expect(result).toContain(\"<strong>optionalField?</strong>\")\n  })\n\n  it(\"handles empty properties object\", () => {\n    const schema: TableSchema = {\n      properties: {},\n    }\n\n    const result = renderTableSchemaAsHtml(schema)\n\n    expect(result).toContain(\"<h2>Columns</h2>\")\n    expect(result).toContain(\"<table>\")\n    expect(result).toContain(\"</table>\")\n  })\n\n  it(\"escapes HTML special characters\", () => {\n    const schema: TableSchema = {\n      properties: {\n        field: {\n          type: \"string\",\n          description: \"Description with <script>alert('xss')</script>\",\n        },\n      },\n    }\n\n    const result = renderTableSchemaAsHtml(schema)\n\n    expect(result).toContain(\n      \"Description with &lt;script&gt;alert(&#x27;xss&#x27;)&lt;/script&gt;\",\n    )\n  })\n\n  it(\"handles columns with enum constraints\", () => {\n    const schema: TableSchema = {\n      properties: {\n        status: {\n          type: \"string\",\n          enum: [\"active\", \"inactive\", \"pending\"],\n        },\n      },\n    }\n\n    const result = renderTableSchemaAsHtml(schema)\n\n    expect(result).toContain(\"enum:\")\n    expect(result).toContain(\"<code>active, inactive, pending</code>\")\n  })\n\n  it(\"handles multiple constraint types\", () => {\n    const schema: TableSchema = {\n      properties: {\n        username: {\n          type: \"string\",\n          minLength: 3,\n          maxLength: 20,\n          pattern: \"^[a-zA-Z0-9_]+$\",\n        },\n      },\n      required: [\"username\"],\n    }\n\n    const result = renderTableSchemaAsHtml(schema)\n\n    expect(result).toContain(\"minLength:\")\n    expect(result).toContain(\"<code>3</code>\")\n    expect(result).toContain(\"maxLength:\")\n    expect(result).toContain(\"<code>20</code>\")\n    expect(result).toContain(\"pattern:\")\n  })\n\n  it(\"handles different column types\", () => {\n    const schema: TableSchema = {\n      properties: {\n        field1: { type: \"string\" },\n        field2: { type: \"integer\" },\n        field3: { type: \"number\" },\n        field4: { type: \"boolean\" },\n        field5: { type: \"string\", format: \"date-time\" },\n        field6: { type: \"array\" },\n      },\n    }\n\n    const result = renderTableSchemaAsHtml(schema)\n\n    expect(result).toContain(\"<code>string</code>\")\n    expect(result).toContain(\"<code>integer</code>\")\n    expect(result).toContain(\"<code>number</code>\")\n    expect(result).toContain(\"<code>boolean</code>\")\n    expect(result).toContain(\"<code>array</code>\")\n  })\n\n  it(\"sanitizes IDs for anchors\", () => {\n    const schema: TableSchema = {\n      properties: {\n        \"field-with-dashes\": {\n          type: \"string\",\n        },\n        \"Field With Spaces\": {\n          type: \"string\",\n        },\n      },\n    }\n\n    const result = renderTableSchemaAsHtml(schema)\n\n    expect(result).toContain('id=\"field-with-dashes\"')\n    expect(result).toContain('id=\"field-with-spaces\"')\n  })\n\n  it(\"does not include top-level html tags\", () => {\n    const schema: TableSchema = {\n      properties: {\n        field1: { type: \"string\" },\n      },\n    }\n\n    const result = renderTableSchemaAsHtml(schema)\n\n    expect(result).not.toContain(\"<!DOCTYPE\")\n    expect(result).not.toContain(\"<html>\")\n    expect(result).not.toContain(\"<head>\")\n    expect(result).not.toContain(\"<body>\")\n    expect(result).not.toContain(\"<style>\")\n  })\n\n  it(\"handles column without description\", () => {\n    const schema: TableSchema = {\n      properties: {\n        field1: {\n          type: \"string\",\n        },\n      },\n    }\n\n    const result = renderTableSchemaAsHtml(schema)\n\n    expect(result).toContain(\"<strong>field1?</strong>\")\n    expect(result).toContain(\"<code>string</code>\")\n  })\n\n  it(\"uses frontmatter when frontmatter option is true\", () => {\n    const schema: TableSchema = {\n      title: \"Table Schema\",\n      properties: {\n        field1: {\n          type: \"string\",\n        },\n      },\n    }\n\n    const result = renderTableSchemaAsHtml(schema, { frontmatter: true })\n\n    expect(result).toContain(\"---\")\n    expect(result).toContain(\"title: Table Schema\")\n  })\n\n  it(\"handles schema with primary key\", () => {\n    const schema: TableSchema = {\n      properties: {\n        id: {\n          type: \"integer\",\n        },\n        name: {\n          type: \"string\",\n        },\n      },\n      primaryKey: [\"id\"],\n    }\n\n    const result = renderTableSchemaAsHtml(schema)\n\n    expect(result).toContain(\"<h2>Primary Key</h2>\")\n    expect(result).toContain(\"<code>id</code>\")\n  })\n\n  it(\"handles schema with composite primary key\", () => {\n    const schema: TableSchema = {\n      properties: {\n        user_id: {\n          type: \"integer\",\n        },\n        project_id: {\n          type: \"integer\",\n        },\n      },\n      primaryKey: [\"user_id\", \"project_id\"],\n    }\n\n    const result = renderTableSchemaAsHtml(schema)\n\n    expect(result).toContain(\"<h2>Primary Key</h2>\")\n    expect(result).toContain(\"<code>user_id, project_id</code>\")\n  })\n\n  it(\"handles schema with foreign keys\", () => {\n    const schema: TableSchema = {\n      properties: {\n        user_id: {\n          type: \"integer\",\n        },\n      },\n      foreignKeys: [\n        {\n          columns: [\"user_id\"],\n          reference: {\n            resource: \"users\",\n            columns: [\"id\"],\n          },\n        },\n      ],\n    }\n\n    const result = renderTableSchemaAsHtml(schema)\n\n    expect(result).toContain(\"<h2>Foreign Keys</h2>\")\n    expect(result).toContain(\"<th>Columns</th>\")\n    expect(result).toContain(\"<th>Reference Resource</th>\")\n    expect(result).toContain(\"<th>Reference Columns</th>\")\n    expect(result).toContain(\"<code>user_id</code>\")\n    expect(result).toContain(\"<code>users</code>\")\n    expect(result).toContain(\"<code>id</code>\")\n  })\n\n  it(\"handles schema with multiple foreign keys\", () => {\n    const schema: TableSchema = {\n      properties: {\n        user_id: {\n          type: \"integer\",\n        },\n        project_id: {\n          type: \"integer\",\n        },\n      },\n      foreignKeys: [\n        {\n          columns: [\"user_id\"],\n          reference: {\n            resource: \"users\",\n            columns: [\"id\"],\n          },\n        },\n        {\n          columns: [\"project_id\"],\n          reference: {\n            resource: \"projects\",\n            columns: [\"id\"],\n          },\n        },\n      ],\n    }\n\n    const result = renderTableSchemaAsHtml(schema)\n\n    expect(result).toContain(\"<h2>Foreign Keys</h2>\")\n    expect(result).toContain(\"<code>user_id</code>\")\n    expect(result).toContain(\"<code>users</code>\")\n    expect(result).toContain(\"<code>project_id</code>\")\n    expect(result).toContain(\"<code>projects</code>\")\n  })\n\n  it(\"handles foreign key without resource specified\", () => {\n    const schema: TableSchema = {\n      properties: {\n        parent_id: {\n          type: \"integer\",\n        },\n      },\n      foreignKeys: [\n        {\n          columns: [\"parent_id\"],\n          reference: {\n            columns: [\"id\"],\n          },\n        },\n      ],\n    }\n\n    const result = renderTableSchemaAsHtml(schema)\n\n    expect(result).toContain(\"<h2>Foreign Keys</h2>\")\n    expect(result).toContain(\"<code>parent_id</code>\")\n    expect(result).toContain(\"<code>-</code>\")\n    expect(result).toContain(\"<code>id</code>\")\n  })\n\n  it(\"does not render primary key or foreign keys sections when not present\", () => {\n    const schema: TableSchema = {\n      properties: {\n        field1: {\n          type: \"string\",\n        },\n      },\n    }\n\n    const result = renderTableSchemaAsHtml(schema)\n\n    expect(result).not.toContain(\"<h2>Primary Key</h2>\")\n    expect(result).not.toContain(\"<h2>Foreign Keys</h2>\")\n  })\n\n  it(\"handles string categories\", () => {\n    const schema: TableSchema = {\n      properties: {\n        status: {\n          type: \"string\",\n          categories: [\"active\", \"inactive\"],\n        },\n      },\n    }\n\n    const result = renderTableSchemaAsHtml(schema)\n\n    expect(result).toContain(\"<strong>Categories</strong>\")\n    expect(result).toContain(\"<code>active</code>\")\n    expect(result).toContain(\"<code>inactive</code>\")\n  })\n\n  it(\"handles integer categories with labels\", () => {\n    const schema: TableSchema = {\n      properties: {\n        level: {\n          type: \"integer\",\n\n          categories: [\n            { value: 1, label: \"Beginner\" },\n            { value: 2, label: \"Advanced\" },\n          ],\n        },\n      },\n    }\n\n    const result = renderTableSchemaAsHtml(schema)\n\n    expect(result).toContain(\"<strong>Categories</strong>\")\n    expect(result).toContain(\"<code>1</code>\")\n    expect(result).toContain(\" - Beginner\")\n    expect(result).toContain(\"<code>2</code>\")\n    expect(result).toContain(\" - Advanced\")\n  })\n})\n"]}

package/build/actions/tableSchema/asMarkdown.d.ts

@@ -0,0 +1,4 @@
+import type { TableSchema } from "@fairspec/metadata";
+export declare function renderTableSchemaAsMarkdown(schema: TableSchema, options?: {
+    frontmatter?: boolean;
+}): string;

package/build/actions/tableSchema/asMarkdown.js

@@ -0,0 +1,65 @@
+import { getColumns } from "@fairspec/metadata";
+export function renderTableSchemaAsMarkdown(schema, options) {
+    const rows = [];
+    rows.push("");
+    rows.push("## Columns");
+    rows.push("");
+    rows.push("| Name | Type | Title | Description | Constraints |");
+    rows.push("|------|------|-------|-------------|-------------|");
+    const columns = getColumns(schema);
+    const required = schema.required ?? [];
+    for (const column of columns) {
+        const { name, type, property } = column;
+        const title = property.title ?? "";
+        const description = property.description ?? "";
+        const constraints = [];
+        if (required.includes(name)) {
+            constraints.push("required");
+        }
+        constraints.push(...extractConstraints(property));
+        const constraintsStr = constraints.join(", ");
+        const escapedName = escapeMarkdown(name);
+        const escapedTitle = escapeMarkdown(title);
+        const escapedDescription = escapeMarkdown(description);
+        const escapedConstraints = escapeMarkdown(constraintsStr);
+        rows.push(`| ${escapedName} | ${type} | ${escapedTitle} | ${escapedDescription} | ${escapedConstraints} |`);
+    }
+    let markdown = `${rows.join("\n")}\n`;
+    if (options?.frontmatter) {
+        const header = [];
+        header.push("---");
+        if (schema.title) {
+            header.push(`title: ${schema.title}`);
+        }
+        header.push("---");
+        header.push("");
+        markdown = header.join("\n") + markdown;
+    }
+    return markdown;
+}
+function escapeMarkdown(text) {
+    return text.replace(/\n/g, " ");
+}
+function extractConstraints(property) {
+    const constraints = [];
+    if ("minimum" in property && property.minimum !== undefined) {
+        constraints.push(`min: ${property.minimum}`);
+    }
+    if ("maximum" in property && property.maximum !== undefined) {
+        constraints.push(`max: ${property.maximum}`);
+    }
+    if ("minLength" in property && property.minLength !== undefined) {
+        constraints.push(`minLength: ${property.minLength}`);
+    }
+    if ("maxLength" in property && property.maxLength !== undefined) {
+        constraints.push(`maxLength: ${property.maxLength}`);
+    }
+    if ("pattern" in property && property.pattern) {
+        constraints.push(`pattern: ${property.pattern}`);
+    }
+    if ("enum" in property && property.enum) {
+        constraints.push(`enum: ${property.enum.join(", ")}`);
+    }
+    return constraints;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/actions/tableSchema/asMarkdown.spec.d.ts

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