@unispechq/unispec-core 0.3.2 → 0.3.4

package/dist/tests/schemas/schemas.test.js

@@ -1,395 +0,0 @@
-import assert from "node:assert";
-import { describe, it } from "node:test";
-import { dedupeSchemas, registerSchema, resolveSchemaRef } from "../../src/schemas/index.js";
-import { normalizeSchemaRef, stableStringify } from "../../src/schemas/utils.js";
-import { getExamplePath, loadExample } from "./utils.js";
-describe("schemas module", () => {
-    describe("normalizeSchemaRef", () => {
-        it("should handle simple name format", () => {
-            assert.strictEqual(normalizeSchemaRef("User"), "User");
-            assert.strictEqual(normalizeSchemaRef("CreateOrderRequest"), "CreateOrderRequest");
-        });
-        it("should handle JSON Pointer format", () => {
-            assert.strictEqual(normalizeSchemaRef("#/service/schemas/User"), "User");
-            assert.strictEqual(normalizeSchemaRef("#/service/schemas/CreateOrderRequest"), "CreateOrderRequest");
-        });
-        it("should handle hash format", () => {
-            assert.strictEqual(normalizeSchemaRef("#User"), "User");
-            assert.strictEqual(normalizeSchemaRef("#CreateOrderRequest"), "CreateOrderRequest");
-        });
-        it("should handle path format", () => {
-            assert.strictEqual(normalizeSchemaRef("path/to/User"), "User");
-            assert.strictEqual(normalizeSchemaRef("models/User"), "User");
-        });
-        it("should handle empty and whitespace strings", () => {
-            assert.strictEqual(normalizeSchemaRef(""), "");
-            assert.strictEqual(normalizeSchemaRef("   "), "");
-            assert.strictEqual(normalizeSchemaRef("#"), "");
-        });
-        it("should handle complex paths", () => {
-            assert.strictEqual(normalizeSchemaRef("#/service/schemas/nested/User"), "User");
-            assert.strictEqual(normalizeSchemaRef("deeply/nested/path/to/Schema"), "Schema");
-        });
-    });
-    describe("stableStringify", () => {
-        it("should create consistent strings for simple values", () => {
-            assert.strictEqual(stableStringify(null), "null");
-            assert.strictEqual(stableStringify(42), "42");
-            assert.strictEqual(stableStringify(true), "true");
-            assert.strictEqual(stableStringify("test"), '"test"');
-        });
-        it("should create consistent strings for arrays", () => {
-            assert.strictEqual(stableStringify([1, 2, 3]), "[1,2,3]");
-            assert.strictEqual(stableStringify(["b", "a"]), '["b","a"]');
-            assert.strictEqual(stableStringify([]), "[]");
-        });
-        it("should create consistent strings for objects with sorted keys", () => {
-            const obj1 = { b: 2, a: 1 };
-            const obj2 = { a: 1, b: 2 };
-            assert.strictEqual(stableStringify(obj1), stableStringify(obj2));
-            assert.strictEqual(stableStringify(obj1), '{"a":1,"b":2}');
-        });
-        it("should handle nested objects", () => {
-            const nested = {
-                outer: {
-                    z: 3,
-                    a: 1,
-                },
-                b: 2,
-            };
-            assert.strictEqual(stableStringify(nested), '{"b":2,"outer":{"a":1,"z":3}}');
-        });
-        it("should handle complex nested structures", () => {
-            const complex = {
-                type: "object",
-                properties: {
-                    name: { type: "string" },
-                    age: { type: "number" },
-                },
-                required: ["name", "age"],
-            };
-            const expected = '{"properties":{"age":{"type":"number"},"name":{"type":"string"}},"required":["name","age"],"type":"object"}';
-            assert.strictEqual(stableStringify(complex), expected);
-        });
-    });
-    describe("registerSchema", () => {
-        it("should register a new schema in an empty document", () => {
-            const doc = {
-                unispecVersion: "1.0.0",
-                service: { name: "test-service" },
-            };
-            const jsonSchema = {
-                type: "object",
-                properties: {
-                    name: { type: "string" },
-                },
-            };
-            const definition = registerSchema(doc, "User", jsonSchema);
-            assert.deepStrictEqual(definition.jsonSchema, jsonSchema);
-            assert.ok(doc.service?.schemas?.User);
-        });
-        it("should create schemas container if missing", () => {
-            const doc = {
-                unispecVersion: "1.0.0",
-                service: { name: "test-service" },
-            };
-            registerSchema(doc, "User", { type: "object" });
-            assert.ok(doc.service?.schemas);
-            assert.ok(doc.service.schemas.User);
-        });
-        it("should create service if missing", () => {
-            const doc = {
-                unispecVersion: "1.0.0",
-            };
-            registerSchema(doc, "User", { type: "object" });
-            assert.ok(doc.service);
-            assert.strictEqual(doc.service.name, "");
-            assert.ok(doc.service.schemas);
-        });
-        it("should overwrite existing schema", () => {
-            const doc = {
-                unispecVersion: "1.0.0",
-                service: {
-                    name: "test-service",
-                    schemas: {
-                        User: {
-                            jsonSchema: { type: "string" },
-                        },
-                    },
-                },
-            };
-            const newSchema = { type: "number" };
-            registerSchema(doc, "User", newSchema);
-            assert.deepStrictEqual(doc.service?.schemas?.User?.jsonSchema, newSchema);
-        });
-    });
-    describe("resolveSchemaRef", () => {
-        it("should resolve simple schema reference", () => {
-            const doc = loadExample(getExamplePath("valid", "spec", "mixed-complete.json"));
-            const schema = resolveSchemaRef(doc, "CreateOrderRequest");
-            assert.ok(schema);
-            assert.strictEqual(schema.jsonSchema.type, "object");
-            assert.ok(schema?.jsonSchema.properties);
-            const properties = schema.jsonSchema.properties;
-            assert.ok(properties.productIds);
-        });
-        it("should resolve JSON Pointer reference", () => {
-            const doc = loadExample(getExamplePath("valid", "spec", "mixed-complete.json"));
-            const schema = resolveSchemaRef(doc, "#/service/schemas/OrderStatusUpdate");
-            assert.ok(schema);
-            assert.strictEqual(schema.jsonSchema.type, "object");
-            assert.ok(schema?.jsonSchema.properties);
-            const properties = schema.jsonSchema.properties;
-            assert.ok(properties.status);
-        });
-        it("should resolve hash reference", () => {
-            const doc = loadExample(getExamplePath("valid", "spec", "mixed-complete.json"));
-            const schema = resolveSchemaRef(doc, "#OrderStatusUpdate");
-            assert.ok(schema);
-            assert.strictEqual(schema.jsonSchema.type, "object");
-        });
-        it("should return undefined for non-existent schema", () => {
-            const doc = loadExample(getExamplePath("valid", "spec", "mixed-complete.json"));
-            const schema = resolveSchemaRef(doc, "NonExistentSchema");
-            assert.strictEqual(schema, undefined);
-        });
-        it("should return undefined for empty reference", () => {
-            const doc = loadExample(getExamplePath("valid", "spec", "mixed-complete.json"));
-            const schema = resolveSchemaRef(doc, "");
-            assert.strictEqual(schema, undefined);
-        });
-        it("should handle document without schemas", () => {
-            const doc = loadExample(getExamplePath("valid", "spec", "rest-simple.json"));
-            const schema = resolveSchemaRef(doc, "AnySchema");
-            assert.strictEqual(schema, undefined);
-        });
-    });
-    describe("dedupeSchemas", () => {
-        it("should remove duplicate schemas and update references", () => {
-            const doc = {
-                unispecVersion: "1.0.0",
-                service: {
-                    name: "test-service",
-                    schemas: {
-                        User: {
-                            jsonSchema: {
-                                type: "object",
-                                properties: {
-                                    id: { type: "string" },
-                                    name: { type: "string" },
-                                },
-                            },
-                        },
-                        Person: {
-                            jsonSchema: {
-                                type: "object",
-                                properties: {
-                                    id: { type: "string" },
-                                    name: { type: "string" },
-                                },
-                            },
-                        },
-                    },
-                    protocols: {
-                        rest: {
-                            routes: [
-                                {
-                                    name: "getUser",
-                                    path: "/user",
-                                    method: "GET",
-                                    responses: {
-                                        "200": {
-                                            description: "User found",
-                                            content: {
-                                                "application/json": {
-                                                    schemaRef: "User",
-                                                },
-                                            },
-                                        },
-                                    },
-                                },
-                                {
-                                    name: "getPerson",
-                                    path: "/person",
-                                    method: "GET",
-                                    responses: {
-                                        "200": {
-                                            description: "Person found",
-                                            content: {
-                                                "application/json": {
-                                                    schemaRef: "Person",
-                                                },
-                                            },
-                                        },
-                                    },
-                                },
-                            ],
-                        },
-                    },
-                },
-            };
-            dedupeSchemas(doc);
-            // Should keep only one schema (the first one encountered)
-            const schemas = doc.service?.schemas;
-            assert.strictEqual(Object.keys(schemas || {}).length, 1);
-            assert.ok(schemas?.User);
-            assert.strictEqual(schemas?.Person, undefined);
-            // References should be updated to point to the retained schema
-            const rest = doc.service?.protocols?.rest;
-            if (rest?.routes) {
-                const userRoute = rest.routes[0];
-                const personRoute = rest.routes[1];
-                assert.strictEqual(userRoute.responses?.["200"]?.content?.["application/json"]
-                    ?.schemaRef, "User");
-                assert.strictEqual(personRoute.responses?.["200"]?.content?.["application/json"]
-                    ?.schemaRef, "User");
-            }
-        });
-        it("should handle documents without schemas", () => {
-            const doc = loadExample(getExamplePath("valid", "spec", "rest-simple.json"));
-            // Should not throw
-            dedupeSchemas(doc);
-            // Should still not have schemas
-            assert.strictEqual(doc.service?.schemas, undefined);
-        });
-        it("should handle empty schemas object", () => {
-            const doc = {
-                unispecVersion: "1.0.0",
-                service: {
-                    name: "test-service",
-                    schemas: {},
-                },
-            };
-            // Should not throw
-            dedupeSchemas(doc);
-            assert.deepStrictEqual(doc.service.schemas, {});
-        });
-        it("should preserve unique schemas", () => {
-            const doc = {
-                unispecVersion: "1.0.0",
-                service: {
-                    name: "test-service",
-                    schemas: {
-                        User: {
-                            jsonSchema: { type: "string" },
-                        },
-                        Product: {
-                            jsonSchema: { type: "number" },
-                        },
-                    },
-                },
-            };
-            dedupeSchemas(doc);
-            // Both schemas should be preserved
-            const schemas = doc.service?.schemas;
-            assert.strictEqual(Object.keys(schemas || {}).length, 2);
-            assert.ok(schemas?.User);
-            assert.ok(schemas?.Product);
-        });
-        it("should update all types of schema references", () => {
-            const doc = {
-                unispecVersion: "1.0.0",
-                service: {
-                    name: "test-service",
-                    schemas: {
-                        SchemaA: {
-                            jsonSchema: { type: "object" },
-                        },
-                        SchemaB: {
-                            jsonSchema: { type: "object" },
-                        },
-                    },
-                    protocols: {
-                        rest: {
-                            routes: [
-                                {
-                                    name: "test",
-                                    path: "/test",
-                                    method: "POST",
-                                    pathParams: [{ name: "id", schemaRef: "SchemaA" }],
-                                    queryParams: [{ name: "filter", schemaRef: "SchemaB" }],
-                                    headers: [{ name: "auth", schemaRef: "SchemaA" }],
-                                    requestBody: {
-                                        content: {
-                                            "application/json": { schemaRef: "SchemaB" },
-                                        },
-                                    },
-                                    responses: {
-                                        "200": {
-                                            content: {
-                                                "application/json": { schemaRef: "SchemaA" },
-                                            },
-                                        },
-                                    },
-                                },
-                            ],
-                        },
-                        websocket: {
-                            channels: [
-                                {
-                                    name: "test",
-                                    messages: [{ name: "msg", schemaRef: "SchemaB" }],
-                                },
-                            ],
-                        },
-                    },
-                },
-            };
-            dedupeSchemas(doc);
-            // Should keep only SchemaA
-            const schemas = doc.service?.schemas;
-            assert.strictEqual(Object.keys(schemas || {}).length, 1);
-            assert.ok(schemas?.SchemaA);
-            const rest = doc.service?.protocols?.rest;
-            if (rest?.routes) {
-                const route = rest.routes[0];
-                assert.strictEqual(route.pathParams?.[0]?.schemaRef, "SchemaA");
-                assert.strictEqual(route.queryParams?.[0]?.schemaRef, "SchemaA");
-                assert.strictEqual(route.headers?.[0]?.schemaRef, "SchemaA");
-                assert.strictEqual(route.requestBody?.content?.["application/json"]?.schemaRef, "SchemaA");
-                assert.strictEqual(route.responses?.["200"]?.content?.["application/json"]?.schemaRef, "SchemaA");
-            }
-            const ws = doc.service?.protocols?.websocket;
-            if (ws?.channels) {
-                const wsMessage = ws.channels[0].messages?.[0];
-                if (wsMessage) {
-                    assert.strictEqual(wsMessage.schemaRef, "SchemaA");
-                }
-            }
-        });
-    });
-    describe("integration with real examples", () => {
-        it("should handle mixed-complete example correctly", () => {
-            const doc = loadExample(getExamplePath("valid", "spec", "mixed-complete.json"));
-            // Test resolving existing schemas
-            const createOrderSchema = resolveSchemaRef(doc, "CreateOrderRequest");
-            assert.ok(createOrderSchema?.jsonSchema.properties);
-            const createOrderProperties = createOrderSchema.jsonSchema
-                .properties;
-            assert.ok(createOrderProperties.productIds);
-            assert.ok(createOrderProperties.customerId);
-            const orderStatusSchema = resolveSchemaRef(doc, "OrderStatusUpdate");
-            assert.ok(orderStatusSchema);
-            assert.strictEqual(orderStatusSchema.jsonSchema.type, "object");
-            assert.ok(orderStatusSchema.jsonSchema.properties);
-            const orderStatusProperties = orderStatusSchema.jsonSchema
-                .properties;
-            assert.ok(orderStatusProperties.orderId);
-            assert.ok(orderStatusProperties.status);
-            // Test deduplication with no duplicates
-            const schemas = doc.service?.schemas;
-            const originalSchemaCount = Object.keys(schemas || {}).length;
-            dedupeSchemas(doc);
-            assert.strictEqual(Object.keys(schemas || {}).length, originalSchemaCount);
-        });
-        it("should handle documents without schemas gracefully", () => {
-            const doc = loadExample(getExamplePath("valid", "spec", "rest-simple.json"));
-            // Should not throw when resolving non-existent schemas
-            assert.strictEqual(resolveSchemaRef(doc, "NonExistent"), undefined);
-            // Should not throw when deduplicating
-            dedupeSchemas(doc);
-            // Should still have no schemas
-            assert.strictEqual(doc.service?.schemas, undefined);
-        });
-    });
-});

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

@@ -1,2 +0,0 @@
-import { examplesDir, getExamplePath, loadExample } from "../../tests/utils.js";
-export { examplesDir, getExamplePath, loadExample };

package/dist/tests/schemas/utils.js

@@ -1,3 +0,0 @@
-import { examplesDir, getExamplePath, loadExample } from "../../tests/utils.js";
-// Re-export commonly used functions from tests/utils for convenience
-export { examplesDir, getExamplePath, loadExample };

package/dist/tests/utils.d.ts

@@ -1,10 +0,0 @@
-import type { UniSpecChange } from "../src/diff/types.js";
-import type { UniSpecDocument } from "../src/types/index.js";
-export declare const examplesDir: string;
-export declare function loadExample(filePath: string): UniSpecDocument;
-export declare function getExamplePath(...parts: string[]): string;
-export declare function createTestDocument(overrides?: Partial<UniSpecDocument>): UniSpecDocument;
-export declare function createTestChange(overrides?: Partial<UniSpecChange>): UniSpecChange;
-export declare function loadInvalidExample(filePath: string): unknown;
-export declare function getValidExamplePaths(): string[];
-export declare function getInvalidExamplePaths(): string[];

package/dist/tests/utils.js

@@ -1,118 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-export const examplesDir = path.join(process.cwd(), "node_modules", "@unispechq", "unispec-schema", "examples");
-export function loadExample(filePath) {
-    const content = fs.readFileSync(filePath, "utf-8");
-    const parsed = JSON.parse(content);
-    return parsed;
-}
-export function getExamplePath(...parts) {
-    return path.join(examplesDir, ...parts);
-}
-export function createTestDocument(overrides = {}) {
-    const base = {
-        unispecVersion: "1.0.0",
-        service: {
-            name: "test-service",
-            description: "Test service description",
-            protocols: {
-                rest: {
-                    routes: [
-                        {
-                            name: "getUsers",
-                            summary: "Get all users",
-                            path: "/users",
-                            method: "GET",
-                            responses: {
-                                "200": { description: "Success" },
-                            },
-                        },
-                    ],
-                },
-                graphql: {
-                    queries: [
-                        {
-                            name: "users",
-                            description: "Get all users",
-                            args: [],
-                            returnType: "[User!]!",
-                        },
-                    ],
-                    mutations: [
-                        {
-                            name: "createUser",
-                            description: "Create a user",
-                            args: [],
-                            returnType: "User!",
-                        },
-                    ],
-                    schema: "type User { id: ID! name: String! }",
-                },
-                websocket: {
-                    channels: [
-                        {
-                            name: "notifications",
-                            description: "Real-time notifications",
-                            messages: [
-                                {
-                                    name: "notification",
-                                    description: "Notification message",
-                                    direction: "subscribe",
-                                },
-                            ],
-                        },
-                    ],
-                },
-            },
-        },
-    };
-    // Deep merge overrides
-    return mergeDeep(base, overrides);
-}
-function mergeDeep(target, source) {
-    const result = { ...target };
-    for (const key in source) {
-        if (source[key] !== undefined) {
-            if (typeof source[key] === "object" &&
-                source[key] !== null &&
-                !Array.isArray(source[key])) {
-                result[key] = mergeDeep(result[key], source[key]);
-            }
-            else {
-                result[key] = source[key];
-            }
-        }
-    }
-    return result;
-}
-export function createTestChange(overrides = {}) {
-    const base = {
-        path: "/test/path",
-        description: "Test change",
-        severity: "unknown",
-    };
-    return { ...base, ...overrides };
-}
-export function loadInvalidExample(filePath) {
-    const content = fs.readFileSync(filePath, "utf-8");
-    return JSON.parse(content);
-}
-export function getValidExamplePaths() {
-    const validSpecDir = path.join(examplesDir, "valid", "spec");
-    return [
-        path.join(validSpecDir, "rest-simple.json"),
-        path.join(validSpecDir, "graphql-simple.json"),
-        path.join(validSpecDir, "websocket-simple.json"),
-        path.join(validSpecDir, "mixed-complete.json"),
-    ];
-}
-export function getInvalidExamplePaths() {
-    const invalidSpecDir = path.join(examplesDir, "invalid", "spec");
-    return [
-        path.join(invalidSpecDir, "missing-unispec-version.json"),
-        path.join(invalidSpecDir, "missing-service-name.json"),
-        path.join(invalidSpecDir, "invalid-rest-method.json"),
-        path.join(invalidSpecDir, "graphql-missing-name.json"),
-        path.join(invalidSpecDir, "invalid-identifier.json"),
-    ];
-}

package/dist/tests/validator/config-validator.test.d.ts

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

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

@@ -1,73 +0,0 @@
-import assert from "node:assert";
-import { describe, it } from "node:test";
-import { validateUniSpecConfig } from "../../src/validator/index.js";
-import { loadInvalidConfigExample, loadValidConfigExample } from "./utils.js";
-describe("validateUniSpecConfig", () => {
-    describe("valid examples", () => {
-        it("should validate simple multi-service config", async () => {
-            const doc = loadValidConfigExample("simple-multi-service");
-            const result = await validateUniSpecConfig(doc);
-            assert.strictEqual(result.valid, true, "Valid multi-service config should pass validation");
-            assert.deepStrictEqual(result.errors, [], "Should have no errors");
-        });
-        it("should validate registry-based config", async () => {
-            const doc = loadValidConfigExample("registry-based");
-            const result = await validateUniSpecConfig(doc);
-            assert.strictEqual(result.valid, true, "Valid registry-based config should pass validation");
-            assert.deepStrictEqual(result.errors, [], "Should have no errors");
-        });
-        it("should validate complete enterprise config", async () => {
-            const doc = loadValidConfigExample("complete-enterprise");
-            const result = await validateUniSpecConfig(doc);
-            assert.strictEqual(result.valid, true, "Valid enterprise config should pass validation");
-            assert.deepStrictEqual(result.errors, [], "Should have no errors");
-        });
-    });
-    describe("invalid examples", () => {
-        it("should reject config missing services", async () => {
-            const doc = loadInvalidConfigExample("missing-services");
-            const result = await validateUniSpecConfig(doc);
-            assert.strictEqual(result.valid, false, "Config without services should fail validation");
-            assert.ok(result.errors.length > 0, "Should have validation errors");
-            // Check that error mentions missing required property
-            const hasServicesError = result.errors.some((error) => error.message?.includes("services"));
-            assert.ok(hasServicesError, "Should have error about missing services");
-        });
-        it("should reject config with empty services array", async () => {
-            const doc = loadInvalidConfigExample("empty-services-array");
-            const result = await validateUniSpecConfig(doc);
-            assert.strictEqual(result.valid, false, "Config with empty services array should fail validation");
-            assert.ok(result.errors.length > 0, "Should have validation errors");
-        });
-        it("should reject config missing version", async () => {
-            const doc = loadInvalidConfigExample("missing-version");
-            const result = await validateUniSpecConfig(doc);
-            assert.strictEqual(result.valid, false, "Config without version should fail validation");
-            assert.ok(result.errors.length > 0, "Should have validation errors");
-        });
-        it("should reject config with invalid spec reference", async () => {
-            const doc = loadInvalidConfigExample("invalid-spec-reference");
-            const result = await validateUniSpecConfig(doc);
-            assert.strictEqual(result.valid, false, "Config with invalid spec reference should fail validation");
-            assert.ok(result.errors.length > 0, "Should have validation errors");
-        });
-        it("should reject config missing service name", async () => {
-            const doc = loadInvalidConfigExample("missing-service-name");
-            const result = await validateUniSpecConfig(doc);
-            assert.strictEqual(result.valid, false, "Config without service name should fail validation");
-            assert.ok(result.errors.length > 0, "Should have validation errors");
-        });
-    });
-    describe("edge cases", () => {
-        it("should reject null input", async () => {
-            const result = await validateUniSpecConfig(null);
-            assert.strictEqual(result.valid, false, "Null input should fail validation");
-            assert.ok(result.errors.length > 0, "Should have validation errors");
-        });
-        it("should reject undefined input", async () => {
-            const result = await validateUniSpecConfig(undefined);
-            assert.strictEqual(result.valid, false, "Undefined input should fail validation");
-            assert.ok(result.errors.length > 0, "Should have validation errors");
-        });
-    });
-});

package/dist/tests/validator/debug-config.js

@@ -1 +0,0 @@
-"use strict";

package/dist/tests/validator/debug-missing-service.js

@@ -1 +0,0 @@
-"use strict";

package/dist/tests/validator/debug-other-configs.js

@@ -1 +0,0 @@
-"use strict";

package/dist/tests/validator/debug-references.js

@@ -1 +0,0 @@
-"use strict";

package/dist/tests/validator/unispec-validator.test.d.ts

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