correctly 0.0.0 → 0.1.0

package/src/core/schemas.ts

@@ -6,6 +6,7 @@ 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"
+import { schemaChildren } from "./schema-walk.ts"
 
 export type Dialect = "draft7" | "2020-12"
 export const DIALECTS = {
@@ -23,28 +24,6 @@ const VOCABULARIES = new Set(
 		"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)
@@ -70,6 +49,7 @@ export type SchemaResource = {
 	uri: string
 	schema: AnySchema
 	dialect: Dialect
+	pointer?: string
 }
 type CacheEntry = {
 	uri: string
@@ -96,7 +76,12 @@ export class SchemaStore {
 	private readonly read: ReadText
 	private readonly request: typeof fetch
 	private requests = 0
-	constructor(project: Project, options: StoreOptions = {}) {
+	constructor(
+		project: Pick<Project, "root"> & {
+			config: Pick<Project["config"], "remote">
+		},
+		options: StoreOptions = {},
+	) {
 		this.options = options
 		const remote = project.config.remote
 		this.cacheDir = path.resolve(
@@ -200,6 +185,7 @@ export class SchemaStore {
 		base: string,
 		expected: Dialect,
 		root: SchemaResource,
+		location = "",
 	) {
 		if (!isObject(schema)) return
 		const ownDialect = dialect(schema.$schema, expected)
@@ -239,28 +225,22 @@ export class SchemaStore {
 				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 })
+			this.register(scope.replace(/#$/, ""), {
+				...root,
+				schema,
+				pointer: location,
+			})
 		}
 		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)
+				this.register(new URL(`#${anchor}`, scope).href, {
+					...root,
+					schema,
+					pointer: location,
+				})
 		}
+		for (const [path, child] of schemaChildren(schema))
+			this.normalize(child, scope, expected, root, location + path)
 	}
 
 	private async remote(uri: string): Promise<string> {

package/src/core/types.ts

@@ -1,4 +1,4 @@
-export type Mode = "json" | "jsonc"
+export type Mode = string
 export type Position = { line: number; character: number }
 export type Range = { start: Position; end: Position }
 export type Diagnostic = {
@@ -10,43 +10,70 @@ export type Diagnostic = {
 	range: Range
 	context?: { parent: number; label: string }
 }
-export type Failure = { code: string; message: string; file?: string }
+export type ExtensionRequirement = {
+	schemaUri: string
+	schemaPointer: string
+	format: string
+	suggestedExtension?: string
+}
+export type Failure = {
+	code: string
+	message: string
+	file?: string
+	details?: ExtensionRequirement
+}
 export class CorrectlyError extends Error {
 	readonly code: string
-	constructor(code: string, message: string) {
+	readonly details?: ExtensionRequirement
+	constructor(code: string, message: string, details?: ExtensionRequirement) {
 		super(message)
 		this.name = "CorrectlyError"
 		this.code = code
+		if (details) this.details = details
 	}
 }
+export function isCorrectlyError(error: unknown): error is CorrectlyError {
+	return (
+		error instanceof Error &&
+		error.name === "CorrectlyError" &&
+		"code" in error &&
+		typeof error.code === "string"
+	)
+}
 export function failure(error: unknown, file?: string): Failure {
 	return {
-		code: error instanceof CorrectlyError ? error.code : "execution",
+		code: isCorrectlyError(error) ? error.code : "execution",
 		message: error instanceof Error ? error.message : String(error),
 		...(file === undefined ? {} : { file }),
+		...(isCorrectlyError(error) && error.details
+			? { details: error.details }
+			: {}),
 	}
 }
 export type Association = {
 	index: number
 	name: string
 	schema: string | null
+	validator: string | null
 	mode: Mode
+	extensions?: string[]
 }
 export type FileResult = {
 	file: string
 	mode: Mode
-	coverage: "schema" | "syntax-only" | "excluded"
+	coverage: "schema" | "validated" | "syntax-only" | "excluded"
 	association: Association | null
 	diagnostics: Diagnostic[]
 	failures: Failure[]
 }
 export type Report = {
-	reportVersion: 1
+	reportVersion: 2
 	config: string | null
 	files: FileResult[]
 	failures: Failure[]
 	summary: {
 		checked: number
+		validated: number
 		schemaCovered: number
 		syntaxOnly: number
 		invalid: number

package/src/extensions/renovate.ts

@@ -0,0 +1,4 @@
+import type { AjvExtension } from "../core/extensions.ts"
+export function renovate(): AjvExtension {
+	return { id: "renovate", annotations: ["x-renovate-version"] }
+}

package/src/lsp/hints.ts

@@ -6,7 +6,8 @@ import {
 } 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 { ProjectSession } from "../runtime/session.ts"
 import type { Engine } from "../core/engine.ts"
 
 // Only the schema-selection accessor is hidden. The original AST (including
@@ -31,20 +32,19 @@ export class Hints {
 		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)
+		const editor = await engine.editor(file)
+		if (!editor) return undefined
+		const key = String(editor.association)
+
 		let services = this.services.get(engine)
 		if (!services) {
 			services = new Map()
 			this.services.set(engine, services)
 		}
-		let service = services.get(association.schema)
+		let service = services.get(key)
 		if (!service) {
 			service = getLanguageService({
-				schemaRequestService: async (uri) =>
-					JSON.stringify((await engine.store.load(uri)).schema),
+				schemaRequestService: (uri) => editor.support.readSchema(uri),
 				workspaceContext: {
 					resolveRelativePath: (relative, resource) =>
 						new URL(relative, resource).href,
@@ -53,13 +53,18 @@ export class Hints {
 			// A per-association service prevents overlapping rules being combined.
 			service.configure({
 				validate: false,
-				schemas: [{ uri: association.schema, fileMatch: ["*"] }],
+				schemas: [{ uri: editor.support.uri, fileMatch: ["*"] }],
 			})
-			services.set(association.schema, service)
+			services.set(key, service)
 		}
 		return service
 	}
-	async complete(engine: Engine, document: TextDocument, position: Position) {
+	async complete(
+		engine: Engine | ProjectSession,
+		document: TextDocument,
+		position: Position,
+	) {
+		if (!("editor" in engine)) return engine.complete(document, position)
 		const service = await this.service(engine, document)
 		return service
 			? await service.doComplete(
@@ -69,7 +74,12 @@ export class Hints {
 				)
 			: { isIncomplete: false, items: [] }
 	}
-	async hover(engine: Engine, document: TextDocument, position: Position) {
+	async hover(
+		engine: Engine | ProjectSession,
+		document: TextDocument,
+		position: Position,
+	) {
+		if (!("editor" in engine)) return engine.hover(document, position)
 		const service = await this.service(engine, document)
 		return service
 			? await service.doHover(

package/src/lsp/server.ts

@@ -92,7 +92,11 @@ export function startServer() {
 				?.dynamicRegistration ?? false
 		return {
 			capabilities: {
-				textDocumentSync: TextDocumentSyncKind.Incremental,
+				textDocumentSync: {
+					openClose: true,
+					change: TextDocumentSyncKind.Incremental,
+					save: { includeText: false },
+				},
 				completionProvider: { triggerCharacters: ['"', ":"] },
 				hoverProvider: true,
 				workspace: {
@@ -106,7 +110,7 @@ export function startServer() {
 		if (dynamicWatch)
 			void connection.client
 				.register(DidChangeWatchedFilesNotification.type, {
-					watchers: [{ globPattern: "**/*.{json,jsonc}" }],
+					watchers: [{ globPattern: "**/*" }],
 				})
 				.catch((error: unknown) => connection.console.error(String(error)))
 		connection.workspace.onDidChangeWorkspaceFolders((event) => {
@@ -171,6 +175,9 @@ export function startServer() {
 		if (document.uri.startsWith("file:") && workspace.close(document.uri))
 			scheduleAll()
 	})
+	documents.onDidSave(({ document }) => {
+		if (workspace.resourceChanged(document.uri)) refresh()
+	})
 	connection.onDidChangeWatchedFiles((params) => {
 		// Cache writes and unrelated JSON files must not trigger schema reloads.
 		if (params.changes.some((change) => workspace.resourceChanged(change.uri)))

package/src/lsp/workspace.ts

@@ -1,48 +1,36 @@
 import path from "node:path"
 import { fileURLToPath, pathToFileURL } from "node:url"
 import { TextDocument } from "vscode-languageserver-textdocument"
-import {
-	contains,
-	discoverConfig,
-	loadProject,
-	readText,
-	type ReadText,
-} from "../core/config.ts"
-import { Engine } from "../core/engine.ts"
+import { contains, discoverConfig, CONFIG_NAME } from "../core/config.ts"
+import { ProjectSession } from "../runtime/session.ts"
 import { CorrectlyError, failure, type FileResult } from "../core/types.ts"
 import { diagnostic } from "../core/parse.ts"
 
 export class Workspace {
 	onSchema: ((uri: string) => void) | undefined
 	roots: string[]
-	private readonly read: ReadText
 	readonly documents = new Map<string, TextDocument>()
-	private readonly engines = new Map<string, Promise<Engine>>()
-	private controller = new AbortController()
+	private readonly engines = new Map<string, ProjectSession>()
 	generation = 0
-	constructor(roots: string[], read: ReadText = readText) {
+	constructor(roots: string[]) {
 		this.roots = roots
-		this.read = read
 	}
 
 	invalidate() {
 		this.generation++
-		this.controller.abort()
-		this.controller = new AbortController()
+		for (const session of this.engines.values()) void session.dispose()
 		this.engines.clear()
 	}
 
 	open(document: TextDocument): boolean {
 		this.documents.set(document.uri, document)
 		const resource =
-			path.basename(fileURLToPath(document.uri)) === "correctly.config.json" ||
-			this.isSchema(document.uri)
+			this.isSchema(document.uri) && !this.moduleUris.has(document.uri)
 		if (resource) this.invalidate()
 		return resource
 	}
 	close(uri: string): boolean {
-		const resource =
-			uri.endsWith("/correctly.config.json") || this.isSchema(uri)
+		const resource = this.isSchema(uri) && !this.moduleUris.has(uri)
 		this.documents.delete(uri)
 		if (resource) this.invalidate()
 		return resource
@@ -51,15 +39,19 @@ export class Workspace {
 	private isSchema(uri: string): boolean {
 		return this.schemaUris.has(uri)
 	}
+	private readonly moduleUris = new Set<string>()
 	resourceChanged(uri: string): boolean {
-		return uri.endsWith("/correctly.config.json") || this.isSchema(uri)
-	}
-	private readonly readBuffer: ReadText = (uri) => {
-		const document = this.documents.get(uri)
-		return document ? Promise.resolve(document.getText()) : this.read(uri)
+		return (
+			uri.endsWith(`/${CONFIG_NAME}`) ||
+			this.isSchema(uri) ||
+			this.moduleUris.has(uri) ||
+			/\/(?:package\.json|pnpm-lock\.yaml|package-lock\.json|yarn\.lock)$/.test(
+				uri,
+			)
+		)
 	}
 
-	async engineFor(uri: string): Promise<Engine> {
+	async engineFor(uri: string): Promise<ProjectSession> {
 		const file = fileURLToPath(uri)
 		const root = this.roots
 			.filter((r) => contains(r, file))
@@ -69,36 +61,25 @@ export class Workspace {
 				"config",
 				`Document is outside the editor workspace: ${file}`,
 			)
-		const virtualConfigs = new Set(
-			[...this.documents.keys()]
-				.filter((key) => key.endsWith("/correctly.config.json"))
-				.map((key) => fileURLToPath(key)),
-		)
-		const configPath = await discoverConfig(
-			path.dirname(file),
-			root,
-			virtualConfigs,
-		)
-		let promise = this.engines.get(configPath)
-		if (!promise) {
-			const signal = this.controller.signal
-			promise = (async () => {
-				const project = await loadProject(configPath, this.readBuffer)
-				const readSchema: ReadText = async (schema) => {
-					this.schemaUris.add(schema)
-					this.onSchema?.(schema)
-					return this.readBuffer(schema)
-				}
-				const engine = new Engine(project, { read: readSchema, signal })
-				await engine.prepare()
-				for (const resource of engine.store.resources.values())
-					this.schemaUris.add(resource.uri)
-				signal.throwIfAborted()
-				return engine
-			})()
-			this.engines.set(configPath, promise)
+		const configPath = await discoverConfig(path.dirname(file), root)
+		let session = this.engines.get(configPath)
+		if (!session) {
+			session = new ProjectSession(configPath, {
+				buffers: [...this.documents].map(([uri, document]) => [
+					uri,
+					document.getText(),
+				]),
+				onDependency: (dependency, kind) => {
+					;(kind === "module" ? this.moduleUris : this.schemaUris).add(
+						dependency,
+					)
+					this.onSchema?.(dependency)
+				},
+			})
+			this.engines.set(configPath, session)
 		}
-		return promise
+		await session.ready
+		return session
 	}
 
 	async validate(document: TextDocument): Promise<FileResult> {
@@ -110,6 +91,20 @@ export class Workspace {
 			)
 		} catch (error) {
 			const problem = failure(error, fileURLToPath(document.uri))
+			if (
+				problem.code === "config" &&
+				problem.message.startsWith(`No ${CONFIG_NAME} found`) &&
+				!["json", "jsonc"].includes(document.languageId)
+			)
+				return {
+					file: fileURLToPath(document.uri),
+					mode: document.languageId,
+					association: null,
+					coverage: "excluded",
+					diagnostics: [],
+					failures: [],
+				}
+
 			return {
 				file: fileURLToPath(document.uri),
 				mode: document.languageId === "jsonc" ? "jsonc" : "json",

package/src/runtime/session.ts

@@ -0,0 +1,173 @@
+import { Worker } from "node:worker_threads"
+import type { TextDocument } from "vscode-languageserver-textdocument"
+import type { CompletionList, Hover } from "vscode-json-languageservice"
+import {
+	CorrectlyError,
+	type Failure,
+	type FileResult,
+	type Position,
+	type Report,
+} from "../core/types.ts"
+
+export type SessionOptions = {
+	offline?: boolean
+	buffers?: [string, string][]
+	onDependency?: (uri: string, kind: "module" | "resource") => void
+}
+export type CheckResult = { report: Report; sources: [string, string][] }
+/** Functions stay in this worker, which is replaced to invalidate native module caches. */
+export class ProjectSession {
+	private readonly worker: Worker
+	private readonly pending = new Map<
+		number,
+		{ resolve(value: unknown): void; reject(error: Error): void }
+	>()
+	private next = 0
+	private closed = false
+	private disposal: Promise<void> | undefined
+	readonly ready: Promise<void>
+	constructor(configPath: string, options: SessionOptions = {}) {
+		const source = import.meta.url.endsWith(".ts")
+		this.worker = new Worker(
+			new URL(source ? "./worker.ts" : "./worker.mjs", import.meta.url),
+			{ stdout: true, stderr: true },
+		)
+		this.worker.stdout?.on("data", (chunk: Buffer) =>
+			process.stderr.write(chunk),
+		)
+		this.worker.stderr?.on("data", (chunk: Buffer) =>
+			process.stderr.write(chunk),
+		)
+		this.worker.on(
+			"message",
+			(message: {
+				id?: number
+				value?: unknown
+				error?: Failure
+				dependency?: { uri: string; kind: "module" | "resource" }
+			}) => {
+				if (message.dependency) {
+					options.onDependency?.(
+						message.dependency.uri,
+						message.dependency.kind,
+					)
+					return
+				}
+				const pending = this.pending.get(message.id!)
+				if (!pending) return
+				this.pending.delete(message.id!)
+				if (message.error)
+					pending.reject(
+						new CorrectlyError(
+							message.error.code,
+							message.error.message,
+							message.error.details,
+						),
+					)
+				else pending.resolve(message.value)
+				if (!this.pending.size) this.worker.unref()
+			},
+		)
+		this.worker.on("error", (error) =>
+			this.fail(
+				new CorrectlyError(
+					"config",
+					`Project worker failed: ${error instanceof Error ? error.message : String(error)}`,
+				),
+			),
+		)
+		this.worker.on("exit", (code) =>
+			this.fail(
+				new CorrectlyError("config", `Project worker exited (${code})`),
+			),
+		)
+		this.ready = this.request<void>("init", {
+			configPath,
+			offline: options.offline,
+			buffers: options.buffers ?? [],
+		})
+		// Avoid an unhandled rejection if a project is invalidated before its consumer awaits it.
+		void this.ready.catch(() => {})
+	}
+	private fail(error: Error) {
+		this.closed = true
+		for (const pending of this.pending.values()) pending.reject(error)
+		this.pending.clear()
+	}
+	private request<T>(method: string, params: unknown): Promise<T> {
+		if (this.closed)
+			return Promise.reject(
+				new CorrectlyError("execution", "Project worker has been closed"),
+			)
+		const id = this.next++
+		this.worker.ref()
+		return new Promise<T>((resolve, reject) => {
+			this.pending.set(id, { resolve: (value) => resolve(value as T), reject })
+			this.worker.postMessage({ id, method, params })
+		})
+	}
+	async validate(file: string, text: string): Promise<FileResult> {
+		await this.ready
+		return this.request("validate", { file, text })
+	}
+	async complete(
+		document: TextDocument,
+		position: Position,
+	): Promise<CompletionList | null> {
+		await this.ready
+		return this.request("complete", {
+			uri: document.uri,
+			text: document.getText(),
+			language: document.languageId,
+			version: document.version,
+			position,
+		})
+	}
+	async hover(
+		document: TextDocument,
+		position: Position,
+	): Promise<Hover | null> {
+		await this.ready
+		return this.request("hover", {
+			uri: document.uri,
+			text: document.getText(),
+			language: document.languageId,
+			version: document.version,
+			position,
+		})
+	}
+	async check(params: {
+		cwd: string
+		files?: string[]
+		sources: boolean
+	}): Promise<CheckResult> {
+		await this.ready
+		return this.request("check", params)
+	}
+	dispose(): Promise<void> {
+		return (this.disposal ??= (async () => {
+			const finished = this.closed
+				? Promise.resolve()
+				: this.request("dispose", {}).catch(() => {})
+			this.closed = true
+			let timer: ReturnType<typeof setTimeout> | undefined
+			try {
+				await Promise.race([
+					finished,
+					new Promise<void>((resolve) => {
+						timer = setTimeout(resolve, 250)
+					}),
+				])
+			} finally {
+				clearTimeout(timer)
+				this.fail(
+					new CorrectlyError(
+						"execution",
+						"Project configuration was invalidated",
+					),
+				)
+				await this.worker.terminate()
+			}
+		})())
+	}
+}