@unispechq/unispec-core 0.3.0 → 0.3.2

package/dist/tests/validator/unispec-validator.test.js

@@ -0,0 +1,98 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { validateUniSpec } from "../../src/validator/index.js";
+import { loadInvalidSpecExample, loadValidSpecExample } from "./utils.js";
+describe("validateUniSpec", () => {
+    describe("valid examples", () => {
+        it("should validate simple REST spec", async () => {
+            const doc = loadValidSpecExample("rest-simple");
+            const result = await validateUniSpec(doc);
+            assert.strictEqual(result.valid, true, "Valid REST spec should pass validation");
+            assert.deepStrictEqual(result.errors, [], "Should have no errors");
+        });
+        it("should validate simple GraphQL spec", async () => {
+            const doc = loadValidSpecExample("graphql-simple");
+            const result = await validateUniSpec(doc);
+            assert.strictEqual(result.valid, true, "Valid GraphQL spec should pass validation");
+            assert.deepStrictEqual(result.errors, [], "Should have no errors");
+        });
+        it("should validate simple WebSocket spec", async () => {
+            const doc = loadValidSpecExample("websocket-simple");
+            const result = await validateUniSpec(doc);
+            assert.strictEqual(result.valid, true, "Valid WebSocket spec should pass validation");
+            assert.deepStrictEqual(result.errors, [], "Should have no errors");
+        });
+        it("should validate mixed complete spec", async () => {
+            const doc = loadValidSpecExample("mixed-complete");
+            const result = await validateUniSpec(doc);
+            assert.strictEqual(result.valid, true, "Valid mixed spec should pass validation");
+            assert.deepStrictEqual(result.errors, [], "Should have no errors");
+        });
+    });
+    describe("invalid examples", () => {
+        it("should reject spec missing service name", async () => {
+            const doc = loadInvalidSpecExample("missing-service-name");
+            const result = await validateUniSpec(doc);
+            assert.strictEqual(result.valid, false, "Spec without service name should fail validation");
+            assert.ok(result.errors.length > 0, "Should have validation errors");
+            // Check that error mentions missing required property
+            const hasServiceNameError = result.errors.some((error) => error.message?.includes("required property") &&
+                error.message.includes("name"));
+            assert.ok(hasServiceNameError, "Should have error about missing service name");
+        });
+        it("should reject spec missing unispec version", async () => {
+            const doc = loadInvalidSpecExample("missing-unispec-version");
+            const result = await validateUniSpec(doc);
+            assert.strictEqual(result.valid, false, "Spec without version should fail validation");
+            assert.ok(result.errors.length > 0, "Should have validation errors");
+        });
+        it("should reject spec with invalid identifier", async () => {
+            const doc = loadInvalidSpecExample("invalid-identifier");
+            const result = await validateUniSpec(doc);
+            assert.strictEqual(result.valid, false, "Spec with invalid identifier should fail validation");
+            assert.ok(result.errors.length > 0, "Should have validation errors");
+        });
+        it("should reject GraphQL spec missing argument type", async () => {
+            const doc = loadInvalidSpecExample("graphql-missing-arg-type");
+            const result = await validateUniSpec(doc);
+            assert.strictEqual(result.valid, false, "GraphQL spec without arg type should fail validation");
+            assert.ok(result.errors.length > 0, "Should have validation errors");
+        });
+        it("should reject GraphQL spec missing name", async () => {
+            const doc = loadInvalidSpecExample("graphql-missing-name");
+            const result = await validateUniSpec(doc);
+            assert.strictEqual(result.valid, false, "GraphQL spec without name should fail validation");
+            assert.ok(result.errors.length > 0, "Should have validation errors");
+        });
+        it("should reject spec with invalid REST method", async () => {
+            const doc = loadInvalidSpecExample("invalid-rest-method");
+            const result = await validateUniSpec(doc);
+            assert.strictEqual(result.valid, false, "Spec with invalid REST method should fail validation");
+            assert.ok(result.errors.length > 0, "Should have validation errors");
+        });
+    });
+    describe("extended validation", () => {
+        it("should perform semantic validation when enabled", async () => {
+            const doc = loadValidSpecExample("rest-simple");
+            const result = await validateUniSpec(doc, {
+                enableExtendedValidation: true,
+                semanticValidation: {},
+            });
+            assert.strictEqual(result.valid, true, "Valid spec should pass semantic validation");
+            assert.ok("semantic" in result, "Should have semantic validation result");
+            const extendedResult = result;
+            assert.strictEqual(extendedResult.semantic?.valid, true, "Semantic validation should pass");
+        });
+        it("should perform reference validation when enabled", async () => {
+            const doc = loadValidSpecExample("mixed-complete");
+            const result = await validateUniSpec(doc, {
+                enableExtendedValidation: true,
+                referenceValidation: {},
+            });
+            assert.strictEqual(result.valid, true, "Valid spec should pass reference validation");
+            assert.ok("references" in result, "Should have reference validation result");
+            const extendedResult = result;
+            assert.strictEqual(extendedResult.references?.valid, true, "Reference validation should pass");
+        });
+    });
+});

package/dist/tests/validator/utils.d.ts

@@ -0,0 +1,6 @@
+import type { UniSpecConfigDocument, UniSpecDocument } from "../../src/types/index.js";
+declare function loadValidSpecExample(name: string): UniSpecDocument;
+declare function loadInvalidSpecExample(name: string): UniSpecDocument;
+declare function loadValidConfigExample(name: string): UniSpecConfigDocument;
+declare function loadInvalidConfigExample(name: string): UniSpecConfigDocument;
+export { loadValidSpecExample, loadInvalidSpecExample, loadValidConfigExample, loadInvalidConfigExample, };

package/dist/tests/validator/utils.js

@@ -0,0 +1,20 @@
+import { join } from "node:path";
+import { examplesDir, loadExample, loadInvalidExample } from "../../tests/utils.js";
+// Validator-specific utilities
+function loadValidSpecExample(name) {
+    const path = join(examplesDir, "valid/spec", `${name}.json`);
+    return loadExample(path);
+}
+function loadInvalidSpecExample(name) {
+    const path = join(examplesDir, "invalid/spec", `${name}.json`);
+    return loadExample(path);
+}
+function loadValidConfigExample(name) {
+    const path = join(examplesDir, "valid/config", `${name}.json`);
+    return loadExample(path);
+}
+function loadInvalidConfigExample(name) {
+    const path = join(examplesDir, "invalid/config", `${name}.json`);
+    return loadInvalidExample(path);
+}
+export { loadValidSpecExample, loadInvalidSpecExample, loadValidConfigExample, loadInvalidConfigExample, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unispechq/unispec-core",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Central UniSpec Core Engine providing parsing, validation, normalization, diffing, and conversion of UniSpec specs.",
   "license": "MIT",
   "repository": {
@@ -42,14 +42,14 @@
     "build:esm": "tsc -p tsconfig.json && tsc-alias -p tsconfig.json --resolve-full-paths",
     "build:cjs": "tsc -p tsconfig.cjs.json && tsc-alias -p tsconfig.cjs.json --resolve-full-paths && node scripts/postbuild-cjs.cjs",
     "schema:generate": "node scripts/generate-schemas.mjs",
-    "test": "pnpm run build && node --test tests/*.test.mjs",
+    "test": "tsx --test tests/**/*.test.ts",
     "lint": "biome check --write --unsafe",
     "release:patch": "node scripts/release.js patch",
     "release:minor": "node scripts/release.js minor",
     "release:major": "node scripts/release.js major"
   },
   "dependencies": {
-    "@unispechq/unispec-schema": "^0.4.1",
+    "@unispechq/unispec-schema": "^0.4.4",
     "ajv": "^8.12.0"
   },
   "optionalDependencies": {
@@ -60,6 +60,7 @@
     "@types/js-yaml": "^4.0.5",
     "@types/node": "^24.10.1",
     "tsc-alias": "^1.8.16",
+    "tsx": "^4.7.0",
     "typescript": "^5.0.0"
   },
   "publishConfig": {