@aneuhold/eslint-config 2.0.5 → 3.0.1

package/src/rules/no-private-modifier/no-private-modifier.test.ts

@@ -0,0 +1,105 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import { setupEslintRuleTester } from '../../utils/eslintTestSetup';
+import { noPrivateModifier } from './no-private-modifier';
+
+setupEslintRuleTester();
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parserOptions: { ecmaVersion: 'latest', sourceType: 'module' },
+  },
+});
+
+ruleTester.run('no-private-modifier', noPrivateModifier, {
+  valid: [
+    // `#private` field and method.
+    { code: `class Foo { #count = 0; }` },
+    { code: `class Foo { #helper(): void {} }` },
+    // Static `#private` field and method.
+    { code: `class Foo { static #count = 0; }` },
+    { code: `class Foo { static #helper(): void {} }` },
+    // `#private` accessor and getter.
+    { code: `class Foo { accessor #x = 1; }` },
+    { code: `class Foo { get #x(): number { return 1; } }` },
+    { code: `class Foo { constructor(foo: string) {} }` },
+    // Private constructors are allowed (no `#` constructor exists).
+    { code: `class Foo { private constructor() {} }` },
+    // Constructor parameter properties are allowed (no `#` shorthand exists).
+    { code: `class Foo { constructor(private foo: string) {} }` },
+    { code: `class Foo { constructor(private readonly foo: string) {} }` },
+    // `public`/`protected`/no-modifier members are out of scope.
+    { code: `class Foo { public count = 0; }` },
+    { code: `class Foo { protected helper(): void {} }` },
+    { code: `class Foo { count = 0; }` },
+    { code: `class Foo { static value = 1; }` },
+  ],
+  invalid: [
+    // Private instance field, rewritten with its `this` reference.
+    {
+      code: `class Foo { private count = 0; read() { return this.count; } }`,
+      errors: [{ messageId: 'privateField' }],
+      output: `class Foo { #count = 0; read() { return this.#count; } }`,
+    },
+    // Field with no references is still converted.
+    {
+      code: `class Foo { private count = 0; }`,
+      errors: [{ messageId: 'privateField' }],
+      output: `class Foo { #count = 0; }`,
+    },
+    // Private method, rewritten along with its call site.
+    {
+      code: `class Foo { private helper() {} run() { this.helper(); } }`,
+      errors: [{ messageId: 'privateMethod' }],
+      output: `class Foo { #helper() {} run() { this.#helper(); } }`,
+    },
+    // Static field referenced via both `Foo.x` and `this.x`.
+    {
+      code: `class Foo { private static total = 0; static bump() { Foo.total++; this.total++; } }`,
+      errors: [{ messageId: 'privateField' }],
+      output: `class Foo { static #total = 0; static bump() { Foo.#total++; this.#total++; } }`,
+    },
+    // Accessor property.
+    {
+      code: `class Foo { private accessor label = ''; show() { return this.label; } }`,
+      errors: [{ messageId: 'privateField' }],
+      output: `class Foo { accessor #label = ''; show() { return this.#label; } }`,
+    },
+    // Getter/setter pair sharing a name: both declarations convert, the shared
+    // reference is rewritten exactly once.
+    {
+      code: `class Foo { private get x() { return 1; } private set x(v: number) {} use() { return this.x; } }`,
+      errors: [{ messageId: 'privateMethod' }, { messageId: 'privateMethod' }],
+      output: `class Foo { get #x() { return 1; } set #x(v: number) {} use() { return this.#x; } }`,
+    },
+    // Two distinct members in one class.
+    {
+      code: `class Foo { private count = 0; private helper() { return this.count; } }`,
+      errors: [{ messageId: 'privateField' }, { messageId: 'privateMethod' }],
+      output: `class Foo { #count = 0; #helper() { return this.#count; } }`,
+    },
+    // Possible cross-instance access (`other.id`) is ambiguous, so no fix.
+    {
+      code: `class Foo { private id = 1; eq(other: Foo): boolean { return this.id === other.id; } }`,
+      errors: [{ messageId: 'privateField' }],
+      output: null,
+    },
+    // Computed access can't be expressed as `#`, so no fix.
+    {
+      code: `class Foo { private val = 1; read() { return this['val']; } }`,
+      errors: [{ messageId: 'privateField' }],
+      output: null,
+    },
+    // Destructuring a private member off `this` has no `#` form, so no fix.
+    {
+      code: `class Foo { private val = 1; read() { const { val } = this; return val; } }`,
+      errors: [{ messageId: 'privateField' }],
+      output: null,
+    },
+    // A colliding `#count` already exists, so the rename is unsafe — report only.
+    {
+      code: `class Foo { #count = 1; private count = 2; }`,
+      errors: [{ messageId: 'privateField' }],
+      output: null,
+    },
+  ],
+});

package/src/rules/no-private-modifier/no-private-modifier.ts

@@ -0,0 +1,130 @@
+import { AST_NODE_TYPES, type TSESTree } from '@typescript-eslint/utils';
+import { createRule } from '../../utils/createRule';
+import { buildClassFixes } from './buildClassFixes';
+import { classifyMemberAccess, createClassFrame, recordDestructuring } from './classFrame';
+import { collectClassReports } from './classReports';
+import { type ClassFrame, type ClassNode } from './types';
+
+/**
+ * Enforces that class members marked private use the ECMAScript `#private`
+ * syntax rather than the TypeScript `private` accessibility modifier, and
+ * autofixes the conversion — declaration plus `this.x` / `ClassName.x`
+ * references — whenever it can do so safely. Covers instance and static fields,
+ * and methods (including accessors and getters/setters). Private constructors
+ * and constructor parameter properties (`constructor(private foo)`) are
+ * intentionally allowed, since the `#` form has no equivalent.
+ *
+ * References are gathered as ESLint makes its single pass over the file: a stack
+ * tracks the class currently being traversed, and a per-class counter tracks how
+ * far `this` has been rebound away from the instance by nested non-arrow
+ * functions. See `classFrame.ts` for how each access is classified.
+ */
+export const noPrivateModifier = createRule({
+  name: 'no-private-modifier',
+  meta: {
+    type: 'suggestion',
+    fixable: 'code',
+    docs: {
+      description:
+        'Class members must use the ECMAScript `#private` syntax instead of the TypeScript `private` accessibility modifier.',
+    },
+    messages: {
+      privateField:
+        'Use a `#private` field instead of the TypeScript `private` modifier (e.g. `#count` rather than `private count`).',
+      privateMethod:
+        'Use a `#private` method instead of the TypeScript `private` modifier (e.g. `#helper()` rather than `private helper()`).',
+    },
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    const { sourceCode } = context;
+    const classStack: ClassFrame[] = [];
+
+    /** Whether `this`, at the current point in traversal, is the class instance. */
+    const thisIsInstance = (): boolean => {
+      const frame = classStack.at(-1);
+      return frame !== undefined && frame.rebindDepth === 0;
+    };
+
+    /**
+     * Adjusts the current class's rebind depth when entering or leaving a
+     * function. A function that isn't a method of the class rebinds `this`.
+     *
+     * @param node The function being entered or left
+     * @param delta `+1` on enter, `-1` on exit
+     */
+    const adjustRebindDepth = (
+      node: TSESTree.FunctionDeclaration | TSESTree.FunctionExpression,
+      delta: number
+    ): void => {
+      const frame = classStack.at(-1);
+      if (frame && node.parent.type !== AST_NODE_TYPES.MethodDefinition) {
+        frame.rebindDepth += delta;
+      }
+    };
+
+    /**
+     * Reports every `private` member of the class being left, attaching the
+     * single class-wide autofix to the first member that can be converted.
+     */
+    const reportClass = (): void => {
+      const frame = classStack.pop();
+      if (!frame) {
+        return;
+      }
+
+      const { reports, targets } = collectClassReports(frame);
+      const fixableMembers = new Set(targets.map((target) => target.member));
+      let fixAttached = false;
+
+      for (const { member, messageId } of reports) {
+        if (!fixAttached && fixableMembers.has(member)) {
+          fixAttached = true;
+          context.report({
+            node: member,
+            messageId,
+            fix: (fixer) => buildClassFixes(fixer, sourceCode, targets),
+          });
+        } else {
+          context.report({ node: member, messageId });
+        }
+      }
+    };
+
+    return {
+      ClassDeclaration: (node: ClassNode) => classStack.push(createClassFrame(node)),
+      ClassExpression: (node: ClassNode) => classStack.push(createClassFrame(node)),
+      'ClassDeclaration:exit': () => {
+        reportClass();
+      },
+      'ClassExpression:exit': () => {
+        reportClass();
+      },
+      FunctionDeclaration: (node) => {
+        adjustRebindDepth(node, 1);
+      },
+      FunctionExpression: (node) => {
+        adjustRebindDepth(node, 1);
+      },
+      'FunctionDeclaration:exit': (node) => {
+        adjustRebindDepth(node, -1);
+      },
+      'FunctionExpression:exit': (node) => {
+        adjustRebindDepth(node, -1);
+      },
+      MemberExpression(node) {
+        const frame = classStack.at(-1);
+        if (frame && frame.candidateNames.size > 0) {
+          classifyMemberAccess(frame, node, thisIsInstance());
+        }
+      },
+      ObjectPattern(node) {
+        const frame = classStack.at(-1);
+        if (frame && frame.candidateNames.size > 0) {
+          recordDestructuring(frame, node);
+        }
+      },
+    };
+  },
+});

package/src/rules/no-private-modifier/types.ts

@@ -0,0 +1,42 @@
+import { type TSESTree } from '@typescript-eslint/utils';
+
+/** A class declaration or expression. */
+export type ClassNode = TSESTree.ClassDeclaration | TSESTree.ClassExpression;
+
+/** A class member that can carry the `private` modifier and be converted to `#`. */
+export type FixableMember =
+  | TSESTree.PropertyDefinition
+  | TSESTree.AccessorProperty
+  | TSESTree.MethodDefinition;
+
+/** A message this rule can report. */
+export type MessageId = 'privateField' | 'privateMethod';
+
+/** A member to convert, paired with the references that convert alongside it. */
+export type FixTarget = { member: FixableMember; refs: TSESTree.MemberExpression[] };
+
+/**
+ * Everything learned about one class while ESLint traverses it: which private
+ * members are candidates for conversion, which `#names` already exist, and the
+ * references discovered so far (safely rewritable vs. blocked).
+ */
+export type ClassFrame = {
+  classNode: ClassNode;
+  className: string | null;
+  /** Private member names eligible for conversion. */
+  candidateNames: Set<string>;
+  /** `#name` identifiers already present; renaming onto one would collide. */
+  existingPrivateNames: Set<string>;
+  /** `this.name` accesses that an autofix would rewrite. */
+  thisRefs: Map<string, TSESTree.MemberExpression[]>;
+  /** `ClassName.name` accesses (statics) that an autofix would rewrite. */
+  staticRefs: Map<string, TSESTree.MemberExpression[]>;
+  /** Names with a reference the fix can't safely rewrite, so won't be touched. */
+  blocked: Set<string>;
+  /**
+   * How many non-arrow functions are currently open inside this class without
+   * being one of its methods — i.e. how deeply `this` has been rebound away
+   * from the instance. Zero means `this` refers to the instance.
+   */
+  rebindDepth: number;
+};

package/src/rules/service-file-structure/isServiceFile.ts

@@ -0,0 +1,51 @@
+/**
+ * Matches a service source file: a basename ending in `service.ts` or
+ * `service.svelte.ts`, where only the leading `S` is case-insensitive (so
+ * `WakeLockService.ts`, `setMapService.svelte.ts`, and `service.ts` all match).
+ * Intentionally broad so mis-named services are still caught and reported.
+ */
+const SERVICE_FILE = /[sS]ervice\.(svelte\.)?ts$/;
+
+/**
+ * Matches the required service file naming convention: a PascalCase name
+ * (capital first letter) followed by `.service.ts` or `.service.svelte.ts`
+ * (e.g. `WakeLock.service.ts`).
+ */
+const SERVICE_FILE_NAMING = /^[A-Z][A-Za-z0-9]*\.service\.(svelte\.)?ts$/;
+
+/**
+ * Excludes test, spec, and mock variants from the gate even when their name
+ * would otherwise look like a service file.
+ */
+const NON_SOURCE = /\.(test|spec|mock)\./;
+
+/**
+ * Returns the final path segment of a file path, handling both POSIX and
+ * Windows separators.
+ *
+ * @param filePath Absolute or relative file path from the lint context
+ */
+const baseName = (filePath: string): string => {
+  const segments = filePath.split(/[\\/]/);
+  return segments[segments.length - 1];
+};
+
+/**
+ * Decides whether a file is in scope for this rule.
+ *
+ * @param filePath The file path being linted
+ */
+export const isServiceFile = (filePath: string): boolean => {
+  const name = baseName(filePath);
+  return SERVICE_FILE.test(name) && !NON_SOURCE.test(name);
+};
+
+/**
+ * Decides whether an in-scope service file follows the required
+ * `<Name>.service.ts` / `<Name>.service.svelte.ts` naming convention, where
+ * `<Name>` is PascalCase (starts with a capital letter).
+ *
+ * @param filePath The file path being linted
+ */
+export const usesServiceFileNaming = (filePath: string): boolean =>
+  SERVICE_FILE_NAMING.test(baseName(filePath));

package/src/rules/service-file-structure/messages.ts

@@ -0,0 +1,25 @@
+/**
+ * The single source of truth for this rule's report messages. The rule's `meta`
+ * consumes this object, and `ServiceMessageId` types every `context.report`
+ * call across the individual validation modules.
+ */
+export const messages = {
+  fileNaming:
+    'A service file must be named `<Name>.service.ts` or `<Name>.service.svelte.ts`, where `<Name>` starts with a capital letter.',
+  classRequired: 'A service file must define exactly one class; none was found.',
+  singleClassOnly: 'A service file must define exactly one class.',
+  classMustBeNamed: 'A service class must have a name.',
+  noTopLevelFunction:
+    'A service file must not define functions outside its class; move this into the class as a private method.',
+  noTopLevelVariable:
+    'A service file must not declare variables outside its class; use a private instance or static field instead. The only exception is the singleton `const {{instance}} = new {{className}}();`.',
+  instanceName:
+    'The service singleton must be named `{{expected}}` (camelCase of `{{className}}`), not `{{actual}}`.',
+  trailingInstanceExport:
+    'Export the singleton via `const {{instance}} = new {{className}}();` then `export default {{instance}};`, not `export default new {{className}}();`.',
+};
+
+/**
+ * Union of every message id this rule can report.
+ */
+export type ServiceMessageId = keyof typeof messages;

package/src/rules/service-file-structure/service-file-structure.md

@@ -0,0 +1,97 @@
+# `service-file-structure`
+
+Enforces the singleton-service file shape for any file the project treats as a
+service.
+
+## Which files are checked
+
+A file is treated as a service when its basename ends in `service.ts` or
+`service.svelte.ts`, where only the leading `S` is case-insensitive — so
+`WakeLockService.ts`, `wakeLock.service.ts`, and `setMapService.svelte.ts` all
+qualify. The gate is intentionally broad so that mis-named services are still
+caught and reported (rule 1). Test, spec, and mock variants (`*.test.*`,
+`*.spec.*`, `*.mock.*`) are excluded. All other files are ignored entirely.
+
+## What it enforces
+
+1. **The file name follows the convention** — `<name>.service.ts` or
+   `<name>.service.svelte.ts`.
+2. **Exactly one class**, and it is named.
+3. **No functions outside the class** — neither `function` declarations nor
+   exported ones. Move them in as (private) methods.
+4. **No variables outside the class** — top-level `const`/`let`/`var` (including
+   `export const`) are forbidden; make them private instance or static fields.
+   The only exception is the singleton binding (rule 6).
+5. **The singleton is conventionally named** — `const xService = new XService()`
+   must use the class name with a lowercased first letter.
+6. **A freshly-constructed default export uses the `const`-bound form** —
+   `export default new XService();` is rewritten to
+   `const xService = new XService();` + `export default xService;`.
+
+Exporting the **class itself** as the default (`export default class XService {}`
+or `export default XService`) is allowed and not rewritten, since such a class
+may be intended for extension.
+
+## Autofix
+
+- `export default new XService();` (with or without constructor arguments) is
+  rewritten to the two-line `const` + `export default` form.
+- The other violations (a non-conforming file name, extra classes, stray
+  declarations, a mis-named singleton) are reported without a fix.
+
+## Rule details
+
+Examples of **incorrect** code (in a `foo.service.ts` file):
+
+```ts
+// Function and constant outside the class.
+function helper() {}
+const MAX = 3;
+
+class FooService {}
+const fooService = new FooService();
+export default fooService;
+```
+
+```ts
+// Inline default export (auto-fixed).
+class FooService {}
+export default new FooService();
+```
+
+Examples of **correct** code:
+
+```ts
+class FooService {
+  private readonly max = 3;
+  private helper(): void {}
+}
+const fooService = new FooService();
+export default fooService;
+```
+
+```ts
+// A service meant to be extended may export its class as the default.
+export default class FooService {}
+```
+
+## How it is implemented
+
+The rule is a thin orchestrator. It gates on the filename (`isServiceFile.ts`),
+resolves the single service class into a shared model (`serviceModel.ts`), then
+runs a list of independent validations from `validations/`:
+
+- `validateFileNamingConvention.ts` — file-level; runs even with no valid class
+- `validateNoTopLevelFunctions.ts`
+- `validateNoTopLevelVariables.ts`
+- `validateSingletonName.ts`
+- `validateDefaultExportIsConstBound.ts`
+
+Add a new restriction by writing another `validations/validate<Concern>.ts`
+module and listing it in `service-file-structure.ts`.
+
+## When not to use it
+
+Disable it for files that are named like services but intentionally export
+something other than a single class. Prefer renaming such files so the gate no
+longer matches.

package/src/rules/service-file-structure/service-file-structure.test.ts

@@ -0,0 +1,159 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import { setupEslintRuleTester } from '../../utils/eslintTestSetup';
+import { serviceFileStructure } from './service-file-structure';
+
+setupEslintRuleTester();
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parserOptions: { ecmaVersion: 'latest', sourceType: 'module' },
+  },
+});
+
+/**
+ * A well-formed service body, parameterized by class name so valid cases stay
+ * DRY.
+ *
+ * @param className The service class name
+ */
+const validService = (className: string): string => {
+  const instance = `${className.charAt(0).toLowerCase()}${className.slice(1)}`;
+  return [
+    `class ${className} {`,
+    `  private helper(): void {}`,
+    `}`,
+    `const ${instance} = new ${className}();`,
+    `export default ${instance};`,
+  ].join('\n');
+};
+
+ruleTester.run('service-file-structure', serviceFileStructure, {
+  valid: [
+    // Canonical singleton service.
+    { filename: 'WakeLock.service.ts', code: validService('WakeLockService') },
+    // Rune-based `.service.svelte.ts` service is in scope and well-formed.
+    { filename: 'Timer.service.svelte.ts', code: validService('TimerService') },
+    // Exporting the class itself as default is allowed (extensible base).
+    {
+      filename: 'Foo.service.ts',
+      code: `export default class FooService {}`,
+    },
+    // Exporting the named class as default is also allowed.
+    {
+      filename: 'Foo.service.ts',
+      code: [`class FooService {}`, `export default FooService;`].join('\n'),
+    },
+    // Out-of-scope file: not a service name, so anything goes.
+    { filename: 'helpers.ts', code: `export function stray() {}` },
+    // Test files are excluded from the gate.
+    { filename: 'Foo.service.test.ts', code: `export function stray() {}` },
+    // Mock files are excluded from the gate.
+    { filename: 'SetMap.service.mock.ts', code: `export const thing = () => {};` },
+  ],
+  invalid: [
+    // A service file not following the `<Name>.service.ts` naming convention.
+    {
+      filename: 'FooService.ts',
+      code: validService('FooService'),
+      errors: [{ messageId: 'fileNaming' }],
+    },
+    // A `.service.ts` file whose name is not PascalCase (lowercase first letter).
+    {
+      filename: 'foo.service.ts',
+      code: validService('FooService'),
+      errors: [{ messageId: 'fileNaming' }],
+    },
+    // Inline `export default new X()` is rewritten to the two-line form.
+    {
+      filename: 'Foo.service.ts',
+      code: [`class FooService {}`, `export default new FooService();`].join('\n'),
+      errors: [{ messageId: 'trailingInstanceExport' }],
+      output: [
+        `class FooService {}`,
+        `const fooService = new FooService();`,
+        `export default fooService;`,
+      ].join('\n'),
+    },
+    // Constructor arguments are preserved by the fix.
+    {
+      filename: 'Foo.service.ts',
+      code: [`class FooService {}`, `export default new FooService(1, 2);`].join('\n'),
+      errors: [{ messageId: 'trailingInstanceExport' }],
+      output: [
+        `class FooService {}`,
+        `const fooService = new FooService(1, 2);`,
+        `export default fooService;`,
+      ].join('\n'),
+    },
+    // Wrong instance name is reported with no safe fix.
+    {
+      filename: 'Foo.service.ts',
+      code: [`class FooService {}`, `const svc = new FooService();`, `export default svc;`].join(
+        '\n'
+      ),
+      errors: [{ messageId: 'instanceName' }],
+      output: null,
+    },
+    // A top-level function declaration is forbidden.
+    {
+      filename: 'Foo.service.ts',
+      code: [
+        `class FooService {}`,
+        `function helper() {}`,
+        `const fooService = new FooService();`,
+        `export default fooService;`,
+      ].join('\n'),
+      errors: [{ messageId: 'noTopLevelFunction' }],
+    },
+    // A top-level value `const` is forbidden.
+    {
+      filename: 'Foo.service.ts',
+      code: [
+        `class FooService {}`,
+        `const MAX = 5;`,
+        `const fooService = new FooService();`,
+        `export default fooService;`,
+      ].join('\n'),
+      errors: [{ messageId: 'noTopLevelVariable' }],
+    },
+    // A top-level arrow-function `const` is forbidden.
+    {
+      filename: 'Foo.service.ts',
+      code: [
+        `class FooService {}`,
+        `const helper = () => {};`,
+        `const fooService = new FooService();`,
+        `export default fooService;`,
+      ].join('\n'),
+      errors: [{ messageId: 'noTopLevelVariable' }],
+    },
+    // A top-level named `export const` is forbidden.
+    {
+      filename: 'Foo.service.ts',
+      code: [
+        `class FooService {}`,
+        `export const value = 1;`,
+        `const fooService = new FooService();`,
+        `export default fooService;`,
+      ].join('\n'),
+      errors: [{ messageId: 'noTopLevelVariable' }],
+    },
+    // More than one class is not allowed.
+    {
+      filename: 'Foo.service.ts',
+      code: [
+        `class AService {}`,
+        `class BService {}`,
+        `const aService = new AService();`,
+        `export default aService;`,
+      ].join('\n'),
+      errors: [{ messageId: 'singleClassOnly' }],
+    },
+    // No class at all.
+    {
+      filename: 'Foo.service.ts',
+      code: `export const value = 1;`,
+      errors: [{ messageId: 'classRequired' }],
+    },
+  ],
+});

package/src/rules/service-file-structure/service-file-structure.ts

@@ -0,0 +1,61 @@
+import { createRule } from '../../utils/createRule';
+import { isServiceFile } from './isServiceFile';
+import { messages } from './messages';
+import { resolveServiceClass, type ServiceValidation } from './serviceModel';
+import { validateDefaultExportIsConstBound } from './validations/validateDefaultExportIsConstBound';
+import { validateFileNamingConvention } from './validations/validateFileNamingConvention';
+import { validateNoTopLevelFunctions } from './validations/validateNoTopLevelFunctions';
+import { validateNoTopLevelVariables } from './validations/validateNoTopLevelVariables';
+import { validateSingletonName } from './validations/validateSingletonName';
+
+/**
+ * Validations that operate on the resolved single-class model, in order. Each
+ * lives in its own `validations/validate<Concern>.ts` module and reports
+ * against the shared model. Add a new restriction by writing another module and
+ * listing it here.
+ */
+const validations: ServiceValidation[] = [
+  validateNoTopLevelFunctions,
+  validateNoTopLevelVariables,
+  validateSingletonName,
+  validateDefaultExportIsConstBound,
+];
+
+/**
+ * Enforces the singleton-service file shape according to the standards that seem to help the most
+ * across multiple code-bases that Aneuhold works with.
+ */
+export const serviceFileStructure = createRule({
+  name: 'service-file-structure',
+  meta: {
+    type: 'problem',
+    fixable: 'code',
+    docs: {
+      description:
+        'A service file must contain exactly one named, JSDoc-documented class with no top-level functions or variables, and must export a fresh instance via a `const`-bound singleton rather than inline.',
+    },
+    messages,
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    if (!isServiceFile(context.filename)) {
+      return {};
+    }
+
+    // Evaluate when the node is left and all it's children have already been processed.
+    return {
+      'Program:exit'(program) {
+        validateFileNamingConvention(context);
+
+        const model = resolveServiceClass(context, program);
+        if (!model) {
+          return;
+        }
+        for (const validate of validations) {
+          validate(context, model);
+        }
+      },
+    };
+  },
+});