@unispechq/unispec-core 0.3.0 → 0.3.2

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

@@ -0,0 +1,400 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = require("node:test");
+const schemas_1 = require("../../src/schemas/index.js");
+const utils_1 = require("../../src/schemas/utils.js");
+const utils_2 = require("./utils.js");
+(0, node_test_1.describe)("schemas module", () => {
+    (0, node_test_1.describe)("normalizeSchemaRef", () => {
+        (0, node_test_1.it)("should handle simple name format", () => {
+            node_assert_1.default.strictEqual((0, utils_1.normalizeSchemaRef)("User"), "User");
+            node_assert_1.default.strictEqual((0, utils_1.normalizeSchemaRef)("CreateOrderRequest"), "CreateOrderRequest");
+        });
+        (0, node_test_1.it)("should handle JSON Pointer format", () => {
+            node_assert_1.default.strictEqual((0, utils_1.normalizeSchemaRef)("#/service/schemas/User"), "User");
+            node_assert_1.default.strictEqual((0, utils_1.normalizeSchemaRef)("#/service/schemas/CreateOrderRequest"), "CreateOrderRequest");
+        });
+        (0, node_test_1.it)("should handle hash format", () => {
+            node_assert_1.default.strictEqual((0, utils_1.normalizeSchemaRef)("#User"), "User");
+            node_assert_1.default.strictEqual((0, utils_1.normalizeSchemaRef)("#CreateOrderRequest"), "CreateOrderRequest");
+        });
+        (0, node_test_1.it)("should handle path format", () => {
+            node_assert_1.default.strictEqual((0, utils_1.normalizeSchemaRef)("path/to/User"), "User");
+            node_assert_1.default.strictEqual((0, utils_1.normalizeSchemaRef)("models/User"), "User");
+        });
+        (0, node_test_1.it)("should handle empty and whitespace strings", () => {
+            node_assert_1.default.strictEqual((0, utils_1.normalizeSchemaRef)(""), "");
+            node_assert_1.default.strictEqual((0, utils_1.normalizeSchemaRef)("   "), "");
+            node_assert_1.default.strictEqual((0, utils_1.normalizeSchemaRef)("#"), "");
+        });
+        (0, node_test_1.it)("should handle complex paths", () => {
+            node_assert_1.default.strictEqual((0, utils_1.normalizeSchemaRef)("#/service/schemas/nested/User"), "User");
+            node_assert_1.default.strictEqual((0, utils_1.normalizeSchemaRef)("deeply/nested/path/to/Schema"), "Schema");
+        });
+    });
+    (0, node_test_1.describe)("stableStringify", () => {
+        (0, node_test_1.it)("should create consistent strings for simple values", () => {
+            node_assert_1.default.strictEqual((0, utils_1.stableStringify)(null), "null");
+            node_assert_1.default.strictEqual((0, utils_1.stableStringify)(42), "42");
+            node_assert_1.default.strictEqual((0, utils_1.stableStringify)(true), "true");
+            node_assert_1.default.strictEqual((0, utils_1.stableStringify)("test"), '"test"');
+        });
+        (0, node_test_1.it)("should create consistent strings for arrays", () => {
+            node_assert_1.default.strictEqual((0, utils_1.stableStringify)([1, 2, 3]), "[1,2,3]");
+            node_assert_1.default.strictEqual((0, utils_1.stableStringify)(["b", "a"]), '["b","a"]');
+            node_assert_1.default.strictEqual((0, utils_1.stableStringify)([]), "[]");
+        });
+        (0, node_test_1.it)("should create consistent strings for objects with sorted keys", () => {
+            const obj1 = { b: 2, a: 1 };
+            const obj2 = { a: 1, b: 2 };
+            node_assert_1.default.strictEqual((0, utils_1.stableStringify)(obj1), (0, utils_1.stableStringify)(obj2));
+            node_assert_1.default.strictEqual((0, utils_1.stableStringify)(obj1), '{"a":1,"b":2}');
+        });
+        (0, node_test_1.it)("should handle nested objects", () => {
+            const nested = {
+                outer: {
+                    z: 3,
+                    a: 1,
+                },
+                b: 2,
+            };
+            node_assert_1.default.strictEqual((0, utils_1.stableStringify)(nested), '{"b":2,"outer":{"a":1,"z":3}}');
+        });
+        (0, node_test_1.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"}';
+            node_assert_1.default.strictEqual((0, utils_1.stableStringify)(complex), expected);
+        });
+    });
+    (0, node_test_1.describe)("registerSchema", () => {
+        (0, node_test_1.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 = (0, schemas_1.registerSchema)(doc, "User", jsonSchema);
+            node_assert_1.default.deepStrictEqual(definition.jsonSchema, jsonSchema);
+            node_assert_1.default.ok(doc.service?.schemas?.User);
+        });
+        (0, node_test_1.it)("should create schemas container if missing", () => {
+            const doc = {
+                unispecVersion: "1.0.0",
+                service: { name: "test-service" },
+            };
+            (0, schemas_1.registerSchema)(doc, "User", { type: "object" });
+            node_assert_1.default.ok(doc.service?.schemas);
+            node_assert_1.default.ok(doc.service.schemas.User);
+        });
+        (0, node_test_1.it)("should create service if missing", () => {
+            const doc = {
+                unispecVersion: "1.0.0",
+            };
+            (0, schemas_1.registerSchema)(doc, "User", { type: "object" });
+            node_assert_1.default.ok(doc.service);
+            node_assert_1.default.strictEqual(doc.service.name, "");
+            node_assert_1.default.ok(doc.service.schemas);
+        });
+        (0, node_test_1.it)("should overwrite existing schema", () => {
+            const doc = {
+                unispecVersion: "1.0.0",
+                service: {
+                    name: "test-service",
+                    schemas: {
+                        User: {
+                            jsonSchema: { type: "string" },
+                        },
+                    },
+                },
+            };
+            const newSchema = { type: "number" };
+            (0, schemas_1.registerSchema)(doc, "User", newSchema);
+            node_assert_1.default.deepStrictEqual(doc.service?.schemas?.User?.jsonSchema, newSchema);
+        });
+    });
+    (0, node_test_1.describe)("resolveSchemaRef", () => {
+        (0, node_test_1.it)("should resolve simple schema reference", () => {
+            const doc = (0, utils_2.loadExample)((0, utils_2.getExamplePath)("valid", "spec", "mixed-complete.json"));
+            const schema = (0, schemas_1.resolveSchemaRef)(doc, "CreateOrderRequest");
+            node_assert_1.default.ok(schema);
+            node_assert_1.default.strictEqual(schema.jsonSchema.type, "object");
+            node_assert_1.default.ok(schema?.jsonSchema.properties);
+            const properties = schema.jsonSchema.properties;
+            node_assert_1.default.ok(properties.productIds);
+        });
+        (0, node_test_1.it)("should resolve JSON Pointer reference", () => {
+            const doc = (0, utils_2.loadExample)((0, utils_2.getExamplePath)("valid", "spec", "mixed-complete.json"));
+            const schema = (0, schemas_1.resolveSchemaRef)(doc, "#/service/schemas/OrderStatusUpdate");
+            node_assert_1.default.ok(schema);
+            node_assert_1.default.strictEqual(schema.jsonSchema.type, "object");
+            node_assert_1.default.ok(schema?.jsonSchema.properties);
+            const properties = schema.jsonSchema.properties;
+            node_assert_1.default.ok(properties.status);
+        });
+        (0, node_test_1.it)("should resolve hash reference", () => {
+            const doc = (0, utils_2.loadExample)((0, utils_2.getExamplePath)("valid", "spec", "mixed-complete.json"));
+            const schema = (0, schemas_1.resolveSchemaRef)(doc, "#OrderStatusUpdate");
+            node_assert_1.default.ok(schema);
+            node_assert_1.default.strictEqual(schema.jsonSchema.type, "object");
+        });
+        (0, node_test_1.it)("should return undefined for non-existent schema", () => {
+            const doc = (0, utils_2.loadExample)((0, utils_2.getExamplePath)("valid", "spec", "mixed-complete.json"));
+            const schema = (0, schemas_1.resolveSchemaRef)(doc, "NonExistentSchema");
+            node_assert_1.default.strictEqual(schema, undefined);
+        });
+        (0, node_test_1.it)("should return undefined for empty reference", () => {
+            const doc = (0, utils_2.loadExample)((0, utils_2.getExamplePath)("valid", "spec", "mixed-complete.json"));
+            const schema = (0, schemas_1.resolveSchemaRef)(doc, "");
+            node_assert_1.default.strictEqual(schema, undefined);
+        });
+        (0, node_test_1.it)("should handle document without schemas", () => {
+            const doc = (0, utils_2.loadExample)((0, utils_2.getExamplePath)("valid", "spec", "rest-simple.json"));
+            const schema = (0, schemas_1.resolveSchemaRef)(doc, "AnySchema");
+            node_assert_1.default.strictEqual(schema, undefined);
+        });
+    });
+    (0, node_test_1.describe)("dedupeSchemas", () => {
+        (0, node_test_1.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",
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            ],
+                        },
+                    },
+                },
+            };
+            (0, schemas_1.dedupeSchemas)(doc);
+            // Should keep only one schema (the first one encountered)
+            const schemas = doc.service?.schemas;
+            node_assert_1.default.strictEqual(Object.keys(schemas || {}).length, 1);
+            node_assert_1.default.ok(schemas?.User);
+            node_assert_1.default.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];
+                node_assert_1.default.strictEqual(userRoute.responses?.["200"]?.content?.["application/json"]
+                    ?.schemaRef, "User");
+                node_assert_1.default.strictEqual(personRoute.responses?.["200"]?.content?.["application/json"]
+                    ?.schemaRef, "User");
+            }
+        });
+        (0, node_test_1.it)("should handle documents without schemas", () => {
+            const doc = (0, utils_2.loadExample)((0, utils_2.getExamplePath)("valid", "spec", "rest-simple.json"));
+            // Should not throw
+            (0, schemas_1.dedupeSchemas)(doc);
+            // Should still not have schemas
+            node_assert_1.default.strictEqual(doc.service?.schemas, undefined);
+        });
+        (0, node_test_1.it)("should handle empty schemas object", () => {
+            const doc = {
+                unispecVersion: "1.0.0",
+                service: {
+                    name: "test-service",
+                    schemas: {},
+                },
+            };
+            // Should not throw
+            (0, schemas_1.dedupeSchemas)(doc);
+            node_assert_1.default.deepStrictEqual(doc.service.schemas, {});
+        });
+        (0, node_test_1.it)("should preserve unique schemas", () => {
+            const doc = {
+                unispecVersion: "1.0.0",
+                service: {
+                    name: "test-service",
+                    schemas: {
+                        User: {
+                            jsonSchema: { type: "string" },
+                        },
+                        Product: {
+                            jsonSchema: { type: "number" },
+                        },
+                    },
+                },
+            };
+            (0, schemas_1.dedupeSchemas)(doc);
+            // Both schemas should be preserved
+            const schemas = doc.service?.schemas;
+            node_assert_1.default.strictEqual(Object.keys(schemas || {}).length, 2);
+            node_assert_1.default.ok(schemas?.User);
+            node_assert_1.default.ok(schemas?.Product);
+        });
+        (0, node_test_1.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" }],
+                                },
+                            ],
+                        },
+                    },
+                },
+            };
+            (0, schemas_1.dedupeSchemas)(doc);
+            // Should keep only SchemaA
+            const schemas = doc.service?.schemas;
+            node_assert_1.default.strictEqual(Object.keys(schemas || {}).length, 1);
+            node_assert_1.default.ok(schemas?.SchemaA);
+            const rest = doc.service?.protocols?.rest;
+            if (rest?.routes) {
+                const route = rest.routes[0];
+                node_assert_1.default.strictEqual(route.pathParams?.[0]?.schemaRef, "SchemaA");
+                node_assert_1.default.strictEqual(route.queryParams?.[0]?.schemaRef, "SchemaA");
+                node_assert_1.default.strictEqual(route.headers?.[0]?.schemaRef, "SchemaA");
+                node_assert_1.default.strictEqual(route.requestBody?.content?.["application/json"]?.schemaRef, "SchemaA");
+                node_assert_1.default.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) {
+                    node_assert_1.default.strictEqual(wsMessage.schemaRef, "SchemaA");
+                }
+            }
+        });
+    });
+    (0, node_test_1.describe)("integration with real examples", () => {
+        (0, node_test_1.it)("should handle mixed-complete example correctly", () => {
+            const doc = (0, utils_2.loadExample)((0, utils_2.getExamplePath)("valid", "spec", "mixed-complete.json"));
+            // Test resolving existing schemas
+            const createOrderSchema = (0, schemas_1.resolveSchemaRef)(doc, "CreateOrderRequest");
+            node_assert_1.default.ok(createOrderSchema?.jsonSchema.properties);
+            const createOrderProperties = createOrderSchema.jsonSchema
+                .properties;
+            node_assert_1.default.ok(createOrderProperties.productIds);
+            node_assert_1.default.ok(createOrderProperties.customerId);
+            const orderStatusSchema = (0, schemas_1.resolveSchemaRef)(doc, "OrderStatusUpdate");
+            node_assert_1.default.ok(orderStatusSchema);
+            node_assert_1.default.strictEqual(orderStatusSchema.jsonSchema.type, "object");
+            node_assert_1.default.ok(orderStatusSchema.jsonSchema.properties);
+            const orderStatusProperties = orderStatusSchema.jsonSchema
+                .properties;
+            node_assert_1.default.ok(orderStatusProperties.orderId);
+            node_assert_1.default.ok(orderStatusProperties.status);
+            // Test deduplication with no duplicates
+            const schemas = doc.service?.schemas;
+            const originalSchemaCount = Object.keys(schemas || {}).length;
+            (0, schemas_1.dedupeSchemas)(doc);
+            node_assert_1.default.strictEqual(Object.keys(schemas || {}).length, originalSchemaCount);
+        });
+        (0, node_test_1.it)("should handle documents without schemas gracefully", () => {
+            const doc = (0, utils_2.loadExample)((0, utils_2.getExamplePath)("valid", "spec", "rest-simple.json"));
+            // Should not throw when resolving non-existent schemas
+            node_assert_1.default.strictEqual((0, schemas_1.resolveSchemaRef)(doc, "NonExistent"), undefined);
+            // Should not throw when deduplicating
+            (0, schemas_1.dedupeSchemas)(doc);
+            // Should still have no schemas
+            node_assert_1.default.strictEqual(doc.service?.schemas, undefined);
+        });
+    });
+});

package/dist/cjs/tests/schemas/utils.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadExample = exports.getExamplePath = exports.examplesDir = void 0;
+const utils_1 = require("../../tests/utils.js");
+Object.defineProperty(exports, "examplesDir", { enumerable: true, get: function () { return utils_1.examplesDir; } });
+Object.defineProperty(exports, "getExamplePath", { enumerable: true, get: function () { return utils_1.getExamplePath; } });
+Object.defineProperty(exports, "loadExample", { enumerable: true, get: function () { return utils_1.loadExample; } });

package/dist/cjs/tests/utils.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.examplesDir = void 0;
+exports.loadExample = loadExample;
+exports.getExamplePath = getExamplePath;
+exports.createTestDocument = createTestDocument;
+exports.createTestChange = createTestChange;
+exports.loadInvalidExample = loadInvalidExample;
+exports.getValidExamplePaths = getValidExamplePaths;
+exports.getInvalidExamplePaths = getInvalidExamplePaths;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+exports.examplesDir = node_path_1.default.join(process.cwd(), "node_modules", "@unispechq", "unispec-schema", "examples");
+function loadExample(filePath) {
+    const content = node_fs_1.default.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(content);
+    return parsed;
+}
+function getExamplePath(...parts) {
+    return node_path_1.default.join(exports.examplesDir, ...parts);
+}
+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;
+}
+function createTestChange(overrides = {}) {
+    const base = {
+        path: "/test/path",
+        description: "Test change",
+        severity: "unknown",
+    };
+    return { ...base, ...overrides };
+}
+function loadInvalidExample(filePath) {
+    const content = node_fs_1.default.readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+}
+function getValidExamplePaths() {
+    const validSpecDir = node_path_1.default.join(exports.examplesDir, "valid", "spec");
+    return [
+        node_path_1.default.join(validSpecDir, "rest-simple.json"),
+        node_path_1.default.join(validSpecDir, "graphql-simple.json"),
+        node_path_1.default.join(validSpecDir, "websocket-simple.json"),
+        node_path_1.default.join(validSpecDir, "mixed-complete.json"),
+    ];
+}
+function getInvalidExamplePaths() {
+    const invalidSpecDir = node_path_1.default.join(exports.examplesDir, "invalid", "spec");
+    return [
+        node_path_1.default.join(invalidSpecDir, "missing-unispec-version.json"),
+        node_path_1.default.join(invalidSpecDir, "missing-service-name.json"),
+        node_path_1.default.join(invalidSpecDir, "invalid-rest-method.json"),
+        node_path_1.default.join(invalidSpecDir, "graphql-missing-name.json"),
+        node_path_1.default.join(invalidSpecDir, "invalid-identifier.json"),
+    ];
+}

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

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = require("node:test");
+const validator_1 = require("../../src/validator/index.js");
+const utils_1 = require("./utils.js");
+(0, node_test_1.describe)("validateUniSpecConfig", () => {
+    (0, node_test_1.describe)("valid examples", () => {
+        (0, node_test_1.it)("should validate simple multi-service config", async () => {
+            const doc = (0, utils_1.loadValidConfigExample)("simple-multi-service");
+            const result = await (0, validator_1.validateUniSpecConfig)(doc);
+            node_assert_1.default.strictEqual(result.valid, true, "Valid multi-service config should pass validation");
+            node_assert_1.default.deepStrictEqual(result.errors, [], "Should have no errors");
+        });
+        (0, node_test_1.it)("should validate registry-based config", async () => {
+            const doc = (0, utils_1.loadValidConfigExample)("registry-based");
+            const result = await (0, validator_1.validateUniSpecConfig)(doc);
+            node_assert_1.default.strictEqual(result.valid, true, "Valid registry-based config should pass validation");
+            node_assert_1.default.deepStrictEqual(result.errors, [], "Should have no errors");
+        });
+        (0, node_test_1.it)("should validate complete enterprise config", async () => {
+            const doc = (0, utils_1.loadValidConfigExample)("complete-enterprise");
+            const result = await (0, validator_1.validateUniSpecConfig)(doc);
+            node_assert_1.default.strictEqual(result.valid, true, "Valid enterprise config should pass validation");
+            node_assert_1.default.deepStrictEqual(result.errors, [], "Should have no errors");
+        });
+    });
+    (0, node_test_1.describe)("invalid examples", () => {
+        (0, node_test_1.it)("should reject config missing services", async () => {
+            const doc = (0, utils_1.loadInvalidConfigExample)("missing-services");
+            const result = await (0, validator_1.validateUniSpecConfig)(doc);
+            node_assert_1.default.strictEqual(result.valid, false, "Config without services should fail validation");
+            node_assert_1.default.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"));
+            node_assert_1.default.ok(hasServicesError, "Should have error about missing services");
+        });
+        (0, node_test_1.it)("should reject config with empty services array", async () => {
+            const doc = (0, utils_1.loadInvalidConfigExample)("empty-services-array");
+            const result = await (0, validator_1.validateUniSpecConfig)(doc);
+            node_assert_1.default.strictEqual(result.valid, false, "Config with empty services array should fail validation");
+            node_assert_1.default.ok(result.errors.length > 0, "Should have validation errors");
+        });
+        (0, node_test_1.it)("should reject config missing version", async () => {
+            const doc = (0, utils_1.loadInvalidConfigExample)("missing-version");
+            const result = await (0, validator_1.validateUniSpecConfig)(doc);
+            node_assert_1.default.strictEqual(result.valid, false, "Config without version should fail validation");
+            node_assert_1.default.ok(result.errors.length > 0, "Should have validation errors");
+        });
+        (0, node_test_1.it)("should reject config with invalid spec reference", async () => {
+            const doc = (0, utils_1.loadInvalidConfigExample)("invalid-spec-reference");
+            const result = await (0, validator_1.validateUniSpecConfig)(doc);
+            node_assert_1.default.strictEqual(result.valid, false, "Config with invalid spec reference should fail validation");
+            node_assert_1.default.ok(result.errors.length > 0, "Should have validation errors");
+        });
+        (0, node_test_1.it)("should reject config missing service name", async () => {
+            const doc = (0, utils_1.loadInvalidConfigExample)("missing-service-name");
+            const result = await (0, validator_1.validateUniSpecConfig)(doc);
+            node_assert_1.default.strictEqual(result.valid, false, "Config without service name should fail validation");
+            node_assert_1.default.ok(result.errors.length > 0, "Should have validation errors");
+        });
+    });
+    (0, node_test_1.describe)("edge cases", () => {
+        (0, node_test_1.it)("should reject null input", async () => {
+            const result = await (0, validator_1.validateUniSpecConfig)(null);
+            node_assert_1.default.strictEqual(result.valid, false, "Null input should fail validation");
+            node_assert_1.default.ok(result.errors.length > 0, "Should have validation errors");
+        });
+        (0, node_test_1.it)("should reject undefined input", async () => {
+            const result = await (0, validator_1.validateUniSpecConfig)(undefined);
+            node_assert_1.default.strictEqual(result.valid, false, "Undefined input should fail validation");
+            node_assert_1.default.ok(result.errors.length > 0, "Should have validation errors");
+        });
+    });
+});

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

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

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

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

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

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

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

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