@unispechq/unispec-core 0.3.2 → 0.3.4

package/dist/tests/errors/errors.test.js

@@ -1,275 +0,0 @@
-import assert from "node:assert";
-import { describe, it } from "node:test";
-import { ErrorFactory, UniSpecConfigError, UniSpecLoaderError, UniSpecReferenceError, UniSpecSchemaError, UniSpecSecurityError, UniSpecSemanticError, UniSpecValidationError, } from "../../src/errors/index.js";
-import { getExamplePath, loadExample, loadInvalidExample } from "./utils.js";
-describe("errors module", () => {
-    describe("UniSpecValidationError", () => {
-        it("should create basic validation error", () => {
-            const error = new UniSpecValidationError("Test error message", "test_code", "/test/path", "error", { detail: "test detail" });
-            assert.strictEqual(error.message, "Test error message");
-            assert.strictEqual(error.code, "test_code");
-            assert.strictEqual(error.path, "/test/path");
-            assert.strictEqual(error.severity, "error");
-            assert.deepStrictEqual(error.details, { detail: "test detail" });
-            assert.strictEqual(error.name, "UniSpecValidationError");
-        });
-        it("should create error with default values", () => {
-            const error = new UniSpecValidationError("Test message", "test_code");
-            assert.strictEqual(error.message, "Test message");
-            assert.strictEqual(error.code, "test_code");
-            assert.strictEqual(error.path, "");
-            assert.strictEqual(error.severity, "error");
-            assert.strictEqual(error.details, undefined);
-        });
-        it("should serialize to JSON correctly", () => {
-            const error = new UniSpecValidationError("Test message", "test_code", "/path", "warning", { test: "value" });
-            const json = error.toJSON();
-            assert.strictEqual(json.name, "UniSpecValidationError");
-            assert.strictEqual(json.message, "Test message");
-            assert.strictEqual(json.code, "test_code");
-            assert.strictEqual(json.path, "/path");
-            assert.strictEqual(json.severity, "warning");
-            assert.deepStrictEqual(json.details, { test: "value" });
-            assert.ok(json.stack);
-        });
-    });
-    describe("Specific error types", () => {
-        it("should create UniSpecConfigError", () => {
-            const error = new UniSpecConfigError("Configuration error", "/config/path", { configKey: "test" });
-            assert.strictEqual(error.name, "UniSpecConfigError");
-            assert.strictEqual(error.code, "config_error");
-            assert.strictEqual(error.message, "Configuration error");
-            assert.strictEqual(error.path, "/config/path");
-            assert.deepStrictEqual(error.details, { configKey: "test" });
-        });
-        it("should create UniSpecLoaderError", () => {
-            const error = new UniSpecLoaderError("Loader error", "/loader/path", {
-                fileType: "yaml",
-            });
-            assert.strictEqual(error.name, "UniSpecLoaderError");
-            assert.strictEqual(error.code, "loader_error");
-            assert.strictEqual(error.message, "Loader error");
-            assert.strictEqual(error.path, "/loader/path");
-            assert.deepStrictEqual(error.details, { fileType: "yaml" });
-        });
-        it("should create UniSpecReferenceError", () => {
-            const error = new UniSpecReferenceError("Reference error", "/ref/path", {
-                reference: "invalid-ref",
-            });
-            assert.strictEqual(error.name, "UniSpecReferenceError");
-            assert.strictEqual(error.code, "reference_error");
-            assert.strictEqual(error.message, "Reference error");
-            assert.strictEqual(error.path, "/ref/path");
-            assert.deepStrictEqual(error.details, { reference: "invalid-ref" });
-        });
-        it("should create UniSpecSchemaError", () => {
-            const error = new UniSpecSchemaError("Schema validation error", "/schema/path", { schemaPath: "service.name" });
-            assert.strictEqual(error.name, "UniSpecSchemaError");
-            assert.strictEqual(error.code, "schema_error");
-            assert.strictEqual(error.message, "Schema validation error");
-            assert.strictEqual(error.path, "/schema/path");
-            assert.deepStrictEqual(error.details, { schemaPath: "service.name" });
-        });
-        it("should create UniSpecSecurityError", () => {
-            const error = new UniSpecSecurityError("Security violation", "/security/path", { violation: "insecure_protocol" });
-            assert.strictEqual(error.name, "UniSpecSecurityError");
-            assert.strictEqual(error.code, "security_error");
-            assert.strictEqual(error.message, "Security violation");
-            assert.strictEqual(error.path, "/security/path");
-            assert.deepStrictEqual(error.details, { violation: "insecure_protocol" });
-        });
-        it("should create UniSpecSemanticError", () => {
-            const error = new UniSpecSemanticError("Semantic error", "/semantic/path", { semanticIssue: "duplicate_name" });
-            assert.strictEqual(error.name, "UniSpecSemanticError");
-            assert.strictEqual(error.code, "semantic_error");
-            assert.strictEqual(error.message, "Semantic error");
-            assert.strictEqual(error.path, "/semantic/path");
-            assert.deepStrictEqual(error.details, {
-                semanticIssue: "duplicate_name",
-            });
-        });
-    });
-    describe("ErrorFactory", () => {
-        it("should create schema error via factory", () => {
-            const error = ErrorFactory.createSchemaError("Schema error", "/path", {
-                detail: "test",
-            });
-            assert.ok(error instanceof UniSpecSchemaError);
-            assert.strictEqual(error.message, "Schema error");
-            assert.strictEqual(error.path, "/path");
-            assert.deepStrictEqual(error.details, { detail: "test" });
-        });
-        it("should create semantic error via factory", () => {
-            const error = ErrorFactory.createSemanticError("Semantic error", "/path", { detail: "test" });
-            assert.ok(error instanceof UniSpecSemanticError);
-            assert.strictEqual(error.message, "Semantic error");
-            assert.strictEqual(error.path, "/path");
-        });
-        it("should create reference error via factory", () => {
-            const error = ErrorFactory.createReferenceError("Reference error", "/path", { detail: "test" });
-            assert.ok(error instanceof UniSpecReferenceError);
-            assert.strictEqual(error.message, "Reference error");
-            assert.strictEqual(error.path, "/path");
-        });
-        it("should create config error via factory", () => {
-            const error = ErrorFactory.createConfigError("Config error", "/path", {
-                detail: "test",
-            });
-            assert.ok(error instanceof UniSpecConfigError);
-            assert.strictEqual(error.message, "Config error");
-            assert.strictEqual(error.path, "/path");
-        });
-        it("should create security error via factory", () => {
-            const error = ErrorFactory.createSecurityError("Security error", "/path", { detail: "test" });
-            assert.ok(error instanceof UniSpecSecurityError);
-            assert.strictEqual(error.message, "Security error");
-            assert.strictEqual(error.path, "/path");
-        });
-        it("should create loader error via factory", () => {
-            const error = ErrorFactory.createLoaderError("Loader error", "/path", {
-                detail: "test",
-            });
-            assert.ok(error instanceof UniSpecLoaderError);
-            assert.strictEqual(error.message, "Loader error");
-            assert.strictEqual(error.path, "/path");
-        });
-        describe("fromError method", () => {
-            it("should return UniSpecValidationError as-is", () => {
-                const originalError = new UniSpecValidationError("Original error", "original_code");
-                const converted = ErrorFactory.fromError(originalError);
-                assert.strictEqual(converted, originalError);
-            });
-            it("should convert Error to UniSpecValidationError", () => {
-                const originalError = new Error("Original error");
-                const converted = ErrorFactory.fromError(originalError);
-                assert.ok(converted instanceof UniSpecValidationError);
-                assert.strictEqual(converted.message, "Original error");
-                assert.strictEqual(converted.code, "validation_error");
-                assert.deepStrictEqual(converted.details, {
-                    originalError: "Error",
-                    stack: originalError.stack,
-                });
-            });
-            it("should convert string to UniSpecValidationError", () => {
-                const originalError = "String error";
-                const converted = ErrorFactory.fromError(originalError);
-                assert.ok(converted instanceof UniSpecValidationError);
-                assert.strictEqual(converted.message, "String error");
-                assert.strictEqual(converted.code, "validation_error");
-            });
-            it("should convert unknown object to UniSpecValidationError", () => {
-                const originalError = { some: "object" };
-                const converted = ErrorFactory.fromError(originalError);
-                assert.ok(converted instanceof UniSpecValidationError);
-                assert.strictEqual(converted.message, "Unknown validation error: [object Object]");
-                assert.strictEqual(converted.code, "validation_error");
-                assert.deepStrictEqual(converted.details, { originalError });
-            });
-            it("should use custom default code", () => {
-                const originalError = new Error("Custom error");
-                const converted = ErrorFactory.fromError(originalError, "custom_code");
-                assert.strictEqual(converted.code, "custom_code");
-            });
-        });
-    });
-    describe("Error handling with schema examples", () => {
-        it("should handle valid examples without errors", () => {
-            const validDoc = loadExample(getExamplePath("valid", "spec", "rest-simple.json"));
-            // This should not throw - valid document should load successfully
-            assert.ok(validDoc);
-            assert.ok(validDoc.unispecVersion);
-            assert.ok(validDoc.service);
-        });
-        it("should create appropriate errors for invalid examples", () => {
-            const invalidDoc = loadInvalidExample(getExamplePath("invalid", "spec", "missing-service-name.json"));
-            // Invalid document should be missing required fields
-            assert.ok(invalidDoc);
-            assert.ok(!invalidDoc.service?.name);
-            // Test creating appropriate error for this case
-            const error = ErrorFactory.createSchemaError("Missing required service name", "service.name", { required: true, found: undefined });
-            assert.ok(error instanceof UniSpecSchemaError);
-            assert.strictEqual(error.path, "service.name");
-            assert.deepStrictEqual(error.details, {
-                required: true,
-                found: undefined,
-            });
-        });
-        it("should handle missing version errors", () => {
-            const invalidDoc = loadInvalidExample(getExamplePath("invalid", "spec", "missing-unispec-version.json"));
-            assert.ok(invalidDoc);
-            assert.ok(!invalidDoc.unispecVersion);
-            const error = ErrorFactory.createSchemaError("Missing required unispecVersion", "unispecVersion", { required: true, found: undefined });
-            assert.ok(error instanceof UniSpecSchemaError);
-            assert.strictEqual(error.path, "unispecVersion");
-        });
-        it("should handle invalid REST method errors", () => {
-            const invalidDoc = loadInvalidExample(getExamplePath("invalid", "spec", "invalid-rest-method.json"));
-            assert.ok(invalidDoc);
-            // Extract method value safely for testing
-            const doc = invalidDoc;
-            const service = doc.service;
-            const protocols = service?.protocols;
-            const rest = protocols?.rest;
-            const routes = rest?.routes;
-            const firstRoute = routes?.[0];
-            const error = ErrorFactory.createSemanticError("Invalid HTTP method", "service.protocols.rest.routes[0].method", { method: firstRoute?.method });
-            assert.ok(error instanceof UniSpecSemanticError);
-            assert.strictEqual(error.path, "service.protocols.rest.routes[0].method");
-        });
-        it("should handle config errors", () => {
-            const invalidConfig = loadInvalidExample(getExamplePath("invalid", "config", "missing-version.json"));
-            assert.ok(invalidConfig);
-            assert.ok(!invalidConfig.version);
-            const error = ErrorFactory.createConfigError("Missing required version in config", "version", { required: true });
-            assert.ok(error instanceof UniSpecConfigError);
-            assert.strictEqual(error.path, "version");
-        });
-        it("should handle loader errors for malformed examples", () => {
-            // Simulate a loader error
-            const error = ErrorFactory.createLoaderError("Failed to parse YAML file", "/path/to/file.yaml", { line: 5, column: 10, reason: "invalid indentation" });
-            assert.ok(error instanceof UniSpecLoaderError);
-            assert.strictEqual(error.path, "/path/to/file.yaml");
-            assert.deepStrictEqual(error.details, {
-                line: 5,
-                column: 10,
-                reason: "invalid indentation",
-            });
-        });
-        it("should handle security errors", () => {
-            const error = ErrorFactory.createSecurityError("Insecure protocol detected", "service.protocols.rest.routes[0].scheme", { protocol: "http", recommended: "https" });
-            assert.ok(error instanceof UniSpecSecurityError);
-            assert.strictEqual(error.path, "service.protocols.rest.routes[0].scheme");
-            assert.deepStrictEqual(error.details, {
-                protocol: "http",
-                recommended: "https",
-            });
-        });
-        it("should handle reference errors", () => {
-            const error = ErrorFactory.createReferenceError("Undefined type reference", "service.protocols.rest.routes[0].responses[200].schema", { reference: "NonExistentType", availableTypes: ["User", "Post"] });
-            assert.ok(error instanceof UniSpecReferenceError);
-            assert.strictEqual(error.path, "service.protocols.rest.routes[0].responses[200].schema");
-            assert.deepStrictEqual(error.details, {
-                reference: "NonExistentType",
-                availableTypes: ["User", "Post"],
-            });
-        });
-    });
-    describe("Error edge cases", () => {
-        it("should handle errors with empty paths", () => {
-            const error = new UniSpecValidationError("Test", "test");
-            assert.strictEqual(error.path, "");
-        });
-        it("should handle errors with no details", () => {
-            const error = new UniSpecValidationError("Test", "test", "/path");
-            assert.strictEqual(error.details, undefined);
-        });
-        it("should handle warning severity", () => {
-            const error = new UniSpecValidationError("Warning message", "warning_code", "/path", "warning");
-            assert.strictEqual(error.severity, "warning");
-        });
-        it("should handle info severity", () => {
-            const error = new UniSpecValidationError("Info message", "info_code", "/path", "info");
-            assert.strictEqual(error.severity, "info");
-        });
-    });
-});

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

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

package/dist/tests/errors/utils.js

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

package/dist/tests/loader/integration.test.d.ts

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

package/dist/tests/loader/integration.test.js

@@ -1,211 +0,0 @@
-import assert from "node:assert";
-import fs from "node:fs";
-import { describe, it } from "node:test";
-import { loadUniSpec, validateDocumentSecurity } from "../../src/loader/index.js";
-import { getExamplePath } from "../diff/utils.js";
-describe("loader integration tests", () => {
-    describe("real examples from @unispechq/unispec-schema", () => {
-        it("should load all valid spec examples", async () => {
-            const validExamples = [
-                "valid/spec/rest-simple.json",
-                "valid/spec/graphql-simple.json",
-                "valid/spec/websocket-simple.json",
-                "valid/spec/mixed-complete.json",
-            ];
-            for (const example of validExamples) {
-                const examplePath = getExamplePath(...example.split("/"));
-                const content = fs.readFileSync(examplePath, "utf-8");
-                const result = await loadUniSpec(content);
-                // Basic structure validation
-                assert.ok(result.unispecVersion, `Missing unispecVersion in ${example}`);
-                assert.ok(result.service, `Missing service in ${example}`);
-                assert.ok(result.service.name, `Missing service.name in ${example}`);
-                assert.ok(result.service.protocols, `Missing service.protocols in ${example}`);
-            }
-        });
-        it("should parse invalid examples but not validate them", async () => {
-            const invalidExamples = [
-                "invalid/spec/missing-service-name.json",
-                "invalid/spec/missing-unispec-version.json",
-                "invalid/spec/invalid-identifier.json",
-                "invalid/spec/invalid-rest-method.json",
-                "invalid/spec/graphql-missing-arg-type.json",
-                "invalid/spec/graphql-missing-name.json",
-            ];
-            for (const example of invalidExamples) {
-                const examplePath = getExamplePath(...example.split("/"));
-                const content = fs.readFileSync(examplePath, "utf-8");
-                // Should parse successfully (loader only handles parsing)
-                const result = await loadUniSpec(content);
-                // Should be an object
-                assert.ok(typeof result === "object", `Failed to parse ${example}`);
-            }
-        });
-        it("should handle config examples", async () => {
-            const configExamples = [
-                "valid/config/complete-enterprise.json",
-                "valid/config/registry-based.json",
-                "valid/config/simple-multi-service.json",
-            ];
-            for (const example of configExamples) {
-                const examplePath = getExamplePath(...example.split("/"));
-                const content = fs.readFileSync(examplePath, "utf-8");
-                const result = await loadUniSpec(content);
-                // Config examples should have version
-                assert.ok(result.version, `Missing version in config ${example}`);
-            }
-        });
-        it("should handle invalid config examples", async () => {
-            const invalidConfigExamples = [
-                "invalid/config/empty-services-array.json",
-                "invalid/config/invalid-spec-reference.json",
-                "invalid/config/missing-service-name.json",
-                "invalid/config/missing-services.json",
-                "invalid/config/missing-version.json",
-            ];
-            for (const example of invalidConfigExamples) {
-                const examplePath = getExamplePath(...example.split("/"));
-                const content = fs.readFileSync(examplePath, "utf-8");
-                // Should parse successfully
-                const result = await loadUniSpec(content);
-                assert.ok(typeof result === "object", `Failed to parse ${example}`);
-            }
-        });
-    });
-    describe("security validation with real examples", () => {
-        it("should validate security of complex examples", () => {
-            const complexExamplePath = getExamplePath("valid", "spec", "mixed-complete.json");
-            const content = fs.readFileSync(complexExamplePath, "utf-8");
-            const parsed = JSON.parse(content);
-            // Should pass default security validation
-            validateDocumentSecurity(parsed, {
-                maxDepth: 100,
-                maxKeys: 10000,
-                allowedTags: ["str", "int", "float", "bool", "null", "seq", "map"],
-                maxDocumentSize: 10 * 1024 * 1024,
-                strictYamlTags: false,
-            });
-        });
-        it("should detect depth violations in nested examples", () => {
-            // Create a deeply nested version of a valid example
-            const deepExample = {
-                unispecVersion: "1.0.0",
-                service: {
-                    name: "test",
-                },
-            };
-            let current = deepExample;
-            for (let i = 0; i < 105; i++) {
-                current.nested = {};
-                current = current.nested;
-            }
-            try {
-                validateDocumentSecurity(deepExample, {
-                    maxDepth: 100,
-                    maxKeys: 10000,
-                    allowedTags: ["str", "int", "float", "bool", "null", "seq", "map"],
-                    maxDocumentSize: 10 * 1024 * 1024,
-                    strictYamlTags: false,
-                });
-                assert.fail("Should have thrown depth error");
-            }
-            catch (error) {
-                assert.ok(error instanceof Error);
-                assert.ok(error.message.includes("depth"));
-            }
-        });
-    });
-    describe("yaml parsing edge cases", () => {
-        it("should handle YAML with special characters", async () => {
-            const yamlWithSpecialChars = `
-unispecVersion: "1.0.0"
-service:
-  name: "测试服务"
-  description: "Service with emojis 🚀 and special chars"
-  protocols:
-    rest:
-      routes:
-        - name: "getUser"
-          path: "/users/{id}"
-          method: "GET"
-          responses:
-            "200":
-              description: "Success ✅"
-`;
-            const result = await loadUniSpec(yamlWithSpecialChars);
-            assert.strictEqual(result.service.name, "测试服务");
-            assert.ok(result.service.description?.includes("🚀"));
-        });
-        it("should handle YAML with anchors and references", async () => {
-            const yamlWithAnchors = `
-unispecVersion: "1.0.0"
-service:
-  name: "test-service"
-  protocols:
-    rest:
-      routes:
-        - name: "route1"
-          method: "GET"
-          path: "/path1"
-          responses: &common-responses
-            "200":
-              description: "Success"
-        - name: "route2" 
-          method: "POST"
-          path: "/path2"
-          responses: *common-responses
-`;
-            const result = await loadUniSpec(yamlWithAnchors);
-            assert.strictEqual(result.service.protocols?.rest?.routes?.length, 2);
-        });
-        it("should reject YAML with security issues", async () => {
-            const yamlWithSecurityIssue = `
-unispecVersion: "1.0.0"
-service:
-  name: "test"
-  protocols: !!js/function >
-    function() { return require('fs').readFileSync('/etc/passwd') }
-`;
-            try {
-                await loadUniSpec(yamlWithSecurityIssue);
-                // If it doesn't throw, that's actually fine - the FAILSAFE_SCHEMA should block this
-            }
-            catch (error) {
-                // Should either parse safely or throw a security-related error
-                assert.ok(error instanceof Error);
-            }
-        });
-    });
-    describe("performance with large examples", () => {
-        it("should handle large documents efficiently", async () => {
-            // Create a large UniSpec document
-            const largeDoc = {
-                unispecVersion: "1.0.0",
-                service: {
-                    name: "large-service",
-                    protocols: {
-                        rest: {
-                            routes: [],
-                        },
-                    },
-                },
-            };
-            // Add many routes
-            for (let i = 0; i < 1000; i++) {
-                largeDoc.service.protocols.rest.routes.push({
-                    name: `route${i}`,
-                    path: `/route${i}`,
-                    method: "GET",
-                    responses: {
-                        "200": { description: `Response ${i}` },
-                    },
-                });
-            }
-            const startTime = Date.now();
-            const result = await loadUniSpec(largeDoc);
-            const endTime = Date.now();
-            assert.strictEqual(result.service.protocols?.rest?.routes?.length, 1000);
-            assert.ok(endTime - startTime < 1000, "Loading should complete within 1 second");
-        });
-    });
-});

package/dist/tests/loader/loader.test.d.ts

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