@fulmenhq/tsfulmen 0.2.0 → 0.2.2

package/dist/errors/index.d.ts

@@ -1,5 +1,5 @@
 export { F as FulmenError, a as FulmenErrorData, b as FulmenErrorOptions, L as LEVEL_TO_SEVERITY, S as SEVERITY_LEVELS, k as Severity, m as SeverityLevel, n as SeverityName, f as compareSeverity, e as extractErrorMessage, d as extractStackTrace, g as getDefaultSeverity, i as isFulmenError, c as isFulmenErrorData, h as isSeverityLevel, j as isSeverityName, l as levelToSeverity, s as serializeError, o as severityToLevel } from '../fulmen-error-B_kX8jSC.js';
-import { A as AjvError } from '../types-BJswWpQC.js';
+import { A as AjvError } from '../types-DdoeE7F5.js';
 
 /**
  * Correlation ID generation and validation for error tracking

package/dist/errors/index.js

@@ -6,6 +6,9 @@ import { dirname, extname, join, relative } from 'path';
 import { fileURLToPath } from 'url';
 import glob from 'fast-glob';
 import Ajv from 'ajv';
+import Ajv2019 from 'ajv/dist/2019';
+import Ajv2020 from 'ajv/dist/2020';
+import AjvDraft04 from 'ajv-draft-04';
 import addFormats from 'ajv-formats';
 import { Readable } from 'stream';
 import picomatch from 'picomatch';
@@ -1622,20 +1625,14 @@ async function loadMetaSchema(draft) {
   const content = await readFile(metaSchemaPath, "utf-8");
   return JSON.parse(content);
 }
-async function loadVocabularySchemas() {
+async function loadVocabularySchemas(draft) {
+  if (draft !== "draft-2019-09" && draft !== "draft-2020-12") {
+    return [];
+  }
   const __filename3 = fileURLToPath(import.meta.url);
   const __dirname4 = dirname(__filename3);
-  const vocabDir = join(
-    __dirname4,
-    "..",
-    "..",
-    "schemas",
-    "crucible-ts",
-    "meta",
-    "draft-2020-12",
-    "meta"
-  );
-  const vocabFiles = [
+  const vocabDir = join(__dirname4, "..", "..", "schemas", "crucible-ts", "meta", draft, "meta");
+  const vocabFiles = draft === "draft-2020-12" ? [
     "core.json",
     "applicator.json",
     "unevaluated.json",
@@ -1643,6 +1640,13 @@ async function loadVocabularySchemas() {
     "meta-data.json",
     "format-annotation.json",
     "content.json"
+  ] : [
+    "core.json",
+    "applicator.json",
+    "validation.json",
+    "meta-data.json",
+    "format.json",
+    "content.json"
   ];
   const schemas = [];
   for (const file of vocabFiles) {
@@ -1697,47 +1701,68 @@ async function loadReferencedSchema(uri) {
   }
   return JSON.parse(content);
 }
-function getAjv() {
-  if (!ajvInstance) {
-    ajvInstance = new Ajv({
-      strict: false,
-      allErrors: true,
-      verbose: true,
-      // Allow schemas with $id to be added without replacing existing ones
-      addUsedSchema: false,
-      // Enable async schema loading for YAML references
-      loadSchema: loadReferencedSchema
-    });
-    addFormats(ajvInstance, {
-      mode: "fast",
-      formats: ["date-time", "email", "hostname", "ipv4", "ipv6", "uri", "uri-reference"]
-    });
-    metaschemaReady = Promise.all([loadVocabularySchemas(), loadMetaSchema("draft-2020-12")]).then(([vocabSchemas, metaSchema]) => {
-      if (ajvInstance) {
-        for (const vocabSchema of vocabSchemas) {
-          try {
-            ajvInstance.addMetaSchema(vocabSchema);
-          } catch {
-          }
-        }
-        ajvInstance.addMetaSchema(metaSchema);
-      }
-    }).catch((error) => {
-      throw new Error(`Failed to load metaschemas: ${error}`);
-    });
+function detectDialect(schema) {
+  if (schema && typeof schema === "object" && !Array.isArray(schema)) {
+    const maybeSchema = schema;
+    const declared = maybeSchema.$schema;
+    if (typeof declared === "string") {
+      if (declared.includes("draft-04")) return "draft-04";
+      if (declared.includes("draft-06")) return "draft-06";
+      if (declared.includes("draft-07")) return "draft-07";
+      if (declared.includes("draft/2019-09")) return "draft-2019-09";
+      if (declared.includes("draft/2020-12")) return "draft-2020-12";
+    }
   }
-  return ajvInstance;
+  return "draft-2020-12";
+}
+function createAjv(dialect) {
+  const AjvCtor = dialect === "draft-2020-12" ? Ajv2020 : dialect === "draft-2019-09" ? Ajv2019 : dialect === "draft-04" ? AjvDraft04 : Ajv;
+  const ajv = new AjvCtor({
+    strict: false,
+    allErrors: true,
+    verbose: true,
+    // Allow schemas with $id to be added without replacing existing ones
+    addUsedSchema: false,
+    // draft-04 uses "id"; later drafts use "$id"
+    schemaId: dialect === "draft-04" ? "id" : "$id",
+    // Enable async schema loading for YAML references
+    loadSchema: loadReferencedSchema
+  });
+  addFormats(ajv, {
+    mode: "fast",
+    formats: ["date-time", "email", "hostname", "ipv4", "ipv6", "uri", "uri-reference"]
+  });
+  return ajv;
+}
+async function getAjv(dialect) {
+  const existing = ajvInstances.get(dialect);
+  if (existing) {
+    const ready = metaschemaReady.get(dialect);
+    if (ready) await ready;
+    return existing;
+  }
+  const ajv = createAjv(dialect);
+  ajvInstances.set(dialect, ajv);
+  const readyPromise = Promise.all([loadVocabularySchemas(dialect), loadMetaSchema(dialect)]).then(([vocabSchemas, metaSchema]) => {
+    for (const vocabSchema of vocabSchemas) {
+      try {
+        ajv.addMetaSchema(vocabSchema);
+      } catch {
+      }
+    }
+    try {
+      ajv.addMetaSchema(metaSchema);
+    } catch {
+    }
+  }).catch((error) => {
+    throw new Error(`Failed to load metaschemas (${dialect}): ${error}`);
+  });
+  metaschemaReady.set(dialect, readyPromise);
+  await readyPromise;
+  return ajv;
 }
 async function compileSchema(schema, options = {}) {
-  const ajv = getAjv();
-  if (metaschemaReady) {
-    await metaschemaReady;
-  }
-  const cacheKey = typeof schema === "string" ? schema : JSON.stringify(schema);
-  const cached = schemaCache.get(cacheKey);
-  if (cached !== void 0) {
-    return cached;
-  }
+  const baseKey = typeof schema === "string" ? schema : JSON.stringify(schema);
   let parsedSchema;
   if (typeof schema === "string") {
     try {
@@ -1755,18 +1780,27 @@ async function compileSchema(schema, options = {}) {
   } else {
     parsedSchema = schema;
   }
+  const dialect = detectDialect(parsedSchema);
+  const ajv = await getAjv(dialect);
+  const cacheKey = `${dialect}:${baseKey}`;
+  const cached = schemaCache.get(cacheKey);
+  if (cached !== void 0) {
+    return cached;
+  }
   try {
     if (options.aliases && options.aliases.length > 0) {
       for (const alias of options.aliases) {
         if (alias && ajv.getSchema(alias) === void 0) {
           try {
-            ajv.addSchema(parsedSchema, alias);
+            if (typeof parsedSchema === "object" && parsedSchema !== null) {
+              ajv.addSchema(parsedSchema, alias);
+            }
           } catch {
           }
         }
       }
     }
-    const validator = await ajv.compileAsync(parsedSchema);
+    const validator = typeof parsedSchema === "boolean" ? ajv.compile(parsedSchema) : await ajv.compileAsync(parsedSchema);
     schemaCache.set(cacheKey, validator);
     return validator;
   } catch (error) {
@@ -1836,8 +1870,39 @@ async function validateFile(filePath, validator) {
 }
 async function validateSchema(schema) {
   try {
-    const validator = await compileSchema(schema);
-    validateData({}, validator);
+    let parsedSchema;
+    if (typeof schema === "string") {
+      try {
+        parsedSchema = JSON.parse(schema);
+      } catch {
+        parsedSchema = parse(schema);
+      }
+    } else if (Buffer.isBuffer(schema)) {
+      const content = schema.toString("utf-8");
+      try {
+        parsedSchema = JSON.parse(content);
+      } catch {
+        parsedSchema = parse(content);
+      }
+    } else {
+      parsedSchema = schema;
+    }
+    const dialect = detectDialect(parsedSchema);
+    const ajv = await getAjv(dialect);
+    const metaValid = ajv.validateSchema(parsedSchema);
+    if (!metaValid && ajv.errors) {
+      const diagnostics = ajv.errors.map(
+        (error) => createDiagnostic(
+          error.instancePath || "",
+          error.message || "Schema meta-validation failed",
+          error.keyword || "unknown",
+          "ERROR",
+          "ajv"
+        )
+      );
+      return { valid: false, diagnostics, source: "ajv" };
+    }
+    await compileSchema(parsedSchema);
     return {
       valid: true,
       diagnostics: [],
@@ -1908,14 +1973,15 @@ async function validateFileBySchemaId(filePath, schemaId, registryOptions) {
     throw error;
   }
 }
-var ajvInstance, metaschemaReady, schemaCache;
+var ajvInstances, metaschemaReady, schemaCache;
 var init_validator = __esm({
   "src/schema/validator.ts"() {
     init_telemetry();
     init_errors();
     init_registry();
     init_utils();
-    metaschemaReady = null;
+    ajvInstances = /* @__PURE__ */ new Map();
+    metaschemaReady = /* @__PURE__ */ new Map();
     schemaCache = /* @__PURE__ */ new Map();
   }
 });