[TypeSpecValidation] Implement as ESLint Rules

.github/workflows/eslint-plugin-tsv-test.yaml

@@ -0,0 +1,25 @@
+name: ESLint Plugin for TypeSpec Validation - Test
+
+on:
+  push:
+    branches:
+      - main
+      - typespec-next
+  pull_request:
+    paths:
+      - package-lock.json
+      - package.json
+      - tsconfig.json
+      - .github/workflows/_reusable-eng-tools-test.yaml
+      - .github/workflows/eslint-plugin-tsv-test.yaml
+      - eng/tools/package.json
+      - eng/tools/tsconfig.json
+      - eng/tools/eslint-plugin-tsv/**
+      - specification/contosowidgetmanager
+  workflow_dispatch:
+
+jobs:
+  eslint-plugin-tsv:
+    uses: ./.github/workflows/_reusable-eng-tools-test.yaml
+    with:
+      package: eslint-plugin-tsv

eng/tools/eslint-plugin-tsv/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@azure-tools/eslint-plugin-tsv",
+  "private": true,
+  "type": "module",
+  "main": "src/index.js",
+  "dependencies": {
+    "ajv": "^8.17.1",
+    "yaml-eslint-parser": "^1.2.3"
+  },
+  "peerDependencies": {
+    "eslint": ">=9.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^18.19.31",
+    "@vitest/coverage-v8": "^3.0.2",
+    "eslint": "^9.17.0",
+    "memfs": "^4.15.0",
+    "rimraf": "^5.0.10",
+    "typescript": "~5.6.2",
+    "vitest": "^3.0.2"
+  },
+  "scripts": {
+    "build": "tsc --build",
+    "cbt": "npm run clean && npm run build && npm run test:ci",
+    "clean": "rimraf ./dist ./temp",
+    "test": "vitest",
+    "test:ci": "vitest run --coverage --reporter=verbose"
+  },
+  "engines": {
+    "node": ">= 18.0.0"
+  }
+}

eng/tools/eslint-plugin-tsv/src/config/config-schema.ts

@@ -0,0 +1,117 @@
+// Copied from https://github.com/microsoft/typespec/blob/main/packages/compiler/src/config/config-schema.ts
+
+import type { JSONSchemaType } from "ajv";
+import { EmitterOptions, TypeSpecRawConfig } from "./types.js";
+
+export const emitterOptionsSchema: JSONSchemaType<EmitterOptions> = {
+  type: "object",
+  additionalProperties: true,
+  required: [],
+  properties: {
+    "emitter-output-dir": { type: "string", nullable: true } as any,
+  },
+};
+
+export const TypeSpecConfigJsonSchema: JSONSchemaType<TypeSpecRawConfig> = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    extends: {
+      type: "string",
+      nullable: true,
+    },
+    "environment-variables": {
+      type: "object",
+      nullable: true,
+      required: [],
+      additionalProperties: {
+        type: "object",
+        properties: {
+          default: { type: "string" },
+        },
+        required: ["default"],
+      },
+    },
+    parameters: {
+      type: "object",
+      nullable: true,
+      required: [],
+      additionalProperties: {
+        type: "object",
+        properties: {
+          default: { type: "string" },
+        },
+        required: ["default"],
+      },
+    },
+
+    "output-dir": {
+      type: "string",
+      nullable: true,
+    },
+    "warn-as-error": {
+      type: "boolean",
+      nullable: true,
+    },
+    trace: {
+      oneOf: [
+        { type: "string" },
+        {
+          type: "array",
+          items: { type: "string" },
+        },
+      ],
+    } as any, // Issue with AJV optional property typing https://github.com/ajv-validator/ajv/issues/1664
+    imports: {
+      type: "array",
+      nullable: true,
+      items: { type: "string" },
+    },
+    emit: {
+      type: "array",
+      nullable: true,
+      items: { type: "string" },
+    },
+    options: {
+      type: "object",
+      nullable: true,
+      required: [],
+      additionalProperties: emitterOptionsSchema,
+    },
+    emitters: {
+      type: "object",
+      nullable: true,
+      deprecated: true,
+      required: [],
+      additionalProperties: {
+        oneOf: [{ type: "boolean" }, emitterOptionsSchema],
+      },
+    },
+
+    linter: {
+      type: "object",
+      nullable: true,
+      required: [],
+      additionalProperties: false,
+      properties: {
+        extends: {
+          type: "array",
+          nullable: true,
+          items: { type: "string" },
+        },
+        enable: {
+          type: "object",
+          required: [],
+          nullable: true,
+          additionalProperties: { type: "boolean" },
+        },
+        disable: {
+          type: "object",
+          required: [],
+          nullable: true,
+          additionalProperties: { type: "string" },
+        },
+      },
+    } as any, // ajv type system doesn't like the string templates
+  },
+};

eng/tools/eslint-plugin-tsv/src/config/types.ts

@@ -0,0 +1,112 @@
+// Copied from https://github.com/microsoft/typespec/blob/main/packages/compiler/src/config/types.ts
+
+import type { Diagnostic, RuleRef } from "@typespec/compiler";
+import type { YamlScript } from "../yaml/types.js";
+
+/**
+ * Represent the normalized user configuration.
+ */
+export interface TypeSpecConfig {
+  /**
+   * Project root.
+   */
+  projectRoot: string;
+
+  /** Yaml file used in this configuration. */
+  file?: YamlScript;
+
+  /**
+   * Path to the config file used to create this configuration.
+   */
+  filename?: string;
+
+  /**
+   * Diagnostics reported while loading the configuration
+   */
+  diagnostics: Diagnostic[];
+
+  /**
+   * Path to another TypeSpec config to extend.
+   */
+  extends?: string;
+
+  /**
+   * Environment variables configuration
+   */
+  environmentVariables?: Record<string, ConfigEnvironmentVariable>;
+
+  /**
+   * Parameters that can be used
+   */
+  parameters?: Record<string, ConfigParameter>;
+
+  /**
+   * Treat warning as error.
+   */
+  warnAsError?: boolean;
+
+  /**
+   * Output directory
+   */
+  outputDir: string;
+
+  /**
+   * Trace options.
+   */
+  trace?: string[];
+
+  /**
+   * Additional imports.
+   */
+  imports?: string[];
+
+  /**
+   * Name of emitters or path to emitters that should be used.
+   */
+  emit?: string[];
+
+  /**
+   * Name of emitters or path to emitters that should be used.
+   */
+  options?: Record<string, EmitterOptions>;
+
+  linter?: LinterConfig;
+}
+
+/**
+ * Represent the configuration that can be provided in a config file.
+ */
+export interface TypeSpecRawConfig {
+  extends?: string;
+  "environment-variables"?: Record<string, ConfigEnvironmentVariable>;
+  parameters?: Record<string, ConfigParameter>;
+
+  "warn-as-error"?: boolean;
+  "output-dir"?: string;
+  trace?: string | string[];
+  imports?: string[];
+
+  emit?: string[];
+  options?: Record<string, EmitterOptions>;
+  emitters?: Record<string, boolean | EmitterOptions>;
+
+  linter?: LinterConfig;
+}
+
+export interface ConfigEnvironmentVariable {
+  default: string;
+}
+
+export interface ConfigParameter {
+  default: string;
+}
+
+export type EmitterOptions = Record<string, unknown> & {
+  "emitter-output-dir"?: string;
+};
+
+export interface LinterConfig {
+  extends?: RuleRef[];
+  enable?: Record<RuleRef, boolean>;
+  disable?: Record<RuleRef, string>;
+}

eng/tools/eslint-plugin-tsv/src/eslint-plugin-tsv.ts

@@ -0,0 +1,29 @@
+import parser from "yaml-eslint-parser";
+import { NamedESLint } from "./interfaces/named-eslint.js";
+import emitAutorest from "./rules/emit-autorest.js";
+import kebabCaseOrg from "./rules/kebab-case-org.js";
+
+const plugin: NamedESLint.Plugin = {
+  configs: { recommended: {} },
+  name: "tsv",
+  rules: {
+    [kebabCaseOrg.name]: kebabCaseOrg,
+    [emitAutorest.name]: emitAutorest,
+  },
+};
+
+plugin.configs.recommended = {
+  plugins: {
+    [plugin.name]: plugin,
+  },
+  files: ["*.yaml", "**/*.yaml"],
+  rules: {
+    [`${plugin.name}/${kebabCaseOrg.name}`]: "error",
+    [`${plugin.name}/${emitAutorest.name}`]: "error",
+  },
+  languageOptions: {
+    parser: parser,
+  },
+};
+
+export default plugin;

eng/tools/eslint-plugin-tsv/src/interfaces/named-eslint.ts

@@ -0,0 +1,17 @@
+import { ESLint, Linter, Rule } from "eslint";
+
+// ESLint with names for convenience
+
+export namespace NamedRule {
+  export interface RuleModule extends Rule.RuleModule {
+    name: string;
+  }
+}
+
+export namespace NamedESLint {
+  export interface Plugin extends ESLint.Plugin {
+    configs: { recommended: Linter.Config };
+    name: string;
+    rules?: Record<string, NamedRule.RuleModule>;
+  }
+}

eng/tools/eslint-plugin-tsv/src/rules/emit-autorest.ts

@@ -0,0 +1,59 @@
+import { Ajv } from "ajv";
+import { Rule } from "eslint";
+import { AST, getStaticYAMLValue } from "yaml-eslint-parser";
+import { TypeSpecConfigJsonSchema } from "../config/config-schema.js";
+import { TypeSpecConfig } from "../config/types.js";
+import { NamedRule } from "../interfaces/named-eslint.js";
+
+export const rule: NamedRule.RuleModule = {
+  name: "emit-autorest",
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Requires emitter 'typespec-autorest' to be enabled by default, and requires emitted autorest to match content in repo",
+    },
+    schema: [],
+    messages: {
+      invalid: "tspconfig.yaml is invalid per the schema: {{errors}}",
+      missing:
+        'tspconfig.yaml must include the following emitter by default:\n\nemit:\n  - "@azure-tools/typespec-autorest"',
+      // disabled: "Path does not match format '.*/specification/{orgName}/': ''{{filename}}'",
+      // autorestDiff: "Emitted autorest does not match content in repo",
+    },
+  },
+  create(context) {
+    return {
+      YAMLDocument(node: Rule.Node) {
+        const yamlDocument = node as unknown as AST.YAMLDocument;
+
+        // If config yaml is empty, use empty object instead of "null"
+        const config = getStaticYAMLValue(yamlDocument) || {};
+
+        const ajv = new Ajv();
+        const valid = ajv.validate(TypeSpecConfigJsonSchema, config);
+
+        if (!valid) {
+          context.report({
+            node,
+            messageId: "invalid",
+            data: { errors: ajv.errorsText(ajv.errors) },
+          });
+          return;
+        }
+
+        const typedConfig = config as unknown as TypeSpecConfig;
+        if (!typedConfig.emit?.includes("@azure-tools/typespec-autorest")) {
+          // TODO: Move error message to "emit:" node
+          context.report({
+            node,
+            messageId: "missing",
+          });
+          return;
+        }
+      },
+    };
+  },
+};
+
+export default rule;