correctly 0.0.0

package/src/core/parse.ts

@@ -0,0 +1,168 @@
+import {
+	findNodeAtLocation,
+	getNodePath,
+	getNodeValue,
+	parseTree,
+	printParseErrorCode,
+	type Node,
+	type ParseError,
+} from "jsonc-parser"
+import type { Diagnostic, Mode, Position } from "./types.ts"
+
+export type SourceSpan = { offset: number; length: number }
+export type ParsedDocument = {
+	value: unknown
+	diagnostics: Diagnostic[]
+	locate: (pointer: string, key?: boolean) => SourceSpan | undefined
+}
+export type ParsedJsonDocument = ParsedDocument & { root: Node | undefined }
+
+export function pointer(parts: readonly (string | number)[]): string {
+	return parts
+		.map((p) => `/${String(p).replace(/~/g, "~0").replace(/\//g, "~1")}`)
+		.join("")
+}
+
+export function positionAt(text: string, offset: number): Position {
+	const end = Math.min(Math.max(0, offset), text.length)
+	let line = 0
+	let start = 0
+	for (let i = 0; i < end; i++) {
+		if (text[i] === "\r") {
+			if (text[i + 1] === "\n" && i + 1 < end) i++
+			line++
+			start = i + 1
+		} else if (text[i] === "\n") {
+			line++
+			start = i + 1
+		}
+	}
+	return { line, character: end - start }
+}
+
+export function diagnostic(
+	text: string,
+	code: string,
+	message: string,
+	jsonPointer = "",
+	offset = 0,
+	length = 1,
+): Diagnostic {
+	const start = Math.min(offset, text.length)
+	const size = Math.min(Math.max(1, length), text.length - start)
+	return {
+		code,
+		message,
+		pointer: jsonPointer,
+		offset: start,
+		length: size,
+		range: {
+			start: positionAt(text, start),
+			end: positionAt(text, start + size),
+		},
+	}
+}
+
+export function parseDocument(text: string, mode: Mode): ParsedJsonDocument {
+	const errors: ParseError[] = []
+	const root = parseTree(text, errors, {
+		disallowComments: mode === "json",
+		allowTrailingComma: mode === "jsonc",
+		allowEmptyContent: false,
+	})
+	const diagnostics = errors.map((e) =>
+		diagnostic(
+			text,
+			"syntax",
+			printParseErrorCode(e.error),
+			"",
+			e.offset,
+			e.length,
+		),
+	)
+	function visit(node: Node) {
+		if (node.type === "object") {
+			const keys = new Set<string>()
+			for (const property of node.children ?? []) {
+				const key = property.children?.[0]
+				if (!key || typeof key.value !== "string") continue
+				if (keys.has(key.value)) {
+					diagnostics.push(
+						diagnostic(
+							text,
+							"duplicate-key",
+							`Duplicate key ${JSON.stringify(key.value)}`,
+							pointer([...getNodePath(node), key.value]),
+							key.offset,
+							key.length,
+						),
+					)
+				}
+				keys.add(key.value)
+			}
+		}
+		if (node.type === "number" && !Number.isFinite(node.value)) {
+			diagnostics.push(
+				diagnostic(
+					text,
+					"syntax",
+					"Number exceeds the supported finite range",
+					pointer(getNodePath(node)),
+					node.offset,
+					node.length,
+				),
+			)
+		}
+		for (const child of node.children ?? []) visit(child)
+	}
+	if (root) visit(root)
+	// jsonc-parser's object values have null prototypes. Ajv's deep equality
+	// expects ordinary JSON objects; Object.fromEntries safely preserves __proto__.
+	function value(node: Node): unknown {
+		if (node.type === "object")
+			return Object.fromEntries(
+				(node.children ?? []).flatMap((property) => {
+					const key = property.children?.[0]
+					const child = property.children?.[1]
+					return key && child ? [[String(key.value), value(child)]] : []
+				}),
+			)
+		if (node.type === "array") return (node.children ?? []).map(value)
+		return getNodeValue(node) as unknown
+	}
+	return {
+		root,
+		value: root ? value(root) : undefined,
+		diagnostics,
+		locate: (jsonPointer, key = false) => {
+			const node = locate(root, jsonPointer, key)
+			return node ? { offset: node.offset, length: node.length } : undefined
+		},
+	}
+}
+
+export function locate(
+	root: Node | undefined,
+	jsonPointer: string,
+	key = false,
+): Node | undefined {
+	if (!root) return undefined
+	const parts =
+		jsonPointer === ""
+			? []
+			: jsonPointer
+					.slice(1)
+					.split("/")
+					.map((p) => p.replace(/~1/g, "/").replace(/~0/g, "~"))
+	let current = root
+	for (const part of parts) {
+		const next = findNodeAtLocation(current, [
+			current.type === "array" ? Number(part) : part,
+		])
+		if (!next) break
+		current = next
+	}
+	return key && current.parent?.type === "property"
+		? (current.parent.children?.[0] ?? current)
+		: current
+}

package/src/core/schemas.ts

@@ -0,0 +1,379 @@
+import { createHash, randomUUID } from "node:crypto"
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+import type { AnySchema, SchemaObject } from "ajv"
+import { parseDocument } from "./parse.ts"
+import { readText, type Project, type ReadText } from "./config.ts"
+import { CorrectlyError } from "./types.ts"
+
+export type Dialect = "draft7" | "2020-12"
+export const DIALECTS = {
+	draft7: "http://json-schema.org/draft-07/schema#",
+	"2020-12": "https://json-schema.org/draft/2020-12/schema",
+} as const
+const VOCABULARIES = new Set(
+	[
+		"core",
+		"applicator",
+		"unevaluated",
+		"validation",
+		"meta-data",
+		"format-annotation",
+		"content",
+	].map((name) => `https://json-schema.org/draft/2020-12/vocab/${name}`),
+)
+const SINGLE_SCHEMAS = [
+	"additionalItems",
+	"additionalProperties",
+	"contains",
+	"propertyNames",
+	"not",
+	"if",
+	"then",
+	"else",
+	"unevaluatedProperties",
+	"unevaluatedItems",
+	"contentSchema",
+]
+const MAP_SCHEMAS = [
+	"properties",
+	"patternProperties",
+	"definitions",
+	"$defs",
+	"dependentSchemas",
+	"dependencies",
+]
+const ARRAY_SCHEMAS = ["allOf", "anyOf", "oneOf", "prefixItems"]
+
+function isObject(value: unknown): value is SchemaObject {
+	return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+function dialect(value: unknown, inherited: Dialect): Dialect {
+	if (value === undefined) return inherited
+	if (typeof value !== "string")
+		throw new CorrectlyError("schema", "Schema $schema must be a string")
+	const id = value.replace(/#$/, "")
+	if (
+		id === "http://json-schema.org/draft-07/schema" ||
+		id === "https://json-schema.org/draft-07/schema"
+	)
+		return "draft7"
+	if (id === DIALECTS["2020-12"]) return "2020-12"
+	throw new CorrectlyError(
+		"unsupported-dialect",
+		`Unsupported schema dialect: ${value}; supported: draft 7, draft 2020-12`,
+	)
+}
+
+export type SchemaResource = {
+	uri: string
+	schema: AnySchema
+	dialect: Dialect
+}
+type CacheEntry = {
+	uri: string
+	text: string
+	etag?: string
+	lastModified?: string
+}
+export type StoreOptions = {
+	offline?: boolean
+	read?: ReadText
+	fetch?: typeof fetch
+	signal?: AbortSignal
+}
+
+export class SchemaStore {
+	private readonly options: StoreOptions
+	readonly resources = new Map<string, SchemaResource>()
+	private readonly pending = new Map<string, Promise<SchemaResource>>()
+	private readonly cacheDir: string
+	private readonly offline: boolean
+	private readonly timeoutMs: number
+	private readonly maxBytes: number
+	private readonly maxRequests: number
+	private readonly read: ReadText
+	private readonly request: typeof fetch
+	private requests = 0
+	constructor(project: Project, options: StoreOptions = {}) {
+		this.options = options
+		const remote = project.config.remote
+		this.cacheDir = path.resolve(
+			project.root,
+			remote?.cacheDir ?? ".correctly-cache",
+		)
+		this.offline = options.offline ?? remote?.offline ?? false
+		this.timeoutMs = remote?.timeoutMs ?? 5000
+		this.maxBytes = remote?.maxBytes ?? 2 * 1024 * 1024
+		this.maxRequests = remote?.maxRequests ?? 64
+		this.read = options.read ?? readText
+		this.request = options.fetch ?? fetch
+	}
+
+	async load(
+		value: string,
+		inherited: Dialect = "draft7",
+	): Promise<SchemaResource> {
+		this.options.signal?.throwIfAborted()
+		const url = new URL(value)
+		url.hash = ""
+		const uri = url.href
+		const known = this.resources.get(uri)
+		if (known) return known
+		let promise = this.pending.get(uri)
+		if (!promise) {
+			promise = this.loadResource(uri, inherited)
+			this.pending.set(uri, promise)
+		}
+		return promise
+	}
+
+	private async loadResource(
+		uri: string,
+		inherited: Dialect,
+	): Promise<SchemaResource> {
+		if (++this.requests > this.maxRequests)
+			throw new CorrectlyError(
+				"schema-limit",
+				`Schema resource limit (${this.maxRequests}) exceeded`,
+			)
+		let text: string
+		const url = new URL(uri)
+		try {
+			if (url.protocol === "file:") text = await this.read(uri)
+			else if (url.protocol === "https:" || url.protocol === "http:")
+				text = await this.remote(uri)
+			else
+				throw new CorrectlyError(
+					"schema",
+					`Unsupported schema protocol: ${url.protocol}`,
+				)
+		} catch (error) {
+			if (error instanceof CorrectlyError) throw error
+			throw new CorrectlyError(
+				"schema-load",
+				`Cannot load schema ${uri}: ${error instanceof Error ? error.message : String(error)}`,
+			)
+		}
+		this.options.signal?.throwIfAborted()
+		if (Buffer.byteLength(text) > this.maxBytes)
+			throw new CorrectlyError(
+				"schema-limit",
+				`Schema ${uri} exceeds ${this.maxBytes} bytes`,
+			)
+		const parsed = parseDocument(text, "json")
+		if (parsed.diagnostics.length) {
+			const d = parsed.diagnostics[0]!
+			throw new CorrectlyError(
+				"schema",
+				`Invalid schema JSON at ${uri}:${d.range.start.line + 1}:${d.range.start.character + 1}: ${d.message}`,
+			)
+		}
+		if (typeof parsed.value !== "boolean" && !isObject(parsed.value))
+			throw new CorrectlyError(
+				"schema",
+				`Schema must be an object or boolean: ${uri}`,
+			)
+		const rootDialect = dialect(
+			isObject(parsed.value) ? parsed.value.$schema : undefined,
+			inherited,
+		)
+		const schema = parsed.value as AnySchema
+		const resource: SchemaResource = { uri, schema, dialect: rootDialect }
+		// Normalize schema identifiers only, never document data or annotation values.
+		this.normalize(schema, uri, rootDialect, resource)
+		if (isObject(schema) && schema.$id === undefined) schema.$id = uri
+		this.register(uri, resource)
+		return resource
+	}
+
+	private register(uri: string, resource: SchemaResource) {
+		const previous = this.resources.get(uri)
+		if (previous && previous.schema !== resource.schema)
+			throw new CorrectlyError("schema", `Duplicate schema identifier: ${uri}`)
+		this.resources.set(uri, resource)
+	}
+
+	private normalize(
+		schema: unknown,
+		base: string,
+		expected: Dialect,
+		root: SchemaResource,
+	) {
+		if (!isObject(schema)) return
+		const ownDialect = dialect(schema.$schema, expected)
+		if (ownDialect !== expected)
+			throw new CorrectlyError(
+				"unsupported-dialect",
+				`Mixed schema dialects at ${base} are not supported`,
+			)
+		if (schema.$schema !== undefined) schema.$schema = DIALECTS[ownDialect]
+		if (schema.$async !== undefined)
+			throw new CorrectlyError(
+				"schema",
+				`Asynchronous data validation is not supported: ${base}`,
+			)
+		if (schema.$vocabulary !== undefined) {
+			if (!isObject(schema.$vocabulary))
+				throw new CorrectlyError(
+					"schema",
+					`$vocabulary must be an object: ${base}`,
+				)
+			for (const [vocabulary, required] of Object.entries(schema.$vocabulary)) {
+				if (typeof required !== "boolean")
+					throw new CorrectlyError(
+						"schema",
+						`$vocabulary values must be boolean: ${base}`,
+					)
+				if (required && !VOCABULARIES.has(vocabulary))
+					throw new CorrectlyError(
+						"unsupported-vocabulary",
+						`Unsupported required vocabulary: ${vocabulary}`,
+					)
+			}
+		}
+		let scope = base
+		if (schema.$id !== undefined) {
+			if (typeof schema.$id !== "string")
+				throw new CorrectlyError("schema", `$id must be a string: ${base}`)
+			scope = new URL(schema.$id, base).href
+			schema.$id = scope
+			this.register(scope.replace(/#$/, ""), { ...root, schema })
+		}
+		for (const anchor of [schema.$anchor, schema.$dynamicAnchor]) {
+			if (typeof anchor === "string")
+				this.register(new URL(`#${anchor}`, scope).href, { ...root, schema })
+		}
+		for (const key of SINGLE_SCHEMAS)
+			this.normalize(schema[key], scope, expected, root)
+		for (const key of MAP_SCHEMAS) {
+			if (isObject(schema[key]))
+				for (const child of Object.values(
+					schema[key] as Record<string, unknown>,
+				))
+					this.normalize(child, scope, expected, root)
+		}
+		for (const key of [...ARRAY_SCHEMAS, "items"]) {
+			const children: unknown = schema[key]
+			if (Array.isArray(children))
+				for (const child of children)
+					this.normalize(child, scope, expected, root)
+			else if (key === "items") this.normalize(children, scope, expected, root)
+		}
+	}
+
+	private async remote(uri: string): Promise<string> {
+		const cacheFile = path.join(
+			this.cacheDir,
+			`${createHash("sha256").update(uri).digest("hex")}.json`,
+		)
+		let cached: CacheEntry | undefined
+		try {
+			const raw = await readFile(cacheFile, "utf8")
+			const entry: unknown = JSON.parse(raw)
+			if (
+				!isObject(entry) ||
+				entry.uri !== uri ||
+				typeof entry.text !== "string"
+			)
+				throw new Error("invalid cache entry")
+			cached = entry as CacheEntry
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code !== "ENOENT")
+				throw new CorrectlyError(
+					"schema-cache",
+					`Cannot read schema cache ${cacheFile}: ${String(error)}`,
+				)
+		}
+		if (this.offline) {
+			if (!cached)
+				throw new CorrectlyError(
+					"offline-miss",
+					`Schema is not cached in offline mode: ${uri}`,
+				)
+			return cached.text
+		}
+		const timeout = AbortSignal.timeout(this.timeoutMs)
+		const signal = this.options.signal
+			? AbortSignal.any([this.options.signal, timeout])
+			: timeout
+		const headers: Record<string, string> = {}
+		if (cached?.etag) headers["If-None-Match"] = cached.etag
+		if (cached?.lastModified) headers["If-Modified-Since"] = cached.lastModified
+		let current = uri
+		for (let redirects = 0; redirects <= 5; redirects++) {
+			const response = await this.request(current, {
+				signal,
+				headers,
+				redirect: "manual",
+			})
+			if ([301, 302, 303, 307, 308].includes(response.status)) {
+				await response.body?.cancel()
+				const location = response.headers.get("location")
+				if (!location)
+					throw new CorrectlyError(
+						"schema-load",
+						`Redirect without location: ${current}`,
+					)
+				current = new URL(location, current).href
+				if (!["http:", "https:"].includes(new URL(current).protocol))
+					throw new CorrectlyError(
+						"schema-load",
+						`Unsupported redirect: ${current}`,
+					)
+				continue
+			}
+			if (response.status === 304 && cached) {
+				await response.body?.cancel()
+				return cached.text
+			}
+			if (!response.ok || !response.body) {
+				await response.body?.cancel()
+				throw new CorrectlyError(
+					"schema-load",
+					`HTTP ${response.status} loading schema ${uri}`,
+				)
+			}
+			const reader = response.body.getReader()
+			const chunks: Uint8Array[] = []
+			let size = 0
+			try {
+				while (true) {
+					const { value, done } = await reader.read()
+					if (done) break
+					size += value.byteLength
+					if (size > this.maxBytes)
+						throw new CorrectlyError(
+							"schema-limit",
+							`Schema ${uri} exceeds ${this.maxBytes} bytes`,
+						)
+					chunks.push(value)
+				}
+			} finally {
+				await reader.cancel()
+			}
+			const text = Buffer.concat(chunks).toString("utf8")
+			const entry: CacheEntry = { uri, text }
+			const etag = response.headers.get("etag")
+			const lastModified = response.headers.get("last-modified")
+			if (etag) entry.etag = etag
+			if (lastModified) entry.lastModified = lastModified
+			signal.throwIfAborted()
+			await mkdir(this.cacheDir, { recursive: true })
+			const temporary = `${cacheFile}.${randomUUID()}.tmp`
+			await writeFile(temporary, JSON.stringify(entry))
+			await rename(temporary, cacheFile)
+			return text
+		}
+		throw new CorrectlyError(
+			"schema-limit",
+			`Too many redirects loading schema ${uri}`,
+		)
+	}
+}
+
+export function localSchemaPath(uri: string): string | undefined {
+	const url = new URL(uri)
+	return url.protocol === "file:" ? fileURLToPath(url) : undefined
+}

package/src/core/types.ts

@@ -0,0 +1,56 @@
+export type Mode = "json" | "jsonc"
+export type Position = { line: number; character: number }
+export type Range = { start: Position; end: Position }
+export type Diagnostic = {
+	code: string
+	message: string
+	pointer: string
+	offset: number
+	length: number
+	range: Range
+	context?: { parent: number; label: string }
+}
+export type Failure = { code: string; message: string; file?: string }
+export class CorrectlyError extends Error {
+	readonly code: string
+	constructor(code: string, message: string) {
+		super(message)
+		this.name = "CorrectlyError"
+		this.code = code
+	}
+}
+export function failure(error: unknown, file?: string): Failure {
+	return {
+		code: error instanceof CorrectlyError ? error.code : "execution",
+		message: error instanceof Error ? error.message : String(error),
+		...(file === undefined ? {} : { file }),
+	}
+}
+export type Association = {
+	index: number
+	name: string
+	schema: string | null
+	mode: Mode
+}
+export type FileResult = {
+	file: string
+	mode: Mode
+	coverage: "schema" | "syntax-only" | "excluded"
+	association: Association | null
+	diagnostics: Diagnostic[]
+	failures: Failure[]
+}
+export type Report = {
+	reportVersion: 1
+	config: string | null
+	files: FileResult[]
+	failures: Failure[]
+	summary: {
+		checked: number
+		schemaCovered: number
+		syntaxOnly: number
+		invalid: number
+		failures: number
+	}
+	exitCode: 0 | 1 | 2
+}

package/src/lsp/hints.ts

@@ -0,0 +1,82 @@
+import {
+	getLanguageService,
+	type JSONDocument,
+	type LanguageService,
+	type Position,
+} from "vscode-json-languageservice"
+import type { TextDocument } from "vscode-languageserver-textdocument"
+import { fileURLToPath } from "node:url"
+import { associationFor, isIncluded } from "../core/config.ts"
+import type { Engine } from "../core/engine.ts"
+
+// Only the schema-selection accessor is hidden. The original AST (including
+// $schema as ordinary data) is retained by every bound traversal method.
+export function externalSelection(document: JSONDocument): JSONDocument {
+	return new Proxy(document, {
+		get(target, key) {
+			if (key === "root") return undefined
+			const value: unknown = Reflect.get(target, key)
+			return typeof value === "function" ? value.bind(target) : value
+		},
+	})
+}
+
+export class Hints {
+	private readonly services = new WeakMap<
+		Engine,
+		Map<string, LanguageService>
+	>()
+	private async service(
+		engine: Engine,
+		document: TextDocument,
+	): Promise<LanguageService | undefined> {
+		const file = fileURLToPath(document.uri)
+		if (!isIncluded(engine.project, file)) return undefined
+		const association = associationFor(engine.project, file)
+		if (!association?.schema) return undefined
+		await engine.validator(association.schema)
+		let services = this.services.get(engine)
+		if (!services) {
+			services = new Map()
+			this.services.set(engine, services)
+		}
+		let service = services.get(association.schema)
+		if (!service) {
+			service = getLanguageService({
+				schemaRequestService: async (uri) =>
+					JSON.stringify((await engine.store.load(uri)).schema),
+				workspaceContext: {
+					resolveRelativePath: (relative, resource) =>
+						new URL(relative, resource).href,
+				},
+			})
+			// A per-association service prevents overlapping rules being combined.
+			service.configure({
+				validate: false,
+				schemas: [{ uri: association.schema, fileMatch: ["*"] }],
+			})
+			services.set(association.schema, service)
+		}
+		return service
+	}
+	async complete(engine: Engine, document: TextDocument, position: Position) {
+		const service = await this.service(engine, document)
+		return service
+			? await service.doComplete(
+					document,
+					position,
+					externalSelection(service.parseJSONDocument(document)),
+				)
+			: { isIncomplete: false, items: [] }
+	}
+	async hover(engine: Engine, document: TextDocument, position: Position) {
+		const service = await this.service(engine, document)
+		return service
+			? await service.doHover(
+					document,
+					position,
+					externalSelection(service.parseJSONDocument(document)),
+				)
+			: null
+	}
+}