@fairspec/agent 0.9.0

package/build/tools/data/validate.js

@@ -0,0 +1,15 @@
+import { Report, Resource, validateData } from "@fairspec/library";
+import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+export const validateDataTool = createTool({
+    id: "validate-data",
+    description: "Validate data against a data schema (JSON Schema). Returns a validation report with errors if any.",
+    inputSchema: z.object({
+        resource: Resource.describe("The data resource to validate"),
+    }),
+    outputSchema: Report,
+    execute: async (input) => {
+        return await validateData(input.resource);
+    },
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90b29scy9kYXRhL3ZhbGlkYXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxNQUFNLEVBQUUsUUFBUSxFQUFFLFlBQVksRUFBRSxNQUFNLG1CQUFtQixDQUFBO0FBQ2xFLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQTtBQUMvQyxPQUFPLEVBQUUsQ0FBQyxFQUFFLE1BQU0sS0FBSyxDQUFBO0FBRXZCLE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHLFVBQVUsQ0FBQztJQUN6QyxFQUFFLEVBQUUsZUFBZTtJQUNuQixXQUFXLEVBQ1Qsb0dBQW9HO0lBQ3RHLFdBQVcsRUFBRSxDQUFDLENBQUMsTUFBTSxDQUFDO1FBQ3BCLFFBQVEsRUFBRSxRQUFRLENBQUMsUUFBUSxDQUFDLCtCQUErQixDQUFDO0tBQzdELENBQUM7SUFDRixZQUFZLEVBQUUsTUFBTTtJQUNwQixPQUFPLEVBQUUsS0FBSyxFQUFDLEtBQUssRUFBQyxFQUFFO1FBQ3JCLE9BQU8sTUFBTSxZQUFZLENBQUMsS0FBSyxDQUFDLFFBQVEsQ0FBQyxDQUFBO0lBQzNDLENBQUM7Q0FDRixDQUFDLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBSZXBvcnQsIFJlc291cmNlLCB2YWxpZGF0ZURhdGEgfSBmcm9tIFwiQGZhaXJzcGVjL2xpYnJhcnlcIlxuaW1wb3J0IHsgY3JlYXRlVG9vbCB9IGZyb20gXCJAbWFzdHJhL2NvcmUvdG9vbHNcIlxuaW1wb3J0IHsgeiB9IGZyb20gXCJ6b2RcIlxuXG5leHBvcnQgY29uc3QgdmFsaWRhdGVEYXRhVG9vbCA9IGNyZWF0ZVRvb2woe1xuICBpZDogXCJ2YWxpZGF0ZS1kYXRhXCIsXG4gIGRlc2NyaXB0aW9uOlxuICAgIFwiVmFsaWRhdGUgZGF0YSBhZ2FpbnN0IGEgZGF0YSBzY2hlbWEgKEpTT04gU2NoZW1hKS4gUmV0dXJucyBhIHZhbGlkYXRpb24gcmVwb3J0IHdpdGggZXJyb3JzIGlmIGFueS5cIixcbiAgaW5wdXRTY2hlbWE6IHoub2JqZWN0KHtcbiAgICByZXNvdXJjZTogUmVzb3VyY2UuZGVzY3JpYmUoXCJUaGUgZGF0YSByZXNvdXJjZSB0byB2YWxpZGF0ZVwiKSxcbiAgfSksXG4gIG91dHB1dFNjaGVtYTogUmVwb3J0LFxuICBleGVjdXRlOiBhc3luYyBpbnB1dCA9PiB7XG4gICAgcmV0dXJuIGF3YWl0IHZhbGlkYXRlRGF0YShpbnB1dC5yZXNvdXJjZSlcbiAgfSxcbn0pXG4iXX0=

package/build/tools/data/validate.spec.d.ts

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

package/build/tools/data/validate.spec.js

@@ -0,0 +1,228 @@
+import { writeTempFile } from "@fairspec/library";
+import { describe, expect, it } from "vitest";
+import { validateDataTool } from "./validate.js";
+describe("validateDataTool", () => {
+    it("validates tool structure", () => {
+        expect(validateDataTool.id).toBe("validate-data");
+        expect(validateDataTool.description).toBeTruthy();
+        expect(validateDataTool.inputSchema).toBeTruthy();
+        expect(validateDataTool.outputSchema).toBeTruthy();
+        expect(validateDataTool.execute).toBeTypeOf("function");
+    });
+    it("validates data against schema", async () => {
+        const resource = {
+            data: { name: "test", count: 5 },
+            dataSchema: {
+                type: "object",
+                properties: {
+                    name: { type: "string" },
+                    count: { type: "integer" },
+                },
+            },
+        };
+        const result = await validateDataTool.execute?.({
+            resource,
+        }, {});
+        expect.assert(result);
+        expect.assert(!("error" in result));
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+    });
+    it("detects invalid data", async () => {
+        const resource = {
+            data: { name: 123, count: "invalid" },
+            dataSchema: {
+                type: "object",
+                properties: {
+                    name: { type: "string" },
+                    count: { type: "integer" },
+                },
+            },
+        };
+        const result = await validateDataTool.execute?.({
+            resource,
+        }, {});
+        expect.assert(result);
+        expect.assert(!("error" in result));
+        expect(result.valid).toBe(false);
+        expect(result.errors.length).toBeGreaterThan(0);
+        expect(result.errors).toContainEqual({
+            type: "data",
+            jsonPointer: "/name",
+            message: "must be string",
+        });
+        expect(result.errors).toContainEqual({
+            type: "data",
+            jsonPointer: "/count",
+            message: "must be integer",
+        });
+    });
+    it("validates data from file path", async () => {
+        const jsonData = { name: "alice", age: 25, active: true };
+        const dataPath = await writeTempFile(JSON.stringify(jsonData), {
+            format: "json",
+        });
+        const resource = {
+            data: dataPath,
+            dataSchema: {
+                type: "object",
+                properties: {
+                    name: { type: "string" },
+                    age: { type: "number" },
+                    active: { type: "boolean" },
+                },
+                required: ["name", "age"],
+            },
+        };
+        const result = await validateDataTool.execute?.({
+            resource,
+        }, {});
+        expect.assert(result);
+        expect.assert(!("error" in result));
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+    });
+    it("detects invalid data from file path", async () => {
+        const jsonData = { name: "alice", age: "not a number" };
+        const dataPath = await writeTempFile(JSON.stringify(jsonData), {
+            format: "json",
+        });
+        const resource = {
+            data: dataPath,
+            dataSchema: {
+                type: "object",
+                properties: {
+                    name: { type: "string" },
+                    age: { type: "number" },
+                },
+                required: ["name", "age"],
+            },
+        };
+        const result = await validateDataTool.execute?.({
+            resource,
+        }, {});
+        expect.assert(result);
+        expect.assert(!("error" in result));
+        expect(result.valid).toBe(false);
+        expect(result.errors.length).toBeGreaterThan(0);
+    });
+    it("validates data with nested objects", async () => {
+        const resource = {
+            data: {
+                name: "alice",
+                address: { city: "New York", zip: "10001" },
+            },
+            dataSchema: {
+                type: "object",
+                properties: {
+                    name: { type: "string" },
+                    address: {
+                        type: "object",
+                        properties: {
+                            city: { type: "string" },
+                            zip: { type: "string" },
+                        },
+                    },
+                },
+            },
+        };
+        const result = await validateDataTool.execute?.({
+            resource,
+        }, {});
+        expect.assert(result);
+        expect.assert(!("error" in result));
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+    });
+    it("validates data with array types", async () => {
+        const resource = {
+            data: {
+                tags: ["admin", "user"],
+                scores: [95, 87, 92],
+            },
+            dataSchema: {
+                type: "object",
+                properties: {
+                    tags: {
+                        type: "array",
+                        items: { type: "string" },
+                    },
+                    scores: {
+                        type: "array",
+                        items: { type: "number" },
+                    },
+                },
+            },
+        };
+        const result = await validateDataTool.execute?.({
+            resource,
+        }, {});
+        expect.assert(result);
+        expect.assert(!("error" in result));
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+    });
+    it("returns error when no data but schema expected", async () => {
+        const resource = {
+            name: "empty",
+            dataSchema: { type: "object" },
+        };
+        const result = await validateDataTool.execute?.({
+            resource,
+        }, {});
+        expect.assert(result);
+        expect.assert(!("error" in result));
+        expect(result.valid).toBe(false);
+        expect(result.errors).toHaveLength(1);
+        expect(result.errors).toContainEqual({
+            type: "resource/type",
+            expectedResourceType: "data",
+        });
+    });
+    it("validates data with required fields", async () => {
+        const resource = {
+            data: { name: "alice" },
+            dataSchema: {
+                type: "object",
+                properties: {
+                    name: { type: "string" },
+                    age: { type: "number" },
+                },
+                required: ["name", "age"],
+            },
+        };
+        const result = await validateDataTool.execute?.({
+            resource,
+        }, {});
+        expect.assert(result);
+        expect.assert(!("error" in result));
+        expect(result.valid).toBe(false);
+        expect(result.errors.length).toBeGreaterThan(0);
+    });
+    it("validates array data against schema", async () => {
+        const resource = {
+            data: [
+                { id: 1, name: "alice" },
+                { id: 2, name: "bob" },
+            ],
+            dataSchema: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        id: { type: "integer" },
+                        name: { type: "string" },
+                    },
+                },
+            },
+        };
+        const result = await validateDataTool.execute?.({
+            resource,
+        }, {});
+        expect.assert(result);
+        expect.assert(!("error" in result));
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validate.spec.js","sourceRoot":"","sources":["../../../tools/data/validate.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Resource } from \"@fairspec/library\"\nimport { writeTempFile } from \"@fairspec/library\"\nimport { describe, expect, it } from \"vitest\"\nimport { validateDataTool } from \"./validate.ts\"\n\ndescribe(\"validateDataTool\", () => {\n  it(\"validates tool structure\", () => {\n    expect(validateDataTool.id).toBe(\"validate-data\")\n    expect(validateDataTool.description).toBeTruthy()\n    expect(validateDataTool.inputSchema).toBeTruthy()\n    expect(validateDataTool.outputSchema).toBeTruthy()\n    expect(validateDataTool.execute).toBeTypeOf(\"function\")\n  })\n\n  it(\"validates data against schema\", async () => {\n    const resource: Resource = {\n      data: { name: \"test\", count: 5 },\n      dataSchema: {\n        type: \"object\",\n        properties: {\n          name: { type: \"string\" },\n          count: { type: \"integer\" },\n        },\n      },\n    }\n\n    const result = await validateDataTool.execute?.(\n      {\n        resource,\n      },\n      {},\n    )\n\n    expect.assert(result)\n    expect.assert(!(\"error\" in result))\n\n    expect(result.valid).toBe(true)\n    expect(result.errors).toHaveLength(0)\n  })\n\n  it(\"detects invalid data\", async () => {\n    const resource: Resource = {\n      data: { name: 123, count: \"invalid\" },\n      dataSchema: {\n        type: \"object\",\n        properties: {\n          name: { type: \"string\" },\n          count: { type: \"integer\" },\n        },\n      },\n    }\n\n    const result = await validateDataTool.execute?.(\n      {\n        resource,\n      },\n      {},\n    )\n\n    expect.assert(result)\n    expect.assert(!(\"error\" in result))\n\n    expect(result.valid).toBe(false)\n    expect(result.errors.length).toBeGreaterThan(0)\n    expect(result.errors).toContainEqual({\n      type: \"data\",\n      jsonPointer: \"/name\",\n      message: \"must be string\",\n    })\n    expect(result.errors).toContainEqual({\n      type: \"data\",\n      jsonPointer: \"/count\",\n      message: \"must be integer\",\n    })\n  })\n\n  it(\"validates data from file path\", async () => {\n    const jsonData = { name: \"alice\", age: 25, active: true }\n    const dataPath = await writeTempFile(JSON.stringify(jsonData), {\n      format: \"json\",\n    })\n\n    const resource: Resource = {\n      data: dataPath,\n      dataSchema: {\n        type: \"object\",\n        properties: {\n          name: { type: \"string\" },\n          age: { type: \"number\" },\n          active: { type: \"boolean\" },\n        },\n        required: [\"name\", \"age\"],\n      },\n    }\n\n    const result = await validateDataTool.execute?.(\n      {\n        resource,\n      },\n      {},\n    )\n\n    expect.assert(result)\n    expect.assert(!(\"error\" in result))\n\n    expect(result.valid).toBe(true)\n    expect(result.errors).toHaveLength(0)\n  })\n\n  it(\"detects invalid data from file path\", async () => {\n    const jsonData = { name: \"alice\", age: \"not a number\" }\n    const dataPath = await writeTempFile(JSON.stringify(jsonData), {\n      format: \"json\",\n    })\n\n    const resource: Resource = {\n      data: dataPath,\n      dataSchema: {\n        type: \"object\",\n        properties: {\n          name: { type: \"string\" },\n          age: { type: \"number\" },\n        },\n        required: [\"name\", \"age\"],\n      },\n    }\n\n    const result = await validateDataTool.execute?.(\n      {\n        resource,\n      },\n      {},\n    )\n\n    expect.assert(result)\n    expect.assert(!(\"error\" in result))\n\n    expect(result.valid).toBe(false)\n    expect(result.errors.length).toBeGreaterThan(0)\n  })\n\n  it(\"validates data with nested objects\", async () => {\n    const resource: Resource = {\n      data: {\n        name: \"alice\",\n        address: { city: \"New York\", zip: \"10001\" },\n      },\n      dataSchema: {\n        type: \"object\",\n        properties: {\n          name: { type: \"string\" },\n          address: {\n            type: \"object\",\n            properties: {\n              city: { type: \"string\" },\n              zip: { type: \"string\" },\n            },\n          },\n        },\n      },\n    }\n\n    const result = await validateDataTool.execute?.(\n      {\n        resource,\n      },\n      {},\n    )\n\n    expect.assert(result)\n    expect.assert(!(\"error\" in result))\n\n    expect(result.valid).toBe(true)\n    expect(result.errors).toHaveLength(0)\n  })\n\n  it(\"validates data with array types\", async () => {\n    const resource: Resource = {\n      data: {\n        tags: [\"admin\", \"user\"],\n        scores: [95, 87, 92],\n      },\n      dataSchema: {\n        type: \"object\",\n        properties: {\n          tags: {\n            type: \"array\",\n            items: { type: \"string\" },\n          },\n          scores: {\n            type: \"array\",\n            items: { type: \"number\" },\n          },\n        },\n      },\n    }\n\n    const result = await validateDataTool.execute?.(\n      {\n        resource,\n      },\n      {},\n    )\n\n    expect.assert(result)\n    expect.assert(!(\"error\" in result))\n\n    expect(result.valid).toBe(true)\n    expect(result.errors).toHaveLength(0)\n  })\n\n  it(\"returns error when no data but schema expected\", async () => {\n    const resource: Resource = {\n      name: \"empty\",\n      dataSchema: { type: \"object\" },\n    }\n\n    const result = await validateDataTool.execute?.(\n      {\n        resource,\n      },\n      {},\n    )\n\n    expect.assert(result)\n    expect.assert(!(\"error\" in result))\n\n    expect(result.valid).toBe(false)\n    expect(result.errors).toHaveLength(1)\n    expect(result.errors).toContainEqual({\n      type: \"resource/type\",\n      expectedResourceType: \"data\",\n    })\n  })\n\n  it(\"validates data with required fields\", async () => {\n    const resource: Resource = {\n      data: { name: \"alice\" },\n      dataSchema: {\n        type: \"object\",\n        properties: {\n          name: { type: \"string\" },\n          age: { type: \"number\" },\n        },\n        required: [\"name\", \"age\"],\n      },\n    }\n\n    const result = await validateDataTool.execute?.(\n      {\n        resource,\n      },\n      {},\n    )\n\n    expect.assert(result)\n    expect.assert(!(\"error\" in result))\n\n    expect(result.valid).toBe(false)\n    expect(result.errors.length).toBeGreaterThan(0)\n  })\n\n  it(\"validates array data against schema\", async () => {\n    const resource: Resource = {\n      data: [\n        { id: 1, name: \"alice\" },\n        { id: 2, name: \"bob\" },\n      ],\n      dataSchema: {\n        type: \"array\",\n        items: {\n          type: \"object\",\n          properties: {\n            id: { type: \"integer\" },\n            name: { type: \"string\" },\n          },\n        },\n      },\n    }\n\n    const result = await validateDataTool.execute?.(\n      {\n        resource,\n      },\n      {},\n    )\n\n    expect.assert(result)\n    expect.assert(!(\"error\" in result))\n\n    expect(result.valid).toBe(true)\n    expect(result.errors).toHaveLength(0)\n  })\n})\n"]}