remark-lint-frontmatter-schema 📑

Validate Markdown frontmatter YAML against an associated JSON schema with this remark-lint rule plugin.

Supports:

• Types validation, pattern, enumerations,… and all you can get with JSON Schema
• Code location problems indicator (for IDE to underline)
• Auto-fixes with suggestions
• Command Line Interface reports
• VS Code integration (see below)
• Global patterns or in-file schemas associations
• In JS framework MD / MDX pipelines

Demo

---

Jump to:

• 👉  Play with pre-configured ./demo
  • Base
  • VS Code (optional)
  • CLI / IDE (VS Code) — Static linting
    • Workspace
    • Schema example
      • 🆕  Add references to external definitions (advanced)
    • Schemas associations
      • Inside frontmatter
      • Globally, with patterns
    • CLI usage
    • Bonus
      • Validate your schema with JSON meta schema
      • ESLint MDX plugin setup
        • Known issues
  • MD / MDX pipeline — Runtime validation
    • Custom pipeline
      • Implementation living example
      • Important foot-notes for custom pipeline
    • Framework
      • Astro
      • Gatsby

---

---

---

---

👉  Play with pre-configured ./demo

Quick shallow clone with:

1pnpx degit JulianCataldo/remark-lint-frontmatter-schema/demo ./demo

---

Installation

Base

1pnpm install -D \
2remark remark-cli \
3remark-frontmatter \
4remark-lint-frontmatter-schema

Remove -D flag for runtime unified MD / MDX pipeline (custom, Astro, Gatsby, etc.), for production.
Keep it if you just want to lint with CLI or your IDE locally, without any production / CI needs.

VS Code (optional)

1code --install-extension unifiedjs.vscode-remark

Configuration

CLI / IDE (VS Code) — Static linting

👉  See ./demo folder to get a working, pre-configured, bare project workspace.
You also get example Markdown files and associated schema to play with.
Supports remark-cli and/or unifiedjs.vscode-remark extension.

📌  Check out the demo/README.md for bootstrapping it.

Workspace

Create the root config. file for remark to source from:
touch ./.remarkrc.mjs

Paste this base configuration:

1import remarkFrontmatter from 'remark-frontmatter';
2import remarkLintFrontmatterSchema from 'remark-lint-frontmatter-schema';
3
4const remarkConfig = {
5	plugins: [remarkFrontmatter, remarkLintFrontmatterSchema],
6};
7export default remarkConfig;

You can use YAML / JSON / …, too (uses cosmiconfig).

Schema example

./content/creative-work.schema.yaml

1type: object
2properties:
3  title:
4    type: string
5# …

🆕  Add references to external definitions (advanced)

Referencing schema definitions allows re-using bit and piece instead of duplicate them, accross your content schemas.

You can reference an external schema relatively, using $ref. For example we can -kind of- merge an host object with a reference properties:

The host schema, content/articles/index.schema.yaml

1allOf:
2  - $ref: ../page.schema.yaml
3
4  - properties:
5      layout:
6        const: src/layouts/Article.astro
7      category:
8        type: string
9        enum:
10          - Book
11          - Movie
12      foo:
13        type: string
14
15    required:
16      - layout
17      - category

A referenced schema, content/page.schema.yaml

1properties:
2  title:
3    type: string
4    maxLength: 80
5    # ...
6  # ...
7
8required:
9  - title

The result will be (virtually) the same as this:

1properties:
2  title:
3    type: string
4    maxLength: 80
5    # ...
6  # ...
7  layout:
8    const: src/layouts/Article.astro
9  category:
10    type: string
11    enum:
12      - Book
13      - Movie
14  foo:
15    type: string
16  # ...
17
18required:
19  - title
20  - layout
21  - category

Schemas associations

Inspired by VS Code JSON Schema and redhat.vscode-yaml conventions.

Inside frontmatter

See ./demo/content files for examples.

Schema association can be done directly inside the frontmatter of the Markdown file, relative to project root, thanks to the '$schema' key:

1---
2# From workspace root (`foo/…`, `/foo/…` or `./foo/…` is the same)
3'$schema': content/creative-work.schema.yaml
4
5# —Or— relatively, from this current file directory (`./foo/…` or `../foo/…`)
6# '$schema': ../creative-work.schema.yaml
7
8layout: src/layouts/Article.astro
9
10title: Hello there
11category: Book
12# …
13---
14
15# You're welcome!
16
17🌝  My **Markdown** content…  🌚
18…

Globally, with patterns

Note:
Locally defined '$schema' takes precedence over global settings below.

1const remarkConfig = {
2	plugins: [
3		remarkFrontmatter,
4		[
5			remarkLintFrontmatterSchema,
6			{
7				schemas: {
8					/* One schema for many files */
9					'./content/creative-work.schema.yaml': [
10						/* Per-file association */
11						'./content/creative-work/the-shipwreck__global-broken.md',
12
13						/* Support glob patterns ———v */
14						// './content/creative-work/*.md',
15						// …
16						// `./` prefix is optional
17						// 'content/creative-work/foobiz.md',
18					],
19
20					// './content/ghost.schema.yaml': [
21					//   './content/casper.md',
22					//   './content/ether.md',
23					// ],
24				},
25			},
26		],
27	],
28};

'./foo', '/foo', 'foo', all will work.
It's always relative to your ./.remarkrc.mjs file, in your workspace root.

CLI usage

Linting whole workspace files (as ./**/*.md) with remark-cli:

1pnpm remark .

Yields:

Bonus

Validate your schema with JSON meta schema

First, install the YAML for Visual Studio Code extension:

1code --install-extension redhat.vscode-yaml

Then, add this to your .vscode/settings.json:

1{
2	"yaml.schemas": {
3		"http://json-schema.org/draft-07/schema#": ["content/**/*.schema.yaml"]
4	}
5	/* ... */
6}

ESLint MDX plugin setup

Will work with the ESLint VS Code extension and the CLI command.

Install the ESLint MDX plugin, the MDX VS Code extension and the ESLint VS Code extension.

Add this dependencies to your project:

1pnpm i -D eslint eslint-plugin-mdx \
2eslint-plugin-prettier eslint-config-prettier

Add a .eslintrc.cjs:

1/** @type {import("@types/eslint").Linter.Config} */
2
3module.exports = {
4	overrides: [
5		{
6			files: ['*.md', '*.mdx'],
7			extends: ['plugin:mdx/recommended'],
8		},
9	],
10};

Add a .remarkrc.yaml (or JSON, etc.), e.g.:

1plugins:
2  - remark-frontmatter
3
4  - - remark-lint-frontmatter-schema
5    - schemas:
6        src/schemas/blog-post.schema.yaml:
7          - content/blog-posts/*.{md,mdx}
8
9  # - remark-preset-lint-consistent
10  # - remark-preset-lint-markdown-style-guide
11  # - remark-preset-lint-recommended

---

Result:

---

Lint with CLI:

1pnpm eslint --ext .mdx .

Efforts has been made to have the best output for both remark and ESLint, for IDE extensions and CLIs.

Known issues

• Expected enum values suggestions are working with the remark extension, not with the ESLint one.
• Similarly, ESLint output will give less details (see screenshot above), and a bit different layout for CLI output, too.
• remark extension seems to load faster, and is more reactive to schema changes.
• As of eslint-plugin-mdx@2, .remarkrc.mjs (ES Module) is not loaded, JSON and YAML configs are fine.

MD / MDX pipeline — Runtime validation

Use it as usual like any remark plugin inside your framework or your custom unified pipeline.

Custom pipeline

When processing Markdown as single files inside your JS/TS app.
An minimal example is provided in ./demo/pipeline.ts, you can launch it with pnpm pipeline from ./demo.

---

Schema should be provided programmatically like this:

1// …
2import remarkFrontmatter from 'remark-frontmatter';
3import remarkLintFrontmatterSchema from 'remark-lint-frontmatter-schema';
4import type { JSONSchema7 } from 'json-schema';
5import { reporter } from 'vfile-reporter';
6
7const mySchema: JSONSchema7 = {
8	/* … */
9};
10
11const output = await unified()
12	// Your pipeline (basic example)
13	.use(remarkParse)
14	// …
15	.use(remarkFrontmatter)
16
17	.use(remarkLintFrontmatterSchema, {
18		/* Bring your own schema */
19		embed: mySchema,
20	})
21
22	// …
23	.use(remarkRehype)
24	.use(rehypeStringify)
25	.use(rehypeFormat)
26	.process(theRawMarkdownLiteral);
27
28/* `path` is for debugging purpose here, as MD literal comes from your app. */
29output.path = './the-current-processed-md-file.md';
30
31console.error(reporter([output]));

Yields:

./the-current-processed-md-file.md
  1:1  warning  Must have required property 'tag'  frontmatter-schema  remark-lint

⚠ 1 warning

Implementation living example

Checkout Astro Content repository.

Astro Content relies on this library, among others, for providing linting reports.

Important foot-notes for custom pipeline

This is different from static linting, with VS Code extension or CLI.
It will not source .remarkrc (but you can source it by your own means, if you want).
In fact, it's not aware of your file structure, nor it will associate or import any schema / Markdown files.
That way, it will integrate easier with your own business logic and existing pipelines.
I found that static linting (during editing) / and runtime validation are two different uses cases enough to separate them in their setups, but I might converge them partially.

Framework

Warning
WIP. NOT tested yet! It is not a common use case for remark-lint.
Linting data inside frameworks are generally ignored.
AFAIK, messages data isn't forwarded to CLI output.
Feel free to open a PR if you have some uses cases in this area that need special care.
Maybe Astro or Astro Content could leverage these linter warnings in the future.

See global patterns schemas associations for settings reference.

Astro

In astro.config.mjs

1// …
2export default defineConfig({
3  // …
4  remarkPlugins: [
5    // …
6    'remark-frontmatter',
7    ['remark-lint-frontmatter-schema', { schemas }],
8    // …
9  ];
10  // …
11});

Gatsby

In gatsby-config.js

1{
2	// …
3	plugins: [
4		// …
5		{
6			resolve: 'gatsby-transformer-remark',
7			options: {
8				plugins: [
9					// …
10					'remark-frontmatter',
11					['remark-lint-frontmatter-schema', { schemas }],
12					// …
13				],
14			},
15		},
16		// …
17	];
18}

Interfaces

1export interface Settings {
2	/**
3	 * Global workspace file associations mapping (for linter extension).
4	 *
5	 * **Example**: `'schemas/thing.schema.yaml': ['content/things/*.md']`
6	 */
7	schemas?: Record<string, string[]>;
8
9	/**
10	 * Direct schema embedding (for using inside an `unified` transform pipeline).
11	 *
12	 * Format: JSON Schema - draft-2019-09
13	 *
14	 * **Documentation**: https://ajv.js.org/json-schema.html#draft-07
15	 */
16	embed?: JSONSchema7;
17
18	/**
19	 * **Documentation**: https://ajv.js.org/options.html
20	 */
21	ajvOptions?: AjvOptions;
22}
23
24export interface FrontmatterSchemaMessage extends VFileMessage {
25	schema: AjvErrorObject & { url: JSONSchemaReference };
26}

Example of a VFileMessage content you could collect from this lint rule:

1[
2	// …
3	{
4		// JS native `Error`
5		"name": "Markdown YAML frontmatter error (JSON Schema)",
6		"message": "Keyword: type\nType: string\nSchema path: #/properties/title/type",
7
8		// `VFileMessage` (Linter / VS Code…)
9		"reason": "/clientType: Must be equal to one of the allowed values",
10		"line": 16,
11		"column": 13,
12		"url": "https://github.com/JulianCataldo/remark-lint-frontmatter-schema",
13		"source": "remark-lint",
14		"ruleId": "frontmatter-schema",
15		"position": {
16			"start": {
17				"line": 16,
18				"column": 13
19			},
20			"end": {
21				"line": 16,
22				"column": 24
23			}
24		},
25		"fatal": false,
26		"actual": "Individuaaaaaaaal",
27		"expected": ["Corporate", "Non-profit", "Individual"],
28		// Condensed string, human readable version of AJV error object
29		"note": "Keyword: enum\nAllowed values: Corporate, Non-profit, Individual\nSchema path: #/properties/clientType/enum",
30
31		// AJV's `ErrorObject`
32		"schema": {
33			"url": "https://ajv.js.org/json-schema.html",
34			"instancePath": "/clientType",
35			"schemaPath": "#/properties/clientType/enum",
36			"keyword": "enum",
37			"params": {
38				"allowedValues": ["Corporate", "Non-profit", "Individual"]
39			},
40			"message": "must be equal to one of the allowed values"
41		}
42	}
43]

---

Footnotes

100% ESM, including dependencies.

Environments:

• CLI Tool

  Remark lint | https://github.com/remarkjs/remark-lint

• IDE Extension (optional)

  VS Code unifiedjs.vscode-remark
  https://github.com/remarkjs/vscode-remark

Major dependencies:

ajv, yaml, remark, remark-frontmatter, unified, remark-cli

---

See CHANGELOG.md for release history.

---

Other projects 👀…

• retext-case-police: Check popular names casing. Example: ⚠️ github → ✅ GitHub.
• remark-embed: A remark plugin for embedding remote / local Markdown or code snippets.
• astro-content: A text based, structured content manager, for edition and consumption.
• Web garden: Building blocks for making progressive and future-proof websites.

---

---

🔗  JulianCataldo.com