import { areJsonValuesEqual } from "./equality.js";
import { epochNext, once } from "./stamps.js";
/**
* Hand-rolled JSON Schema meta-validator.
*
* Replaces the old AJV meta-schema check in request hot paths with a small
* structural validator for the JSON Schema subset this repo emits and forwards.
* Unknown keywords are accepted for forward compatibility; known keywords are
* checked so malformed provider payloads still fall back instead of being sent.
*/
type Json = unknown;
function isPlainObject(value: Json): value is Record<string, Json> {
return typeof value === "object" && value !== null && !Array.isArray(value);
}
const TYPE_NAMES: Record<string, true> = {
string: true,
number: true,
integer: true,
boolean: true,
object: true,
array: true,
null: true,
};
function isNonNegativeInteger(value: Json): value is number {
return typeof value === "number" && Number.isInteger(value) && value >= 0;
}
function hasUniqueJsonValues(values: readonly unknown[]): boolean {
for (let i = 0; i < values.length; i += 1) {
for (let j = i + 1; j < values.length; j += 1) {
if (areJsonValuesEqual(values[i], values[j])) return false;
}
}
return true;
}
function checkTypeKeyword(value: Json): boolean {
if (typeof value === "string") return value in TYPE_NAMES;
if (!Array.isArray(value) || value.length === 0) return false;
const seen = new Set<string>();
for (const entry of value) {
if (typeof entry !== "string" || !(entry in TYPE_NAMES) || seen.has(entry)) return false;
seen.add(entry);
}
return true;
}
function checkSchemaArray(value: Json, epoch: number): boolean {
return Array.isArray(value) && value.every((entry) => checkNode(entry, epoch));
}
function checkSchemaMap(value: Json, epoch: number): boolean {
if (!isPlainObject(value)) return false;
for (const k in value) {
if (!checkNode(value[k], epoch)) return false;
}
return true;
}
/** Validate a single sub-schema node. */
function checkNode(node: Json, epoch: number): boolean {
// Boolean schemas (`true` / `false`) are valid JSON Schema.
if (node === true || node === false) return true;
if (!isPlainObject(node)) return false;
if (!once(node, epoch)) return true;
if ("type" in node && !checkTypeKeyword(node.type)) return false;
for (const key of ["anyOf", "oneOf", "allOf"] as const) {
if (key in node && !checkSchemaArray(node[key], epoch)) return false;
}
if ("not" in node && !checkNode(node.not, epoch)) return false;
for (const key of ["if", "then", "else"] as const) {
if (key in node && !checkNode(node[key], epoch)) return false;
}
for (const key of ["properties", "patternProperties", "$defs", "definitions"] as const) {
if (key in node && !checkSchemaMap(node[key], epoch)) return false;
}
if ("propertyNames" in node && !checkNode(node.propertyNames, epoch)) return false;
if ("contains" in node && !checkNode(node.contains, epoch)) return false;
if ("required" in node) {
const value = node.required;
if (!Array.isArray(value)) return false;
const seenRequired = new Set<string>();
for (const entry of value) {
if (typeof entry !== "string" || seenRequired.has(entry)) return false;
seenRequired.add(entry);
}
}
if ("items" in node) {
const items = node.items;
if (Array.isArray(items)) return false;
if (!checkNode(items, epoch)) return false;
}
if ("prefixItems" in node && !checkSchemaArray(node.prefixItems, epoch)) return false;
// Obsolete tuple/dependency keywords are not valid in the 2020-12 schema
// shape we emit and forward.
if ("additionalItems" in node || "dependencies" in node) return false;
for (const key of ["additionalProperties", "unevaluatedProperties", "unevaluatedItems"] as const) {
if (!(key in node)) continue;
const value = node[key];
if (typeof value !== "boolean" && !checkNode(value, epoch)) return false;
}
if ("dependentSchemas" in node && !checkSchemaMap(node.dependentSchemas, epoch)) return false;
if ("dependentRequired" in node) {
const value = node.dependentRequired;
if (!isPlainObject(value)) return false;
for (const k in value) {
const entry = value[k];
if (!Array.isArray(entry) || !entry.every((item) => typeof item === "string")) return false;
}
}
if ("enum" in node) {
if (!Array.isArray(node.enum) || node.enum.length === 0 || !hasUniqueJsonValues(node.enum)) return false;
}
for (const key of ["minimum", "maximum", "multipleOf"] as const) {
if (key in node && typeof node[key] !== "number") return false;
}
if (node.multipleOf !== undefined && typeof node.multipleOf === "number" && node.multipleOf <= 0) return false;
for (const key of ["exclusiveMinimum", "exclusiveMaximum"] as const) {
if (key in node && typeof node[key] !== "number" && typeof node[key] !== "boolean") return false;
}
for (const key of ["minLength", "maxLength", "minItems", "maxItems", "minProperties", "maxProperties"] as const) {
if (key in node && !isNonNegativeInteger(node[key])) return false;
}
for (const key of ["minContains", "maxContains"] as const) {
if (key in node && !isNonNegativeInteger(node[key])) return false;
}
if ("uniqueItems" in node && typeof node.uniqueItems !== "boolean") return false;
if ("pattern" in node) {
if (typeof node.pattern !== "string") return false;
try {
new RegExp(node.pattern);
} catch {
return false;
}
}
if ("format" in node && typeof node.format !== "string") return false;
if ("nullable" in node && typeof node.nullable !== "boolean") return false;
if ("readOnly" in node && typeof node.readOnly !== "boolean") return false;
if ("writeOnly" in node && typeof node.writeOnly !== "boolean") return false;
if ("deprecated" in node && typeof node.deprecated !== "boolean") return false;
return true;
}
/** Validate that `schema` is structurally a valid JSON Schema (subset). */
export function isValidJsonSchema(schema: unknown): boolean {
try {
return checkNode(schema, epochNext());
} catch {
return false;
}
}