@unispechq/unispec-core 0.2.8 → 0.2.9

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/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.9",
   "description": "Central UniSpec Core Engine providing parsing, validation, normalization, diffing, and conversion of UniSpec specs.",
   "license": "MIT",
   "repository": {