@unispechq/unispec-core 0.2.8 → 0.2.10

package/dist/cjs/index.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./types/index.js"), exports);
 __exportStar(require("./loader/index.js"), exports);
 __exportStar(require("./validator/index.js"), exports);
+__exportStar(require("./schemas/index.js"), exports);
 __exportStar(require("./normalizer/index.js"), exports);
 __exportStar(require("./diff/index.js"), exports);
 __exportStar(require("./converters/index.js"), exports);

package/dist/cjs/schemas/index.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSchemaRef = resolveSchemaRef;
+exports.registerSchema = registerSchema;
+exports.dedupeSchemas = dedupeSchemas;
+function normalizeSchemaRef(ref) {
+    const trimmed = ref.trim();
+    if (trimmed.length === 0)
+        return "";
+    const withoutHash = trimmed.startsWith("#") ? trimmed.slice(1) : trimmed;
+    const parts = withoutHash.split("/").filter(Boolean);
+    return parts.length > 0 ? parts[parts.length - 1] : withoutHash;
+}
+function stableStringify(value) {
+    if (value === null)
+        return "null";
+    const t = typeof value;
+    if (t === "number" || t === "boolean")
+        return JSON.stringify(value);
+    if (t === "string")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(stableStringify).join(",")}]`;
+    if (t !== "object")
+        return JSON.stringify(value);
+    const obj = value;
+    const keys = Object.keys(obj).sort();
+    const entries = keys.map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`);
+    return `{${entries.join(",")}}`;
+}
+function resolveSchemaRef(doc, ref) {
+    const name = normalizeSchemaRef(ref);
+    if (!name)
+        return undefined;
+    return doc.schemas?.[name];
+}
+function registerSchema(doc, name, jsonSchema) {
+    if (!doc.schemas) {
+        doc.schemas = {};
+    }
+    const definition = {
+        jsonSchema,
+    };
+    doc.schemas[name] = definition;
+    return definition;
+}
+function updateSchemaRefs(doc, mapping) {
+    const rest = doc.protocols?.rest;
+    const websocket = doc.protocols?.websocket;
+    if (rest?.routes) {
+        for (const route of rest.routes) {
+            for (const params of [route.pathParams, route.queryParams, route.headers]) {
+                if (!params)
+                    continue;
+                for (const p of params) {
+                    if (!p.schemaRef)
+                        continue;
+                    const key = normalizeSchemaRef(p.schemaRef);
+                    const next = mapping[key];
+                    if (next && next !== key)
+                        p.schemaRef = next;
+                }
+            }
+            const requestContent = route.requestBody?.content;
+            if (requestContent) {
+                for (const media of Object.values(requestContent)) {
+                    if (!media.schemaRef)
+                        continue;
+                    const key = normalizeSchemaRef(media.schemaRef);
+                    const next = mapping[key];
+                    if (next && next !== key)
+                        media.schemaRef = next;
+                }
+            }
+            const responses = route.responses;
+            if (responses) {
+                for (const resp of Object.values(responses)) {
+                    const respContent = resp.content;
+                    if (!respContent)
+                        continue;
+                    for (const media of Object.values(respContent)) {
+                        if (!media.schemaRef)
+                            continue;
+                        const key = normalizeSchemaRef(media.schemaRef);
+                        const next = mapping[key];
+                        if (next && next !== key)
+                            media.schemaRef = next;
+                    }
+                }
+            }
+        }
+    }
+    if (websocket?.channels) {
+        for (const channel of websocket.channels) {
+            if (!channel.messages)
+                continue;
+            for (const message of channel.messages) {
+                if (!message.schemaRef)
+                    continue;
+                const key = normalizeSchemaRef(message.schemaRef);
+                const next = mapping[key];
+                if (next && next !== key)
+                    message.schemaRef = next;
+            }
+        }
+    }
+}
+function dedupeSchemas(doc) {
+    if (!doc.schemas)
+        return;
+    const names = Object.keys(doc.schemas);
+    const hashToName = new Map();
+    const renameMap = {};
+    for (const name of names) {
+        const schema = doc.schemas[name];
+        const hash = stableStringify(schema?.jsonSchema ?? null);
+        const existing = hashToName.get(hash);
+        if (!existing) {
+            hashToName.set(hash, name);
+            continue;
+        }
+        renameMap[name] = existing;
+    }
+    const duplicates = Object.keys(renameMap);
+    if (duplicates.length === 0)
+        return;
+    updateSchemaRefs(doc, renameMap);
+    for (const dup of duplicates) {
+        delete doc.schemas[dup];
+    }
+}

package/dist/cjs/validator/index.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -6,32 +39,91 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateUniSpec = validateUniSpec;
 exports.validateUniSpecTests = validateUniSpecTests;
 const _2020_js_1 = __importDefault(require("ajv/dist/2020.js"));
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const unispec_schema_1 = require("@unispechq/unispec-schema");
-const ajv = new _2020_js_1.default({
-    allErrors: true,
-    strict: true,
-});
-// Register minimal URI format to satisfy UniSpec schemas (service.environments[*].baseUrl)
-ajv.addFormat("uri", true);
-// Register all UniSpec subschemas so that Ajv can resolve internal $ref links
-try {
-    const schemaDir = path_1.default.join(process.cwd(), "node_modules", "@unispechq", "unispec-schema", "schema");
-    const types = unispec_schema_1.manifest?.types ?? {};
+let cached = null;
+async function tryCreateNodeSchemaProvider() {
+    try {
+        const fs = await Promise.resolve().then(() => __importStar(require("node:fs/promises")));
+        const path = await Promise.resolve().then(() => __importStar(require("node:path")));
+        const module = await Promise.resolve().then(() => __importStar(require("node:module")));
+        const requireBasePath = typeof __filename === "string" && __filename.length > 0
+            ? __filename
+            : path.join(process.cwd(), "__unispec_core_require__.js");
+        const require = module.createRequire(requireBasePath);
+        const schemaIndexPath = require.resolve("@unispechq/unispec-schema/schema");
+        const schemaRoot = path.dirname(schemaIndexPath);
+        return {
+            getSchema: async (schemaPath) => {
+                const fullPath = path.join(schemaRoot, schemaPath);
+                const json = await fs.readFile(fullPath, "utf8");
+                return JSON.parse(json);
+            },
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+async function loadDefaultSchemas() {
+    const schemaProvider = await tryCreateNodeSchemaProvider();
+    if (!schemaProvider) {
+        throw new Error("UniSpec validator: default schema loading is not available in this environment. " +
+            "Provide ValidateOptions.schemas (recommended for browsers/edge runtimes) or ValidateOptions.schemaProvider.");
+    }
+    const { manifest, unispec } = (await Promise.resolve().then(() => __importStar(require("@unispechq/unispec-schema"))));
+    const types = manifest?.types ?? {};
     const typeSchemaPaths = Object.values(types).map((rel) => String(rel));
-    const loadedTypeSchemas = typeSchemaPaths
-        .map((relPath) => path_1.default.join(schemaDir, relPath))
-        .filter((filePath) => fs_1.default.existsSync(filePath))
-        .map((filePath) => JSON.parse(fs_1.default.readFileSync(filePath, "utf8")));
-    ajv.addSchema(loadedTypeSchemas);
+    const subschemas = await Promise.all(typeSchemaPaths.map(async (relPath) => {
+        try {
+            return await schemaProvider.getSchema(relPath);
+        }
+        catch {
+            return null;
+        }
+    }));
+    let unispecTests;
+    try {
+        unispecTests = await schemaProvider.getSchema("unispec-tests.schema.json");
+    }
+    catch {
+        unispecTests = undefined;
+    }
+    return {
+        unispec: unispec,
+        unispecTests,
+        subschemas: subschemas.filter((s) => Boolean(s)),
+    };
+}
+function createAjv(options) {
+    const ajv = new _2020_js_1.default({
+        allErrors: true,
+        strict: true,
+        ...(options.ajvOptions ?? {}),
+    });
+    ajv.addFormat("uri", true);
+    return ajv;
 }
-catch {
-    // If subschemas cannot be loaded for some reason, validation will still work for
-    // parts of the schema that do not rely on those $ref references.
+async function getValidator(options = {}) {
+    if (cached && !options.schemas && !options.schemaProvider && !options.ajvOptions)
+        return cached;
+    const schemas = options.schemas ?? (await loadDefaultSchemas());
+    const ajv = createAjv(options);
+    if (schemas.subschemas?.length) {
+        ajv.addSchema(schemas.subschemas);
+    }
+    const validateUniSpecFn = ajv.compile(schemas.unispec);
+    let validateUniSpecTestsFn;
+    if (schemas.unispecTests) {
+        validateUniSpecTestsFn = ajv.compile(schemas.unispecTests);
+    }
+    const result = {
+        validateUniSpecFn,
+        validateUniSpecTestsFn,
+    };
+    if (!options.schemas && !options.schemaProvider && !options.ajvOptions) {
+        cached = result;
+    }
+    return result;
 }
-const validateFn = ajv.compile(unispec_schema_1.unispec);
-let validateTestsFn;
 function mapAjvErrors(errors) {
     if (!errors)
         return [];
@@ -44,7 +136,8 @@ function mapAjvErrors(errors) {
 /**
  * Validate a UniSpec document against the UniSpec JSON Schema.
  */
-async function validateUniSpec(doc, _options = {}) {
+async function validateUniSpec(doc, options = {}) {
+    const { validateUniSpecFn } = await getValidator(options);
     const docForValidation = {
         unispecVersion: "0.0.0",
         service: {
@@ -56,7 +149,7 @@ async function validateUniSpec(doc, _options = {}) {
         },
         extensions: doc.extensions,
     };
-    const valid = validateFn(docForValidation);
+    const valid = validateUniSpecFn(docForValidation);
     if (valid) {
         return {
             valid: true,
@@ -65,20 +158,27 @@ async function validateUniSpec(doc, _options = {}) {
     }
     return {
         valid: false,
-        errors: mapAjvErrors(validateFn.errors),
+        errors: mapAjvErrors(validateUniSpecFn.errors),
     };
 }
 /**
  * Validate a UniSpec Tests document against the UniSpec Tests JSON Schema.
  */
-async function validateUniSpecTests(doc, _options = {}) {
-    if (!validateTestsFn) {
-        const schemaDir = path_1.default.join(process.cwd(), "node_modules", "@unispechq", "unispec-schema", "schema");
-        const testsSchemaPath = path_1.default.join(schemaDir, "unispec-tests.schema.json");
-        const testsSchema = JSON.parse(fs_1.default.readFileSync(testsSchemaPath, "utf8"));
-        validateTestsFn = ajv.compile(testsSchema);
+async function validateUniSpecTests(doc, options = {}) {
+    const { validateUniSpecTestsFn } = await getValidator(options);
+    if (!validateUniSpecTestsFn) {
+        return {
+            valid: false,
+            errors: [
+                {
+                    message: "UniSpec tests validation schema is not available. Provide ValidateOptions.schemas.unispecTests or a schemaProvider that can load it.",
+                    path: "",
+                    code: "schema_missing",
+                },
+            ],
+        };
     }
-    const valid = validateTestsFn(doc);
+    const valid = validateUniSpecTestsFn(doc);
     if (valid) {
         return {
             valid: true,
@@ -87,6 +187,6 @@ async function validateUniSpecTests(doc, _options = {}) {
     }
     return {
         valid: false,
-        errors: mapAjvErrors(validateTestsFn.errors),
+        errors: mapAjvErrors(validateUniSpecTestsFn.errors),
     };
 }

package/dist/index.cjs

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./types/index.js"), exports);
 __exportStar(require("./loader/index.js"), exports);
 __exportStar(require("./validator/index.js"), exports);
+__exportStar(require("./schemas/index.js"), exports);
 __exportStar(require("./normalizer/index.js"), exports);
 __exportStar(require("./diff/index.js"), exports);
 __exportStar(require("./converters/index.js"), exports);

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./types/index.js";
 export * from "./loader/index.js";
 export * from "./validator/index.js";
+export * from "./schemas/index.js";
 export * from "./normalizer/index.js";
 export * from "./diff/index.js";
 export * from "./converters/index.js";

package/dist/index.js

@@ -1,6 +1,7 @@
 export * from "./types/index.js";
 export * from "./loader/index.js";
 export * from "./validator/index.js";
+export * from "./schemas/index.js";
 export * from "./normalizer/index.js";
 export * from "./diff/index.js";
 export * from "./converters/index.js";

package/dist/schemas/index.d.ts

@@ -0,0 +1,4 @@
+import { UniSpecDocument, UniSpecSchemaDefinition } from "../types/index.js";
+export declare function resolveSchemaRef(doc: UniSpecDocument, ref: string): UniSpecSchemaDefinition | undefined;
+export declare function registerSchema(doc: UniSpecDocument, name: string, jsonSchema: Record<string, unknown>): UniSpecSchemaDefinition;
+export declare function dedupeSchemas(doc: UniSpecDocument): void;

package/dist/schemas/index.js

@@ -0,0 +1,126 @@
+function normalizeSchemaRef(ref) {
+    const trimmed = ref.trim();
+    if (trimmed.length === 0)
+        return "";
+    const withoutHash = trimmed.startsWith("#") ? trimmed.slice(1) : trimmed;
+    const parts = withoutHash.split("/").filter(Boolean);
+    return parts.length > 0 ? parts[parts.length - 1] : withoutHash;
+}
+function stableStringify(value) {
+    if (value === null)
+        return "null";
+    const t = typeof value;
+    if (t === "number" || t === "boolean")
+        return JSON.stringify(value);
+    if (t === "string")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(stableStringify).join(",")}]`;
+    if (t !== "object")
+        return JSON.stringify(value);
+    const obj = value;
+    const keys = Object.keys(obj).sort();
+    const entries = keys.map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`);
+    return `{${entries.join(",")}}`;
+}
+export function resolveSchemaRef(doc, ref) {
+    const name = normalizeSchemaRef(ref);
+    if (!name)
+        return undefined;
+    return doc.schemas?.[name];
+}
+export function registerSchema(doc, name, jsonSchema) {
+    if (!doc.schemas) {
+        doc.schemas = {};
+    }
+    const definition = {
+        jsonSchema,
+    };
+    doc.schemas[name] = definition;
+    return definition;
+}
+function updateSchemaRefs(doc, mapping) {
+    const rest = doc.protocols?.rest;
+    const websocket = doc.protocols?.websocket;
+    if (rest?.routes) {
+        for (const route of rest.routes) {
+            for (const params of [route.pathParams, route.queryParams, route.headers]) {
+                if (!params)
+                    continue;
+                for (const p of params) {
+                    if (!p.schemaRef)
+                        continue;
+                    const key = normalizeSchemaRef(p.schemaRef);
+                    const next = mapping[key];
+                    if (next && next !== key)
+                        p.schemaRef = next;
+                }
+            }
+            const requestContent = route.requestBody?.content;
+            if (requestContent) {
+                for (const media of Object.values(requestContent)) {
+                    if (!media.schemaRef)
+                        continue;
+                    const key = normalizeSchemaRef(media.schemaRef);
+                    const next = mapping[key];
+                    if (next && next !== key)
+                        media.schemaRef = next;
+                }
+            }
+            const responses = route.responses;
+            if (responses) {
+                for (const resp of Object.values(responses)) {
+                    const respContent = resp.content;
+                    if (!respContent)
+                        continue;
+                    for (const media of Object.values(respContent)) {
+                        if (!media.schemaRef)
+                            continue;
+                        const key = normalizeSchemaRef(media.schemaRef);
+                        const next = mapping[key];
+                        if (next && next !== key)
+                            media.schemaRef = next;
+                    }
+                }
+            }
+        }
+    }
+    if (websocket?.channels) {
+        for (const channel of websocket.channels) {
+            if (!channel.messages)
+                continue;
+            for (const message of channel.messages) {
+                if (!message.schemaRef)
+                    continue;
+                const key = normalizeSchemaRef(message.schemaRef);
+                const next = mapping[key];
+                if (next && next !== key)
+                    message.schemaRef = next;
+            }
+        }
+    }
+}
+export function dedupeSchemas(doc) {
+    if (!doc.schemas)
+        return;
+    const names = Object.keys(doc.schemas);
+    const hashToName = new Map();
+    const renameMap = {};
+    for (const name of names) {
+        const schema = doc.schemas[name];
+        const hash = stableStringify(schema?.jsonSchema ?? null);
+        const existing = hashToName.get(hash);
+        if (!existing) {
+            hashToName.set(hash, name);
+            continue;
+        }
+        renameMap[name] = existing;
+    }
+    const duplicates = Object.keys(renameMap);
+    if (duplicates.length === 0)
+        return;
+    updateSchemaRefs(doc, renameMap);
+    for (const dup of duplicates) {
+        delete doc.schemas[dup];
+    }
+}

package/dist/validator/index.d.ts

@@ -1,11 +1,23 @@
+import Ajv2020 from "ajv/dist/2020.js";
 import { UniSpecDocument, UniSpecTestsDocument, ValidationResult } from "../types";
+export interface SchemaProvider {
+    getSchema: (schemaPath: string) => Promise<object>;
+}
+export interface ValidatorSchemas {
+    unispec: object;
+    unispecTests?: object;
+    subschemas?: object[];
+}
 export interface ValidateOptions {
+    schemas?: ValidatorSchemas;
+    schemaProvider?: SchemaProvider;
+    ajvOptions?: ConstructorParameters<typeof Ajv2020>[0];
 }
 /**
  * Validate a UniSpec document against the UniSpec JSON Schema.
  */
-export declare function validateUniSpec(doc: UniSpecDocument, _options?: ValidateOptions): Promise<ValidationResult>;
+export declare function validateUniSpec(doc: UniSpecDocument, options?: ValidateOptions): Promise<ValidationResult>;
 /**
  * Validate a UniSpec Tests document against the UniSpec Tests JSON Schema.
  */
-export declare function validateUniSpecTests(doc: UniSpecTestsDocument, _options?: ValidateOptions): Promise<ValidationResult>;
+export declare function validateUniSpecTests(doc: UniSpecTestsDocument, options?: ValidateOptions): Promise<ValidationResult>;

package/dist/validator/index.js

@@ -1,30 +1,89 @@
 import Ajv2020 from "ajv/dist/2020.js";
-import fs from "fs";
-import path from "path";
-import { unispec as unispecSchema, manifest as unispecManifest } from "@unispechq/unispec-schema";
-const ajv = new Ajv2020({
-    allErrors: true,
-    strict: true,
-});
-// Register minimal URI format to satisfy UniSpec schemas (service.environments[*].baseUrl)
-ajv.addFormat("uri", true);
-// Register all UniSpec subschemas so that Ajv can resolve internal $ref links
-try {
-    const schemaDir = path.join(process.cwd(), "node_modules", "@unispechq", "unispec-schema", "schema");
-    const types = unispecManifest?.types ?? {};
+let cached = null;
+async function tryCreateNodeSchemaProvider() {
+    try {
+        const fs = await import("node:fs/promises");
+        const path = await import("node:path");
+        const module = await import("node:module");
+        const requireBasePath = typeof __filename === "string" && __filename.length > 0
+            ? __filename
+            : path.join(process.cwd(), "__unispec_core_require__.js");
+        const require = module.createRequire(requireBasePath);
+        const schemaIndexPath = require.resolve("@unispechq/unispec-schema/schema");
+        const schemaRoot = path.dirname(schemaIndexPath);
+        return {
+            getSchema: async (schemaPath) => {
+                const fullPath = path.join(schemaRoot, schemaPath);
+                const json = await fs.readFile(fullPath, "utf8");
+                return JSON.parse(json);
+            },
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+async function loadDefaultSchemas() {
+    const schemaProvider = await tryCreateNodeSchemaProvider();
+    if (!schemaProvider) {
+        throw new Error("UniSpec validator: default schema loading is not available in this environment. " +
+            "Provide ValidateOptions.schemas (recommended for browsers/edge runtimes) or ValidateOptions.schemaProvider.");
+    }
+    const { manifest, unispec } = (await import("@unispechq/unispec-schema"));
+    const types = manifest?.types ?? {};
     const typeSchemaPaths = Object.values(types).map((rel) => String(rel));
-    const loadedTypeSchemas = typeSchemaPaths
-        .map((relPath) => path.join(schemaDir, relPath))
-        .filter((filePath) => fs.existsSync(filePath))
-        .map((filePath) => JSON.parse(fs.readFileSync(filePath, "utf8")));
-    ajv.addSchema(loadedTypeSchemas);
+    const subschemas = await Promise.all(typeSchemaPaths.map(async (relPath) => {
+        try {
+            return await schemaProvider.getSchema(relPath);
+        }
+        catch {
+            return null;
+        }
+    }));
+    let unispecTests;
+    try {
+        unispecTests = await schemaProvider.getSchema("unispec-tests.schema.json");
+    }
+    catch {
+        unispecTests = undefined;
+    }
+    return {
+        unispec: unispec,
+        unispecTests,
+        subschemas: subschemas.filter((s) => Boolean(s)),
+    };
 }
-catch {
-    // If subschemas cannot be loaded for some reason, validation will still work for
-    // parts of the schema that do not rely on those $ref references.
+function createAjv(options) {
+    const ajv = new Ajv2020({
+        allErrors: true,
+        strict: true,
+        ...(options.ajvOptions ?? {}),
+    });
+    ajv.addFormat("uri", true);
+    return ajv;
+}
+async function getValidator(options = {}) {
+    if (cached && !options.schemas && !options.schemaProvider && !options.ajvOptions)
+        return cached;
+    const schemas = options.schemas ?? (await loadDefaultSchemas());
+    const ajv = createAjv(options);
+    if (schemas.subschemas?.length) {
+        ajv.addSchema(schemas.subschemas);
+    }
+    const validateUniSpecFn = ajv.compile(schemas.unispec);
+    let validateUniSpecTestsFn;
+    if (schemas.unispecTests) {
+        validateUniSpecTestsFn = ajv.compile(schemas.unispecTests);
+    }
+    const result = {
+        validateUniSpecFn,
+        validateUniSpecTestsFn,
+    };
+    if (!options.schemas && !options.schemaProvider && !options.ajvOptions) {
+        cached = result;
+    }
+    return result;
 }
-const validateFn = ajv.compile(unispecSchema);
-let validateTestsFn;
 function mapAjvErrors(errors) {
     if (!errors)
         return [];
@@ -37,7 +96,8 @@ function mapAjvErrors(errors) {
 /**
  * Validate a UniSpec document against the UniSpec JSON Schema.
  */
-export async function validateUniSpec(doc, _options = {}) {
+export async function validateUniSpec(doc, options = {}) {
+    const { validateUniSpecFn } = await getValidator(options);
     const docForValidation = {
         unispecVersion: "0.0.0",
         service: {
@@ -49,7 +109,7 @@ export async function validateUniSpec(doc, _options = {}) {
         },
         extensions: doc.extensions,
     };
-    const valid = validateFn(docForValidation);
+    const valid = validateUniSpecFn(docForValidation);
     if (valid) {
         return {
             valid: true,
@@ -58,20 +118,27 @@ export async function validateUniSpec(doc, _options = {}) {
     }
     return {
         valid: false,
-        errors: mapAjvErrors(validateFn.errors),
+        errors: mapAjvErrors(validateUniSpecFn.errors),
     };
 }
 /**
  * Validate a UniSpec Tests document against the UniSpec Tests JSON Schema.
  */
-export async function validateUniSpecTests(doc, _options = {}) {
-    if (!validateTestsFn) {
-        const schemaDir = path.join(process.cwd(), "node_modules", "@unispechq", "unispec-schema", "schema");
-        const testsSchemaPath = path.join(schemaDir, "unispec-tests.schema.json");
-        const testsSchema = JSON.parse(fs.readFileSync(testsSchemaPath, "utf8"));
-        validateTestsFn = ajv.compile(testsSchema);
+export async function validateUniSpecTests(doc, options = {}) {
+    const { validateUniSpecTestsFn } = await getValidator(options);
+    if (!validateUniSpecTestsFn) {
+        return {
+            valid: false,
+            errors: [
+                {
+                    message: "UniSpec tests validation schema is not available. Provide ValidateOptions.schemas.unispecTests or a schemaProvider that can load it.",
+                    path: "",
+                    code: "schema_missing",
+                },
+            ],
+        };
     }
-    const valid = validateTestsFn(doc);
+    const valid = validateUniSpecTestsFn(doc);
     if (valid) {
         return {
             valid: true,
@@ -80,6 +147,6 @@ export async function validateUniSpecTests(doc, _options = {}) {
     }
     return {
         valid: false,
-        errors: mapAjvErrors(validateTestsFn.errors),
+        errors: mapAjvErrors(validateUniSpecTestsFn.errors),
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unispechq/unispec-core",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "description": "Central UniSpec Core Engine providing parsing, validation, normalization, diffing, and conversion of UniSpec specs.",
   "license": "MIT",
   "repository": {
@@ -48,7 +48,7 @@
     "release:major": "node scripts/release.js major"
   },
   "dependencies": {
-    "@unispechq/unispec-schema": "^0.3.3",
+    "@unispechq/unispec-schema": "^0.3.4",
     "ajv": "^8.12.0"
   },
   "devDependencies": {