toolcraft-schema 0.0.304 → 0.0.306

package/README.md

@@ -11,6 +11,7 @@ and JSON Schema generation.
 - Runtime validation with `validateValue()`
 - JSON Schema serialization via `toJsonSchema()`
 - JSON Schema document serialization via `toJsonSchemaDocument()`
+- Native JSON Schema compilation and property projection with reference support
 
 ## Usage
 
@@ -83,6 +84,16 @@ const validation = validateValue(schema, {
 - Invalid input returns `{ ok: false, issues }` with path-aware diagnostics.
 - Validation applies defaults from schema descriptors.
 
+`compileJsonSchema(document, options)` validates complete native JSON Schema
+documents. `projectJsonSchemaProperties(document, options)` supplies stable
+property names, unconditional required metadata, resolved schema annotations,
+and candidate validators for CLI generation. It follows references, compositions,
+embedded resource IDs and conditional declarations using the same compiler.
+Property candidate validators accept values matching at least one declaration;
+validate the complete object to enforce branch-dependent and combined constraints.
+Both functions accept a `registry` for external schema documents without network
+fetching.
+
 ## Environment Variables
 
 This package exposes no environment variables.

package/dist/index.d.ts

@@ -185,6 +185,8 @@ export { isJsonValue } from "./json.js";
 export { cloneDefaultValue } from "./clone-default.js";
 export { unicodeLength } from "./json-schema/utils.js";
 export { compileJsonSchema, formatIssues } from "./json-schema/index.js";
+export { projectJsonSchemaProperties } from "./json-schema/properties.js";
+export type { JsonSchemaProperty } from "./json-schema/properties.js";
 export { normalizeLegacyNullability } from "./json-schema/normalize-nullability.js";
 export { withJsonSchema, nativeJsonSchema } from "./native-json-schema.js";
 export type { NativeSchema } from "./native-json-schema.js";

package/dist/index.js

@@ -329,5 +329,6 @@ export { isJsonValue } from "./json.js";
 export { cloneDefaultValue } from "./clone-default.js";
 export { unicodeLength } from "./json-schema/utils.js";
 export { compileJsonSchema, formatIssues } from "./json-schema/index.js";
+export { projectJsonSchemaProperties } from "./json-schema/properties.js";
 export { normalizeLegacyNullability } from "./json-schema/normalize-nullability.js";
 export { withJsonSchema, nativeJsonSchema } from "./native-json-schema.js";

package/dist/json-schema/properties.d.ts

@@ -0,0 +1,16 @@
+import type { ValidationResult } from "../validate.js";
+import type { CompileJsonSchemaOptions } from "./types.js";
+export interface JsonSchemaProperty {
+    readonly name: string;
+    /** Required regardless of the object's selected alternative or condition. */
+    readonly required: boolean;
+    /** Isolated annotation/schema copies, including resolved references. */
+    readonly schemas: readonly unknown[];
+    /** Candidate hint: accepts a value matching at least one advertised declaration.
+     * Validate the complete object to enforce compositions and conditional rules. */
+    validate(value: unknown): ValidationResult<unknown>;
+}
+/** Project names and candidate validators while retaining the native reference graph.
+ * Property hints cover declarations in refs, compositions and conditional branches;
+ * full object validation remains necessary for branch-dependent constraints. */
+export declare function projectJsonSchemaProperties(schema: unknown, options?: CompileJsonSchemaOptions): readonly JsonSchemaProperty[];

package/dist/json-schema/properties.js

@@ -0,0 +1,129 @@
+import { compileGraph } from "./compiler.js";
+import { evaluateSchema } from "./evaluate.js";
+import { isObject } from "./utils.js";
+function referenceNodes(graph, node) {
+    if (!isObject(node.schema))
+        return [];
+    return ["$ref", "$dynamicRef", "$recursiveRef"].flatMap(keyword => typeof node.schema === "object" && typeof node.schema[keyword] === "string"
+        ? [graph.resolve(node, node.schema[keyword])] : []);
+}
+function ignoresSiblings(node) {
+    return node.dialect === "draft7" && isObject(node.schema) && typeof node.schema.$ref === "string";
+}
+function requiredFor(graph, node, name, ancestors = new Set()) {
+    if (!isObject(node.schema) || ancestors.has(node))
+        return false;
+    const next = new Set(ancestors).add(node);
+    const referenced = referenceNodes(graph, node).some(target => requiredFor(graph, target, name, next));
+    if (ignoresSiblings(node))
+        return referenced;
+    if (referenced || (Array.isArray(node.schema.required) && node.schema.required.includes(name)))
+        return true;
+    for (const keyword of ["allOf", "anyOf", "oneOf"]) {
+        const branches = node.schema[keyword];
+        if (!Array.isArray(branches))
+            continue;
+        const requirements = branches.map((_branch, index) => {
+            const child = node.children.get(`${keyword}/${index}`);
+            return child !== undefined && requiredFor(graph, child, name, next);
+        });
+        if (keyword === "allOf" ? requirements.some(Boolean) : requirements.every(Boolean))
+            return true;
+    }
+    return false;
+}
+function annotationSchemas(graph, root) {
+    const seen = new Set();
+    const schemas = [];
+    const visit = (node) => {
+        if (seen.has(node))
+            return;
+        seen.add(node);
+        if (!ignoresSiblings(node))
+            schemas.push(structuredClone(node.schema));
+        for (const target of referenceNodes(graph, node))
+            visit(target);
+        if (ignoresSiblings(node) || !isObject(node.schema))
+            return;
+        for (const keyword of ["allOf", "anyOf", "oneOf"]) {
+            const branches = node.schema[keyword];
+            if (!Array.isArray(branches))
+                continue;
+            branches.forEach((_branch, index) => {
+                const child = node.children.get(`${keyword}/${index}`);
+                if (child)
+                    visit(child);
+            });
+        }
+    };
+    visit(root);
+    return schemas;
+}
+/** Project names and candidate validators while retaining the native reference graph.
+ * Property hints cover declarations in refs, compositions and conditional branches;
+ * full object validation remains necessary for branch-dependent constraints. */
+export function projectJsonSchemaProperties(schema, options = {}) {
+    const graph = compileGraph(structuredClone(schema), {
+        ...options, ...(options.registry === undefined ? {} : { registry: structuredClone(options.registry) })
+    });
+    const declarations = new Map();
+    const seen = new Set();
+    const visit = (node) => {
+        if (seen.has(node) || !isObject(node.schema))
+            return;
+        seen.add(node);
+        for (const target of referenceNodes(graph, node))
+            visit(target);
+        if (ignoresSiblings(node))
+            return;
+        if (isObject(node.schema.properties)) {
+            for (const name of Object.keys(node.schema.properties)) {
+                const child = node.children.get(`properties/${name}`);
+                if (!child)
+                    continue;
+                const sources = declarations.get(name) ?? new Set();
+                sources.add(child);
+                declarations.set(name, sources);
+            }
+        }
+        for (const keyword of ["allOf", "anyOf", "oneOf"]) {
+            const branches = node.schema[keyword];
+            if (!Array.isArray(branches))
+                continue;
+            branches.forEach((_branch, index) => {
+                const child = node.children.get(`${keyword}/${index}`);
+                if (child)
+                    visit(child);
+            });
+        }
+        for (const keyword of ["then", "else", "dependentSchemas"]) {
+            if (keyword === "dependentSchemas" && isObject(node.schema.dependentSchemas)) {
+                for (const key of Object.keys(node.schema.dependentSchemas)) {
+                    const child = node.children.get(`dependentSchemas/${key}`);
+                    if (child)
+                        visit(child);
+                }
+            }
+            else {
+                const child = node.children.get(keyword);
+                if (child)
+                    visit(child);
+            }
+        }
+    };
+    visit(graph.root);
+    return [...declarations.keys()].sort().map(name => {
+        const sources = [...declarations.get(name)];
+        return {
+            name,
+            required: requiredFor(graph, graph.root, name),
+            schemas: sources.flatMap(node => annotationSchemas(graph, node)),
+            validate(value) {
+                const results = sources.map(node => evaluateSchema({ ...graph, root: node }, value));
+                if (results.some(result => result.valid))
+                    return { ok: true, value };
+                return { ok: false, issues: results.flatMap(result => result.issues) };
+            }
+        };
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft-schema",
-  "version": "0.0.304",
+  "version": "0.0.306",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",