Refactor vitest integration to use a plugin

Author: jdesrosiers

README.md

@@ -61,17 +61,16 @@ script.
 `vitest-schema.config.js`
 ```TypeScript
 import { defineConfig } from "vitest/config";
-import type { JsonSchemaCoverageProviderOptions } from "@hyperjump/json-schema-coverage/vitest/coverage-provider";
+import { jsonSchemaCoveragePlugin } from "@hyperjump/json-schema-coverage/vitest";
 
 export default defineConfig({
+  plugins: [jsonSchemaCoveragePlugin()],
   test: {
     globalSetup: ["./register-my-dialect.ts"], // Optional
     include: ["schema-tests/"], // Optional
     coverage: {
-      provider: "custom",
-      customProviderModule: "@hyperjump/json-schema-coverage/vitest/coverage-provider",
       include: ["schemas/**/*.json"] // Optional
-    } as JsonSchemaCoverageProviderOptions
+    }
   }
 });
 ```
@@ -85,7 +84,6 @@ if vitest has coverage enabled, it will collect coverage data from those tests.
 
 ```JavaScript
 import { describe, expect, test } from "vitest";
-import "@hyperjump/json-schema-coverage/vitest-matchers";
 
 describe("Worksheet", () => {
   test("matches with chai-style matcher", async () => {
@@ -107,7 +105,6 @@ for the validation to work.
 
 ```JavaScript
 import { describe, expect, test } from "vitest";
-import { registerSchema, unregisterSchema } from "@hyperjump/json-schema-coverage/vitest";
 
 describe("Worksheet", () => {
   beforeEach(async () => {
@@ -135,7 +132,6 @@ schemas from files in your code base.
 
 ```JavaScript
 import { describe, expect, test } from "vitest";
-import "@hyperjump/json-schema-coverage/vitest-matchers";
 
 describe("Worksheet", () => {
   test("matches with schema", async () => {
@@ -158,6 +154,10 @@ These are the functions available when working with the vitest integration.
 import { ... } from "@hyperjump/json-schema-coverage/vitest"
 ```
 
+- **jsonSchemaCoveragePlugin**: () => VitestPlugin
+
+    A function that returns a Vitest plugin that registers matchers and sets up
+    JSON Schema coverage if enabled.
 - **matchJsonSchema**: (uriOrSchema: string | SchemaObject | boolean) => Promise\<void>
 
     A vitest matcher that can be used to validate a JSON-compatible value. It

package.json

@@ -21,8 +21,7 @@
   "type": "module",
   "exports": {
     ".": "./src/index.js",
-    "./vitest": "./src/vitest/index.js",
-    "./vitest/coverage-provider": "./src/vitest/coverage-provider.js"
+    "./vitest": "./src/vitest/index.js"
   },
   "scripts": {
     "lint": "eslint src",

src/vitest/build-coverage-maps.js

@@ -3,7 +3,7 @@ import { readFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { glob } from "tinyglobby";
 import ignore from "ignore";
-import { registerSchema } from "./json-schema-matchers.js";
+import { registerSchema } from "./index.js";
 import { FileCoverageMapService } from "./file-coverage-map-service.js";
 
 /**

src/vitest/coverage-provider.d.ts

@@ -30,7 +30,7 @@ const JsonSchemaCoverageProviderModule = {
 
 /** @implements CoverageProvider */
 class JsonSchemaCoverageProvider {
-  name = "@hyperjump/json-schema-coverage/vitest/coverage-provider";
+  name = "@hyperjump/json-schema-coverage/vitest";
 
   ctx = /** @type Vitest */ ({});
 

src/vitest/coverage-provider.js

@@ -1,13 +1,7 @@
-import type { SchemaObject } from "@hyperjump/json-schema";
 import type { AsyncExpectationResult } from "@vitest/expect";
-import "vitest";
-
-declare module "vitest" {
-  interface Matchers<R = unknown> {
-    matchJsonSchema: (uriOrSchema: string | SchemaObject | boolean) => Promise<R>;
-    toMatchJsonSchema: (uriOrSchema: string | SchemaObject | boolean) => Promise<R>;
-  }
-}
+import type { Plugin } from "vite";
+import type { SchemaObject } from "@hyperjump/json-schema";
+import JsonSchemaCoverageProvider from "./coverage-provider.js";
 
 /**
  * Register a schema in your code base by it's path.
@@ -25,6 +19,12 @@ export const registerSchema: (filePath: string) => Promise<void>;
  */
 export const unregisterSchema: (filePath: string) => Promise<void>;
 
+/**
+ * Use this Vitest plugin in your Vitest config to enable the matchers and
+ * coverage support.
+ */
+export const jsonSchemaCoveragePlugin: () => Plugin;
+
 /**
  * A vitest matcher that can be used to validate a JSON-compatible value. It
  * can take a relative or full URI for a schema in your codebase. Use relative
@@ -33,8 +33,9 @@ export const unregisterSchema: (filePath: string) => Promise<void>;
  *
  * You can use this matcher with an inline schema as well, but you will only
  * get coverage for schemas that are in files.
- *
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const matchJsonSchema: (instance: any, uriOrSchema: string | SchemaObject | boolean) => AsyncExpectationResult;
 export const toMatchJsonSchema: typeof matchJsonSchema;
+
+export default JsonSchemaCoverageProvider;

src/vitest/index.d.ts

@@ -1,10 +1,73 @@
 /** @module vitest */
-import { expect } from "vitest";
-import { matchJsonSchema, toMatchJsonSchema } from "./json-schema-matchers.js";
+import { readFile } from "node:fs/promises";
+import { extname } from "node:path";
+import { pathToFileURL } from "node:url";
+import { registerSchema as register, unregisterSchema as unregister } from "./json-schema.js";
+import { getKeywordId, getKeywordName } from "@hyperjump/json-schema/experimental";
+import YAML from "yaml";
+import { toAbsoluteIri } from "@hyperjump/uri";
+import JsonSchemaCoverageProvider from "./coverage-provider.js";
 
-expect.extend({
-  matchJsonSchema: matchJsonSchema,
-  toMatchJsonSchema: toMatchJsonSchema
-});
+/**
+ * @import { SchemaObject } from "@hyperjump/json-schema"
+ */
+// @ts-expect-error There appears to be a bug in TypeScript
+/** @import * as API from "./index.d.ts" */
 
+export * from "./json-schema-coverage-plugin.js";
 export * from "./json-schema-matchers.js";
+
+/** @type API.registerSchema */
+export const registerSchema = async (schemaPath) => {
+  const text = await readFile(schemaPath, "utf-8");
+  const extension = extname(schemaPath);
+
+  /** @type SchemaObject */
+  let schema;
+  switch (extension) {
+    case ".json":
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      schema = JSON.parse(text);
+      break;
+    case ".yaml":
+    case ".yml":
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      schema = YAML.parse(text);
+      break;
+    default:
+      throw Error(`File of type '${extension}' is not supported.`);
+  }
+
+  register(schema);
+};
+
+/** @type (schemaPath: string) => Promise<void> */
+export const unregisterSchema = async (schemaPath) => {
+  const text = await readFile(schemaPath, "utf-8");
+  const extension = extname(schemaPath);
+
+  /** @type SchemaObject */
+  let schema;
+  switch (extension) {
+    case ".json":
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      schema = JSON.parse(text);
+      break;
+    case ".yaml":
+    case ".yml":
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      schema = YAML.parse(text);
+      break;
+    default:
+      throw Error(`File of type '${extension}' is not supported.`);
+  }
+
+  const dialectUri = toAbsoluteIri(/** @type string */ (schema.$schema));
+  const idToken = getKeywordName(dialectUri, "https://json-schema.org/keyword/id")
+    ?? getKeywordId("https://json-schema.org/keyword/draft-04/id", dialectUri);
+  const schemaUri = /** @type string */ (schema[idToken]) ?? pathToFileURL(schemaPath).toString();
+
+  unregister(schemaUri);
+};
+
+export default JsonSchemaCoverageProvider;

src/vitest/index.js

@@ -0,0 +1,24 @@
+/**
+ * @import { Plugin } from "vite"
+ * @import { VitestPluginContext, ResolvedCoverageOptions } from "vitest/node"
+ */
+
+import { resolve } from "path";
+
+/** @type () => Plugin */
+export const jsonSchemaCoveragePlugin = () => {
+  return {
+    name: "json-schema-coverage-plugin",
+
+    /** @type (context: VitestPluginContext) => void */
+    configureVitest(context) {
+      const config = context.vitest.config;
+
+      const coverage = /** @type ResolvedCoverageOptions<"custom"> */ (config.coverage);
+      coverage.provider = "custom";
+      coverage.customProviderModule = resolve(import.meta.dirname, "./coverage-provider.js");
+
+      config.setupFiles.push(resolve(import.meta.dirname, "./register-matchers.js"));
+    }
+  };
+};

src/vitest/json-schema-coverage-plugin.js

@@ -1,17 +1,14 @@
 import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
-import { readFile, writeFile } from "node:fs/promises";
-import { extname, join } from "node:path";
-import { pathToFileURL } from "node:url";
-import { registerSchema as register, unregisterSchema as unregister, validate } from "./json-schema.js";
-import { getKeywordId, getKeywordName, BASIC } from "@hyperjump/json-schema/experimental";
-import YAML from "yaml";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { registerSchema, unregisterSchema, validate } from "./json-schema.js";
+import { BASIC } from "@hyperjump/json-schema/experimental";
 import { FileCoverageMapService } from "./file-coverage-map-service.js";
 import { TestCoverageEvaluationPlugin } from "../test-coverage-evaluation-plugin.js";
-import { toAbsoluteIri } from "@hyperjump/uri";
 
 /**
- * @import { OutputUnit, SchemaObject } from "@hyperjump/json-schema"
+ * @import { OutputUnit } from "@hyperjump/json-schema"
  * @import * as API from "./index.d.ts"
  */
 
@@ -51,12 +48,12 @@ export const matchJsonSchema = async (instance, uriOrSchema) => {
   } else {
     const schema = uriOrSchema;
     const uri = `urn:uuid:${randomUUID()}`;
-    register(schema, uri, "https://json-schema.org/draft/2020-12/schema");
+    registerSchema(schema, uri, "https://json-schema.org/draft/2020-12/schema");
     try {
       // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
       output = await validate(uri, instance, BASIC);
     } finally {
-      unregister(uri);
+      unregisterSchema(uri);
     }
   }
 
@@ -67,56 +64,3 @@ export const matchJsonSchema = async (instance, uriOrSchema) => {
 };
 
 export const toMatchJsonSchema = matchJsonSchema;
-
-/** @type API.registerSchema */
-export const registerSchema = async (schemaPath) => {
-  const text = await readFile(schemaPath, "utf-8");
-  const extension = extname(schemaPath);
-
-  /** @type SchemaObject */
-  let schema;
-  switch (extension) {
-    case ".json":
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-      schema = JSON.parse(text);
-      break;
-    case ".yaml":
-    case ".yml":
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-      schema = YAML.parse(text);
-      break;
-    default:
-      throw Error(`File of type '${extension}' is not supported.`);
-  }
-
-  register(schema);
-};
-
-/** @type (schemaPath: string) => Promise<void> */
-export const unregisterSchema = async (schemaPath) => {
-  const text = await readFile(schemaPath, "utf-8");
-  const extension = extname(schemaPath);
-
-  /** @type SchemaObject */
-  let schema;
-  switch (extension) {
-    case ".json":
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-      schema = JSON.parse(text);
-      break;
-    case ".yaml":
-    case ".yml":
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-      schema = YAML.parse(text);
-      break;
-    default:
-      throw Error(`File of type '${extension}' is not supported.`);
-  }
-
-  const dialectUri = toAbsoluteIri(/** @type string */ (schema.$schema));
-  const idToken = getKeywordName(dialectUri, "https://json-schema.org/keyword/id")
-    ?? getKeywordId("https://json-schema.org/keyword/draft-04/id", dialectUri);
-  const schemaUri = /** @type string */ (schema[idToken]) ?? pathToFileURL(schemaPath).toString();
-
-  unregister(schemaUri);
-};

src/vitest/json-schema-matchers.js

@@ -0,0 +1,9 @@
+import type { SchemaObject } from "@hyperjump/json-schema";
+import "vitest";
+
+declare module "vitest" {
+  interface Matchers<R = unknown> {
+    matchJsonSchema: (uriOrSchema: string | SchemaObject | boolean) => Promise<R>;
+    toMatchJsonSchema: (uriOrSchema: string | SchemaObject | boolean) => Promise<R>;
+  }
+}