npm - @unispechq/unispec-core - Versions diffs - 0.2.3 → 0.2.5 - Mend

@unispechq/unispec-core 0.2.3 → 0.2.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/cjs/validator/index.js +90 -26
package/dist/validator/index.d.ts +1 -0
package/dist/validator/index.js +90 -26
package/package.json +1 -1

package/dist/cjs/validator/index.js CHANGED Viewed

@@ -8,30 +8,98 @@ 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 module_1 = require("module");
+const url_1 = require("url");
 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");
+function getThisModuleUrl() {
+    if (typeof __filename === "string" && __filename.length > 0) {
+        return (0, url_1.pathToFileURL)(__filename).href;
+    }
+    const stack = new Error().stack ?? "";
+    const fileUrlMatch = stack.match(/file:\/\/\/[^\s)]+/);
+    if (fileUrlMatch?.[0]) {
+        return fileUrlMatch[0];
+    }
+    const winPathMatch = stack.match(/[A-Za-z]:\\[^\s)]+/);
+    if (winPathMatch?.[0]) {
+        return (0, url_1.pathToFileURL)(winPathMatch[0]).href;
+    }
+    throw new Error("Cannot determine current module URL for createRequire()");
+}
+function getLocalRequire() {
+    if (typeof require !== "undefined") {
+        return require;
+    }
+    return (0, module_1.createRequire)(getThisModuleUrl());
+}
+function findPackageRoot(startFilePath) {
+    let dir = path_1.default.dirname(startFilePath);
+    for (let i = 0; i < 50; i++) {
+        const pkgJsonPath = path_1.default.join(dir, "package.json");
+        if (fs_1.default.existsSync(pkgJsonPath)) {
+            return dir;
+        }
+        const parent = path_1.default.dirname(dir);
+        if (parent === dir) {
+            break;
+        }
+        dir = parent;
+    }
+    throw new Error(`Cannot locate package.json for resolved path: ${startFilePath}`);
+}
+function getUniSpecSchemaDir(options = {}) {
+    const override = options.schemaDir ?? process.env.UNISPEC_SCHEMA_DIR;
+    if (override) {
+        return override;
+    }
+    const localRequire = getLocalRequire();
+    try {
+        const pkgJsonPath = localRequire.resolve("@unispechq/unispec-schema/package.json");
+        return path_1.default.join(path_1.default.dirname(pkgJsonPath), "schema");
+    }
+    catch {
+        const entryPath = localRequire.resolve("@unispechq/unispec-schema");
+        const pkgRoot = findPackageRoot(entryPath);
+        return path_1.default.join(pkgRoot, "schema");
+    }
+}
+const validatorCache = new Map();
+function getCompiledValidator(options = {}) {
+    const schemaDir = getUniSpecSchemaDir(options);
+    const cached = validatorCache.get(schemaDir);
+    if (cached) {
+        return cached;
+    }
+    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
     const types = unispec_schema_1.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);
-}
-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.
+    for (const relPath of typeSchemaPaths) {
+        const filePath = path_1.default.join(schemaDir, relPath);
+        if (!fs_1.default.existsSync(filePath)) {
+            continue;
+        }
+        const schema = JSON.parse(fs_1.default.readFileSync(filePath, "utf8"));
+        const normalizedRelPath = String(relPath).replace(/^\.\//, "");
+        const fallbackId = `https://unispec.dev/schema/${normalizedRelPath}`;
+        ajv.addSchema(schema, fallbackId);
+    }
+    const validateFn = ajv.compile(unispec_schema_1.unispec);
+    const testsSchemaPath = path_1.default.join(schemaDir, "unispec-tests.schema.json");
+    const testsSchema = JSON.parse(fs_1.default.readFileSync(testsSchemaPath, "utf8"));
+    const validateTestsFn = ajv.compile(testsSchema);
+    const compiled = {
+        validateFn,
+        validateTestsFn,
+    };
+    validatorCache.set(schemaDir, compiled);
+    return compiled;
 }
-const validateFn = ajv.compile(unispec_schema_1.unispec);
-let validateTestsFn;
 function mapAjvErrors(errors) {
     if (!errors)
         return [];
@@ -45,6 +113,7 @@ function mapAjvErrors(errors) {
  * Validate a UniSpec document against the UniSpec JSON Schema.
  */
 async function validateUniSpec(doc, _options = {}) {
+    const { validateFn } = getCompiledValidator(_options);
     const docForValidation = {
         unispecVersion: "0.0.0",
         service: {
@@ -72,12 +141,7 @@ async function validateUniSpec(doc, _options = {}) {
  * 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);
-    }
+    const { validateTestsFn } = getCompiledValidator(_options);
     const valid = validateTestsFn(doc);
     if (valid) {
         return {

package/dist/validator/index.d.ts CHANGED Viewed

@@ -1,5 +1,6 @@
 import { UniSpecDocument, UniSpecTestsDocument, ValidationResult } from "../types";
 export interface ValidateOptions {
+    schemaDir?: string;
 }
 /**
  * Validate a UniSpec document against the UniSpec JSON Schema.

package/dist/validator/index.js CHANGED Viewed

@@ -1,30 +1,98 @@
 import Ajv2020 from "ajv/dist/2020.js";
 import fs from "fs";
 import path from "path";
+import { createRequire } from "module";
+import { pathToFileURL } from "url";
 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");
+function getThisModuleUrl() {
+    if (typeof __filename === "string" && __filename.length > 0) {
+        return pathToFileURL(__filename).href;
+    }
+    const stack = new Error().stack ?? "";
+    const fileUrlMatch = stack.match(/file:\/\/\/[^\s)]+/);
+    if (fileUrlMatch?.[0]) {
+        return fileUrlMatch[0];
+    }
+    const winPathMatch = stack.match(/[A-Za-z]:\\[^\s)]+/);
+    if (winPathMatch?.[0]) {
+        return pathToFileURL(winPathMatch[0]).href;
+    }
+    throw new Error("Cannot determine current module URL for createRequire()");
+}
+function getLocalRequire() {
+    if (typeof require !== "undefined") {
+        return require;
+    }
+    return createRequire(getThisModuleUrl());
+}
+function findPackageRoot(startFilePath) {
+    let dir = path.dirname(startFilePath);
+    for (let i = 0; i < 50; i++) {
+        const pkgJsonPath = path.join(dir, "package.json");
+        if (fs.existsSync(pkgJsonPath)) {
+            return dir;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            break;
+        }
+        dir = parent;
+    }
+    throw new Error(`Cannot locate package.json for resolved path: ${startFilePath}`);
+}
+function getUniSpecSchemaDir(options = {}) {
+    const override = options.schemaDir ?? process.env.UNISPEC_SCHEMA_DIR;
+    if (override) {
+        return override;
+    }
+    const localRequire = getLocalRequire();
+    try {
+        const pkgJsonPath = localRequire.resolve("@unispechq/unispec-schema/package.json");
+        return path.join(path.dirname(pkgJsonPath), "schema");
+    }
+    catch {
+        const entryPath = localRequire.resolve("@unispechq/unispec-schema");
+        const pkgRoot = findPackageRoot(entryPath);
+        return path.join(pkgRoot, "schema");
+    }
+}
+const validatorCache = new Map();
+function getCompiledValidator(options = {}) {
+    const schemaDir = getUniSpecSchemaDir(options);
+    const cached = validatorCache.get(schemaDir);
+    if (cached) {
+        return cached;
+    }
+    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
     const types = unispecManifest?.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);
-}
-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.
+    for (const relPath of typeSchemaPaths) {
+        const filePath = path.join(schemaDir, relPath);
+        if (!fs.existsSync(filePath)) {
+            continue;
+        }
+        const schema = JSON.parse(fs.readFileSync(filePath, "utf8"));
+        const normalizedRelPath = String(relPath).replace(/^\.\//, "");
+        const fallbackId = `https://unispec.dev/schema/${normalizedRelPath}`;
+        ajv.addSchema(schema, fallbackId);
+    }
+    const validateFn = ajv.compile(unispecSchema);
+    const testsSchemaPath = path.join(schemaDir, "unispec-tests.schema.json");
+    const testsSchema = JSON.parse(fs.readFileSync(testsSchemaPath, "utf8"));
+    const validateTestsFn = ajv.compile(testsSchema);
+    const compiled = {
+        validateFn,
+        validateTestsFn,
+    };
+    validatorCache.set(schemaDir, compiled);
+    return compiled;
 }
-const validateFn = ajv.compile(unispecSchema);
-let validateTestsFn;
 function mapAjvErrors(errors) {
     if (!errors)
         return [];
@@ -38,6 +106,7 @@ function mapAjvErrors(errors) {
  * Validate a UniSpec document against the UniSpec JSON Schema.
  */
 export async function validateUniSpec(doc, _options = {}) {
+    const { validateFn } = getCompiledValidator(_options);
     const docForValidation = {
         unispecVersion: "0.0.0",
         service: {
@@ -65,12 +134,7 @@ export async function validateUniSpec(doc, _options = {}) {
  * 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);
-    }
+    const { validateTestsFn } = getCompiledValidator(_options);
     const valid = validateTestsFn(doc);
     if (valid) {
         return {

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@unispechq/unispec-core",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Central UniSpec Core Engine providing parsing, validation, normalization, diffing, and conversion of UniSpec specs.",
   "license": "MIT",
   "repository": {