@digital-science-dsl/dimensions-analytics-mcp 0.5.3

package/test/dsl/commands/functions/ClassifyCommand.test.ts

@@ -0,0 +1,170 @@
+import { describe, expect, it } from "vitest";
+import { ValidationError } from "../../../../src/client/index.js";
+import { ClassifyCommand } from "../../../../src/dsl/commands/functions/ClassifyCommand.js";
+
+describe("ClassifyCommand", () => {
+  describe("constructor validation", () => {
+    it("creates command with title only", () => {
+      const cmd = new ClassifyCommand({
+        title: "Machine learning",
+        system: "FOR",
+      });
+
+      expect(cmd.input.title).toBe("Machine learning");
+      expect(cmd.input.abstract).toBeUndefined();
+      expect(cmd.input.system).toBe("FOR");
+    });
+
+    it("creates command with abstract only", () => {
+      const cmd = new ClassifyCommand({
+        abstract: "This study examines...",
+        system: "SDG",
+      });
+
+      expect(cmd.input.title).toBeUndefined();
+      expect(cmd.input.abstract).toBe("This study examines...");
+      expect(cmd.input.system).toBe("SDG");
+    });
+
+    it("creates command with both title and abstract", () => {
+      const cmd = new ClassifyCommand({
+        title: "Test Title",
+        abstract: "Test Abstract",
+        system: "RCDC",
+      });
+
+      expect(cmd.input.title).toBe("Test Title");
+      expect(cmd.input.abstract).toBe("Test Abstract");
+      expect(cmd.input.system).toBe("RCDC");
+    });
+
+    it("throws ValidationError when neither title nor abstract provided", () => {
+      expect(
+        () =>
+          new ClassifyCommand({
+            system: "FOR",
+          } as never),
+      ).toThrow(ValidationError);
+    });
+
+    it("accepts all valid classification systems", () => {
+      const systems = [
+        "FOR",
+        "FOR_2020",
+        "SDG",
+        "SDG_2021",
+        "RCDC",
+        "HRCS_HC",
+        "HRCS_RAC",
+        "HRA",
+        "BRA",
+        "ICRP_CSO",
+        "ICRP_CT",
+        "UOA",
+      ] as const;
+
+      for (const system of systems) {
+        const cmd = new ClassifyCommand({ title: "Test", system });
+        expect(cmd.input.system).toBe(system);
+      }
+    });
+  });
+
+  describe("resolveQuery", () => {
+    it("generates DSL with title only", () => {
+      const cmd = new ClassifyCommand({
+        title: "Burnout in nursing",
+        system: "FOR",
+      });
+
+      expect(cmd.resolveQuery()).toBe('classify(title="Burnout in nursing", system="FOR")');
+    });
+
+    it("generates DSL with abstract only", () => {
+      const cmd = new ClassifyCommand({
+        abstract: "This research examines...",
+        system: "SDG",
+      });
+
+      expect(cmd.resolveQuery()).toBe(
+        'classify(abstract="This research examines...", system="SDG")',
+      );
+    });
+
+    it("generates DSL with both title and abstract", () => {
+      const cmd = new ClassifyCommand({
+        title: "Climate change",
+        abstract: "Rising sea levels affect...",
+        system: "SDG",
+      });
+
+      expect(cmd.resolveQuery()).toBe(
+        'classify(title="Climate change", abstract="Rising sea levels affect...", system="SDG")',
+      );
+    });
+
+    it("escapes quotes in text", () => {
+      const cmd = new ClassifyCommand({
+        title: 'A "quoted" title',
+        system: "FOR",
+      });
+
+      expect(cmd.resolveQuery()).toBe('classify(title="A \\"quoted\\" title", system="FOR")');
+    });
+
+    it("normalizes newlines in text", () => {
+      const cmd = new ClassifyCommand({
+        abstract: "Line one\nLine two",
+        system: "FOR",
+      });
+
+      expect(cmd.resolveQuery()).toBe('classify(abstract="Line one\\nLine two", system="FOR")');
+    });
+  });
+
+  describe("transformResponse", () => {
+    it("transforms valid FOR classification response", () => {
+      const cmd = new ClassifyCommand({
+        title: "Test",
+        system: "FOR",
+      });
+
+      const response = {
+        FOR: [
+          { id: "1117", name: "Public Health and Health Services" },
+          { id: "1103", name: "Clinical Sciences" },
+        ],
+      };
+
+      const result = cmd.transformResponse(response);
+      expect(result.FOR).toHaveLength(2);
+      expect(result.FOR[0].id).toBe("1117");
+      expect(result.FOR[0].name).toBe("Public Health and Health Services");
+    });
+
+    it("transforms valid SDG classification response", () => {
+      const cmd = new ClassifyCommand<"SDG">({
+        title: "Test",
+        system: "SDG",
+      });
+
+      const response = {
+        SDG: [{ id: "3", name: "Good Health and Well-being" }],
+      };
+
+      const result = cmd.transformResponse(response);
+      expect(result.SDG).toHaveLength(1);
+      expect(result.SDG[0].id).toBe("3");
+    });
+
+    it("throws ValidationError for invalid response structure", () => {
+      const cmd = new ClassifyCommand({
+        title: "Test",
+        system: "FOR",
+      });
+
+      expect(() => cmd.transformResponse("not an object")).toThrow(ValidationError);
+      expect(() => cmd.transformResponse({ FOR: "not an array" })).toThrow(ValidationError);
+    });
+  });
+});

package/test/dsl/commands/functions/ExtractAffiliationsCommand.test.ts

@@ -0,0 +1,306 @@
+/**
+ * Tests for ExtractAffiliationsCommand.
+ * @module test/commands/functions/ExtractAffiliationsCommand
+ */
+
+import { describe, expect, it } from "vitest";
+import { ValidationError } from "../../../../src/client/index.js";
+import {
+  ExtractAffiliationsCommand,
+  ExtractAffiliationsInputSchema,
+} from "../../../../src/dsl/commands/functions/ExtractAffiliationsCommand.js";
+
+describe("ExtractAffiliationsCommand", () => {
+  describe("input validation", () => {
+    it("should accept valid freetext affiliation input", () => {
+      const input = {
+        affiliations: [
+          { affiliation: "University of Oxford, UK" },
+          { affiliation: "Stanford University, Stanford, CA, USA" },
+        ],
+      };
+
+      const cmd = new ExtractAffiliationsCommand(input);
+      expect(cmd.input.affiliations).toHaveLength(2);
+    });
+
+    it("should accept valid structured affiliation input", () => {
+      const input = {
+        affiliations: [
+          { name: "Stanford", city: "Stanford", country: "USA" },
+          { name: "MIT", state: "Massachusetts", country: "USA" },
+        ],
+      };
+
+      const cmd = new ExtractAffiliationsCommand(input);
+      expect(cmd.input.affiliations).toHaveLength(2);
+    });
+
+    it("should accept mixed freetext and structured input", () => {
+      const input = {
+        affiliations: [
+          { affiliation: "University of Oxford, UK" },
+          { name: "Stanford", city: "Stanford", country: "USA" },
+        ],
+      };
+
+      const cmd = new ExtractAffiliationsCommand(input);
+      expect(cmd.input.affiliations).toHaveLength(2);
+    });
+
+    it("should reject empty affiliations array", () => {
+      expect(() => {
+        new ExtractAffiliationsCommand({ affiliations: [] });
+      }).toThrow(ValidationError);
+    });
+
+    it("should reject affiliation with neither freetext nor structured fields", () => {
+      expect(() => {
+        new ExtractAffiliationsCommand({
+          affiliations: [{}],
+        });
+      }).toThrow(ValidationError);
+    });
+
+    it("should accept affiliation with only name (minimal structured)", () => {
+      const input = {
+        affiliations: [{ name: "Harvard" }],
+      };
+
+      const cmd = new ExtractAffiliationsCommand(input);
+      expect(cmd.input.affiliations).toHaveLength(1);
+    });
+  });
+
+  describe("DSL generation", () => {
+    it("should generate correct DSL for freetext affiliations", () => {
+      const cmd = new ExtractAffiliationsCommand({
+        affiliations: [{ affiliation: "University of Oxford, UK" }],
+      });
+
+      const dsl = cmd.resolveQuery();
+      expect(dsl).toBe('extract_affiliations(json=[{"affiliation": "University of Oxford, UK"}])');
+    });
+
+    it("should generate correct DSL for structured affiliations", () => {
+      const cmd = new ExtractAffiliationsCommand({
+        affiliations: [{ name: "Stanford", city: "Stanford", country: "USA" }],
+      });
+
+      const dsl = cmd.resolveQuery();
+      expect(dsl).toBe(
+        'extract_affiliations(json=[{"name": "Stanford", "city": "Stanford", "country": "USA"}])',
+      );
+    });
+
+    it("should generate correct DSL for multiple affiliations", () => {
+      const cmd = new ExtractAffiliationsCommand({
+        affiliations: [
+          { affiliation: "University of Oxford, UK" },
+          { name: "Stanford", city: "Stanford", country: "USA" },
+        ],
+      });
+
+      const dsl = cmd.resolveQuery();
+      expect(dsl).toBe(
+        'extract_affiliations(json=[{"affiliation": "University of Oxford, UK"}, {"name": "Stanford", "city": "Stanford", "country": "USA"}])',
+      );
+    });
+
+    it("should escape quotes in affiliation text", () => {
+      const cmd = new ExtractAffiliationsCommand({
+        affiliations: [{ affiliation: 'University "Test" Name' }],
+      });
+
+      const dsl = cmd.resolveQuery();
+      expect(dsl).toContain('\\"Test\\"');
+    });
+
+    it("should include state when provided in structured input", () => {
+      const cmd = new ExtractAffiliationsCommand({
+        affiliations: [{ name: "MIT", state: "Massachusetts", country: "USA" }],
+      });
+
+      const dsl = cmd.resolveQuery();
+      expect(dsl).toContain('"state": "Massachusetts"');
+    });
+  });
+
+  describe("response transformation", () => {
+    it("should transform valid API response", () => {
+      const cmd = new ExtractAffiliationsCommand({
+        affiliations: [{ affiliation: "University of Oxford" }],
+      });
+
+      const response = {
+        extracted_affiliations: [
+          {
+            id: "grid.4991.5",
+            name: "University of Oxford",
+            country: "United Kingdom",
+            score: 0.95,
+          },
+        ],
+      };
+
+      const result = cmd.transformResponse(response);
+      expect(result.extracted_affiliations).toHaveLength(1);
+      expect(result.extracted_affiliations[0].id).toBe("grid.4991.5");
+      expect(result.extracted_affiliations[0].name).toBe("University of Oxford");
+      expect(result.extracted_affiliations[0].score).toBe(0.95);
+    });
+
+    it("should handle multiple results per affiliation", () => {
+      const cmd = new ExtractAffiliationsCommand({
+        affiliations: [{ affiliation: "Stanford" }],
+      });
+
+      const response = {
+        extracted_affiliations: [
+          { id: "grid.168010.e", name: "Stanford University", score: 0.98 },
+          { id: "grid.168011.e", name: "Stanford Health Care", score: 0.72 },
+        ],
+      };
+
+      const result = cmd.transformResponse(response);
+      expect(result.extracted_affiliations).toHaveLength(2);
+    });
+
+    it("should handle empty results", () => {
+      const cmd = new ExtractAffiliationsCommand({
+        affiliations: [{ affiliation: "Unknown Institution XYZ" }],
+      });
+
+      const response = {
+        extracted_affiliations: [],
+      };
+
+      const result = cmd.transformResponse(response);
+      expect(result.extracted_affiliations).toHaveLength(0);
+    });
+
+    it("should handle results without optional fields", () => {
+      const cmd = new ExtractAffiliationsCommand({
+        affiliations: [{ affiliation: "Some University" }],
+      });
+
+      const response = {
+        extracted_affiliations: [{ id: "grid.123456", name: "Some University" }],
+      };
+
+      const result = cmd.transformResponse(response);
+      expect(result.extracted_affiliations[0].country).toBeUndefined();
+      expect(result.extracted_affiliations[0].score).toBeUndefined();
+    });
+
+    it("should throw ValidationError for invalid response structure", () => {
+      const cmd = new ExtractAffiliationsCommand({
+        affiliations: [{ affiliation: "Test" }],
+      });
+
+      expect(() => {
+        cmd.transformResponse({ invalid: "response" });
+      }).toThrow(ValidationError);
+    });
+
+    it("should throw ValidationError for missing id in result", () => {
+      const cmd = new ExtractAffiliationsCommand({
+        affiliations: [{ affiliation: "Test" }],
+      });
+
+      expect(() => {
+        cmd.transformResponse({
+          extracted_affiliations: [{ name: "Test University" }],
+        });
+      }).toThrow(ValidationError);
+    });
+  });
+
+  describe("results parameter", () => {
+    it("should generate DSL without results when not specified", () => {
+      const cmd = new ExtractAffiliationsCommand({
+        affiliations: [{ affiliation: "University of Oxford" }],
+      });
+
+      const dsl = cmd.resolveQuery();
+      expect(dsl).not.toContain("results=");
+    });
+
+    it("should generate DSL with results='full'", () => {
+      const cmd = new ExtractAffiliationsCommand({
+        affiliations: [{ affiliation: "University of Oxford" }],
+        results: "full",
+      });
+
+      const dsl = cmd.resolveQuery();
+      expect(dsl).toContain('results="full"');
+    });
+
+    it("should generate DSL with results='basic'", () => {
+      const cmd = new ExtractAffiliationsCommand({
+        affiliations: [{ affiliation: "Test" }],
+        results: "basic",
+      });
+
+      const dsl = cmd.resolveQuery();
+      expect(dsl).toContain('results="basic"');
+    });
+
+    it("should generate DSL with results='publisher'", () => {
+      const cmd = new ExtractAffiliationsCommand({
+        affiliations: [{ affiliation: "Test" }],
+        results: "publisher",
+      });
+
+      const dsl = cmd.resolveQuery();
+      expect(dsl).toContain('results="publisher"');
+    });
+
+    it("should reject invalid results value", () => {
+      expect(() => {
+        new ExtractAffiliationsCommand({
+          affiliations: [{ affiliation: "Test" }],
+          results: "invalid" as "basic",
+        });
+      }).toThrow(ValidationError);
+    });
+  });
+
+  describe("endpoint resolution", () => {
+    it("should resolve to DSL v2 endpoint", () => {
+      const cmd = new ExtractAffiliationsCommand({
+        affiliations: [{ affiliation: "Test" }],
+      });
+
+      expect(cmd.resolveEndpoint()).toBe("/api/dsl/v2");
+    });
+  });
+});
+
+describe("ExtractAffiliationsInputSchema", () => {
+  it("should validate correct freetext input", () => {
+    const result = ExtractAffiliationsInputSchema.safeParse({
+      affiliations: [{ affiliation: "Oxford" }],
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("should validate correct structured input", () => {
+    const result = ExtractAffiliationsInputSchema.safeParse({
+      affiliations: [{ name: "Stanford", country: "USA" }],
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("should reject empty array", () => {
+    const result = ExtractAffiliationsInputSchema.safeParse({
+      affiliations: [],
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it("should reject missing affiliations field", () => {
+    const result = ExtractAffiliationsInputSchema.safeParse({});
+    expect(result.success).toBe(false);
+  });
+});

package/test/dsl/commands/functions/ExtractConceptsCommand.test.ts

@@ -0,0 +1,136 @@
+import { describe, expect, it } from "vitest";
+import { ValidationError } from "../../../../src/client/index.js";
+import { ExtractConceptsCommand } from "../../../../src/dsl/commands/functions/ExtractConceptsCommand.js";
+
+describe("ExtractConceptsCommand", () => {
+  describe("constructor validation", () => {
+    it("creates command with required text", () => {
+      const cmd = new ExtractConceptsCommand({
+        text: "Machine learning algorithms",
+      });
+
+      expect(cmd.input.text).toBe("Machine learning algorithms");
+      expect(cmd.input.returnScores).toBe(false);
+    });
+
+    it("creates command with returnScores true", () => {
+      const cmd = new ExtractConceptsCommand({
+        text: "Test text",
+        returnScores: true,
+      });
+
+      expect(cmd.input.text).toBe("Test text");
+      expect(cmd.input.returnScores).toBe(true);
+    });
+
+    it("defaults returnScores to false", () => {
+      const cmd = new ExtractConceptsCommand({
+        text: "Test text",
+      });
+
+      expect(cmd.input.returnScores).toBe(false);
+    });
+
+    it("throws ValidationError for empty text", () => {
+      expect(() => new ExtractConceptsCommand({ text: "" })).toThrow(ValidationError);
+    });
+  });
+
+  describe("resolveQuery", () => {
+    it("generates DSL without return_scores", () => {
+      const cmd = new ExtractConceptsCommand({
+        text: "Neural networks for drug discovery",
+      });
+
+      expect(cmd.resolveQuery()).toBe('extract_concepts("Neural networks for drug discovery")');
+    });
+
+    it("generates DSL with return_scores=true", () => {
+      const cmd = new ExtractConceptsCommand({
+        text: "Neural networks for drug discovery",
+        returnScores: true,
+      });
+
+      expect(cmd.resolveQuery()).toBe(
+        'extract_concepts("Neural networks for drug discovery", return_scores=true)',
+      );
+    });
+
+    it("escapes quotes in text", () => {
+      const cmd = new ExtractConceptsCommand({
+        text: 'Text with "quotes"',
+      });
+
+      expect(cmd.resolveQuery()).toBe('extract_concepts("Text with \\"quotes\\"")');
+    });
+
+    it("normalizes newlines in text", () => {
+      const cmd = new ExtractConceptsCommand({
+        text: "Line one\nLine two\nLine three",
+      });
+
+      expect(cmd.resolveQuery()).toBe('extract_concepts("Line one\\nLine two\\nLine three")');
+    });
+  });
+
+  describe("transformResponse", () => {
+    it("transforms simple concept array response", () => {
+      const cmd = new ExtractConceptsCommand({
+        text: "Test",
+      });
+
+      const response = {
+        extracted_concepts: ["machine learning", "neural networks", "deep learning"],
+      };
+
+      const result = cmd.transformResponse(response);
+      expect(result.extracted_concepts).toHaveLength(3);
+      expect(result.extracted_concepts[0]).toBe("machine learning");
+    });
+
+    it("transforms concepts with scores response", () => {
+      const cmd = new ExtractConceptsCommand({
+        text: "Test",
+        returnScores: true,
+      });
+
+      const response = {
+        extracted_concepts: [
+          { concept: "machine learning", relevance: 0.95 },
+          { concept: "neural networks", relevance: 0.87 },
+        ],
+      };
+
+      const result = cmd.transformResponse(response);
+      expect(result.extracted_concepts).toHaveLength(2);
+      expect((result.extracted_concepts[0] as { concept: string; relevance: number }).concept).toBe(
+        "machine learning",
+      );
+      expect(
+        (result.extracted_concepts[0] as { concept: string; relevance: number }).relevance,
+      ).toBe(0.95);
+    });
+
+    it("throws ValidationError for invalid response structure", () => {
+      const cmd = new ExtractConceptsCommand({
+        text: "Test",
+      });
+
+      expect(() => cmd.transformResponse("not an object")).toThrow(ValidationError);
+      expect(() => cmd.transformResponse({ wrong_key: [] })).toThrow(ValidationError);
+    });
+
+    it("throws ValidationError when expecting scores but gets strings", () => {
+      const cmd = new ExtractConceptsCommand({
+        text: "Test",
+        returnScores: true,
+      });
+
+      const response = {
+        extracted_concepts: ["machine learning", "neural networks"],
+      };
+
+      expect(() => cmd.transformResponse(response)).toThrow(ValidationError);
+    });
+  });
+});