@unispechq/unispec-core 0.1.0

package/tests/diff.test.mjs

@@ -0,0 +1,240 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import * as core from "../dist/index.js";
+
+const { diffUniSpec } = core;
+
+test("diffUniSpec detects added and removed fields", () => {
+  const oldDoc = { info: { title: "Old" } };
+  const newDoc = { info: { title: "New", description: "Desc" } };
+
+  const result = diffUniSpec(oldDoc, newDoc);
+
+  const paths = result.changes.map((c) => c.path).sort();
+
+  assert.ok(paths.includes("/info/title"));
+  assert.ok(paths.includes("/info/description"));
+});
+
+test("diffUniSpec marks REST path and operation changes with severity and kind", () => {
+  const oldDoc = {
+    unispecVersion: "0.1.0",
+    service: {
+      name: "test-service",
+      protocols: {
+        rest: {
+          paths: {
+            "/ping": {
+              get: {},
+            },
+            "/status": {
+              get: {},
+            },
+          },
+        },
+      },
+    },
+  };
+
+  const newDoc = {
+    unispecVersion: "0.1.0",
+    service: {
+      name: "test-service",
+      protocols: {
+        rest: {
+          paths: {
+            "/ping": {
+              get: {},
+              post: {},
+            },
+          },
+        },
+      },
+    },
+  };
+
+  const result = diffUniSpec(oldDoc, newDoc);
+
+  const restChanges = result.changes.filter((c) => c.protocol === "rest");
+
+  const pathRemoved = restChanges.find((c) => c.kind === "rest.path.removed");
+  const opAdded = restChanges.find((c) => c.kind === "rest.operation.added");
+
+  assert.ok(pathRemoved);
+  assert.equal(pathRemoved.severity, "breaking");
+
+  assert.ok(opAdded);
+  assert.equal(opAdded.severity, "non-breaking");
+});
+
+test("diffUniSpec marks WebSocket channel changes with severity and kind", () => {
+  const oldDoc = {
+    unispecVersion: "0.1.0",
+    service: {
+      name: "test-service",
+      protocols: {
+        websocket: {
+          channels: {
+            chat: {},
+            metrics: {},
+          },
+        },
+      },
+    },
+  };
+
+  const newDoc = {
+    unispecVersion: "0.1.0",
+    service: {
+      name: "test-service",
+      protocols: {
+        websocket: {
+          channels: {
+            chat: {},
+            notifications: {},
+          },
+        },
+      },
+    },
+  };
+
+  const result = diffUniSpec(oldDoc, newDoc);
+
+  const wsChanges = result.changes.filter((c) => c.protocol === "websocket");
+
+  const channelRemoved = wsChanges.find((c) => c.kind === "websocket.channel.removed");
+  const channelAdded = wsChanges.find((c) => c.kind === "websocket.channel.added");
+
+  assert.ok(channelRemoved);
+  assert.equal(channelRemoved.severity, "breaking");
+
+  assert.ok(channelAdded);
+  assert.equal(channelAdded.severity, "non-breaking");
+});
+
+test("diffUniSpec marks WebSocket message changes with severity and kind", () => {
+  const oldDoc = {
+    unispecVersion: "0.1.0",
+    service: {
+      name: "test-service",
+      protocols: {
+        websocket: {
+          channels: {
+            chat: {
+              messages: [
+                { name: "messageA" },
+                { name: "messageB" },
+              ],
+            },
+          },
+        },
+      },
+    },
+  };
+
+  const newDoc = {
+    unispecVersion: "0.1.0",
+    service: {
+      name: "test-service",
+      protocols: {
+        websocket: {
+          channels: {
+            chat: {
+              messages: [
+                { name: "messageA" },
+                { name: "messageB" },
+                { name: "messageC" },
+              ],
+            },
+          },
+        },
+      },
+    },
+  };
+
+  const result = diffUniSpec(oldDoc, newDoc);
+
+  const wsChangesAdd = result.changes.filter((c) => c.protocol === "websocket" && c.kind === "websocket.message.added");
+
+  assert.ok(wsChangesAdd.length > 0);
+  wsChangesAdd.forEach((change) => {
+    assert.equal(change.severity, "non-breaking");
+  });
+
+  const newDoc2 = {
+    unispecVersion: "0.1.0",
+    service: {
+      name: "test-service",
+      protocols: {
+        websocket: {
+          channels: {
+            chat: {
+              messages: [
+                { name: "messageA" },
+              ],
+            },
+          },
+        },
+      },
+    },
+  };
+
+  const result2 = diffUniSpec(oldDoc, newDoc2);
+
+  const wsChangesRemove = result2.changes.filter((c) => c.protocol === "websocket" && c.kind === "websocket.message.removed");
+
+  assert.ok(wsChangesRemove.length > 0);
+  wsChangesRemove.forEach((change) => {
+    assert.equal(change.severity, "breaking");
+  });
+});
+
+test("diffUniSpec marks GraphQL operation changes with severity and kind", () => {
+  const oldDoc = {
+    unispecVersion: "0.1.0",
+    service: {
+      name: "test-service",
+      protocols: {
+        graphql: {
+          operations: {
+            queries: {
+              me: {},
+              ping: {},
+            },
+          },
+        },
+      },
+    },
+  };
+
+  const newDoc = {
+    unispecVersion: "0.1.0",
+    service: {
+      name: "test-service",
+      protocols: {
+        graphql: {
+          operations: {
+            queries: {
+              ping: {},
+              status: {},
+            },
+          },
+        },
+      },
+    },
+  };
+
+  const result = diffUniSpec(oldDoc, newDoc);
+
+  const graphqlChanges = result.changes.filter((c) => c.protocol === "graphql");
+
+  const opRemoved = graphqlChanges.find((c) => c.kind === "graphql.operation.removed");
+  const opAdded = graphqlChanges.find((c) => c.kind === "graphql.operation.added");
+
+  assert.ok(opRemoved);
+  assert.equal(opRemoved.severity, "breaking");
+
+  assert.ok(opAdded);
+  assert.equal(opAdded.severity, "non-breaking");
+});

package/tests/loader-validator.test.mjs

@@ -0,0 +1,19 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import * as core from "../dist/index.js";
+
+const { loadUniSpec, validateUniSpec } = core;
+
+test("loadUniSpec loads JSON string into object", async () => {
+  const input = '{"info": {"title": "Test"}}';
+  const doc = await loadUniSpec(input);
+  assert.equal(typeof doc, "object");
+  assert.equal(doc.info.title, "Test");
+});
+
+test("validateUniSpec returns ValidationResult shape", async () => {
+  const result = await validateUniSpec({});
+  assert.equal(typeof result.valid, "boolean");
+  assert.ok(Array.isArray(result.errors));
+});

package/tests/normalizer.test.mjs

@@ -0,0 +1,115 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import * as core from "../dist/index.js";
+
+const { normalizeUniSpec } = core;
+
+test("normalizeUniSpec sorts object keys deterministically", () => {
+  const doc = {
+    b: 1,
+    a: {
+      d: 3,
+      c: 2,
+    },
+  };
+
+  const normalized = normalizeUniSpec(doc);
+
+  assert.deepEqual(Object.keys(normalized), ["a", "b"]);
+  assert.deepEqual(Object.keys(normalized.a), ["c", "d"]);
+});
+
+test("normalizeUniSpec normalizes REST paths and HTTP methods order", () => {
+  const doc = {
+    unispecVersion: "0.1.0",
+    service: {
+      name: "test-service",
+      protocols: {
+        rest: {
+          paths: {
+            "/z": {
+              post: {},
+              get: {},
+            },
+            "/a": {
+              delete: {},
+              get: {},
+            },
+          },
+        },
+      },
+    },
+  };
+
+  const normalized = normalizeUniSpec(doc);
+
+  const paths = normalized.service.protocols.rest.paths;
+
+  assert.deepEqual(Object.keys(paths), ["/a", "/z"]);
+  assert.deepEqual(Object.keys(paths["/z"]), ["get", "post"]);
+  assert.deepEqual(Object.keys(paths["/a"]), ["get", "delete"]);
+});
+
+test("normalizeUniSpec normalizes GraphQL operations order", () => {
+  const doc = {
+    unispecVersion: "0.1.0",
+    service: {
+      name: "test-service",
+      protocols: {
+        graphql: {
+          operations: {
+            queries: {
+              me: {},
+              ping: {},
+              a: {},
+            },
+          },
+        },
+      },
+    },
+  };
+
+  const normalized = normalizeUniSpec(doc);
+
+  const queries = normalized.service.protocols.graphql.operations.queries;
+  assert.deepEqual(Object.keys(queries), ["a", "me", "ping"]);
+});
+
+test("normalizeUniSpec normalizes WebSocket channels and messages order", () => {
+  const doc = {
+    unispecVersion: "0.1.0",
+    service: {
+      name: "test-service",
+      protocols: {
+        websocket: {
+          channels: {
+            zChannel: {
+              messages: [
+                { name: "msgB" },
+                { name: "msgA" },
+              ],
+            },
+            aChannel: {
+              messages: [
+                { name: "z" },
+                { name: "a" },
+              ],
+            },
+          },
+        },
+      },
+    },
+  };
+
+  const normalized = normalizeUniSpec(doc);
+
+  const channels = normalized.service.protocols.websocket.channels;
+  assert.deepEqual(Object.keys(channels), ["aChannel", "zChannel"]);
+
+  const aMessages = channels.aChannel.messages;
+  const zMessages = channels.zChannel.messages;
+
+  assert.deepEqual(aMessages.map((m) => m.name), ["a", "z"]);
+  assert.deepEqual(zMessages.map((m) => m.name), ["msgA", "msgB"]);
+});

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "Node",
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}