@alexgorbatchev/typescript-ai-policy 0.1.0

package/src/oxlint/rules/interface-naming-convention.ts

@@ -0,0 +1,72 @@
+import type { TSESTree } from "@typescript-eslint/types";
+import type { RuleModule } from "./types.ts";
+import { isAstNode, isPascalCase } from "./helpers.ts";
+
+function isExternallyOwnedAmbientInterface(node: TSESTree.TSInterfaceDeclaration): boolean {
+  if (node.declare === true && node.parent?.type !== "ExportNamedDeclaration") {
+    return true;
+  }
+
+  let current: TSESTree.Node | undefined = node.parent;
+
+  while (current) {
+    if (current.type === "TSModuleDeclaration") {
+      if (current.declare === true || current.kind === "global" || current.id?.type === "Literal") {
+        return true;
+      }
+    }
+
+    const parentNode: unknown = Reflect.get(current, "parent");
+    current = isAstNode(parentNode) ? parentNode : undefined;
+  }
+
+  return false;
+}
+
+function isValidInterfaceName(name: string): boolean {
+  if (!name.startsWith("I")) {
+    return false;
+  }
+
+  const interfaceBaseName = name.slice(1);
+
+  return interfaceBaseName.length > 0 && isPascalCase(interfaceBaseName);
+}
+
+const interfaceNamingConventionRule: RuleModule = {
+  meta: {
+    type: "problem" as const,
+    docs: {
+      description: 'Enforce repository-owned interface names to use the "I" prefix followed by PascalCase',
+    },
+    schema: [],
+    messages: {
+      unexpectedInterfaceName:
+        'Rename interface "{{ name }}" to match "I[A-Z][A-Za-z0-9]*". Repository-owned interfaces must start with "I" and use PascalCase after the prefix.',
+    },
+  },
+  create(context) {
+    return {
+      TSInterfaceDeclaration(node) {
+        if (isExternallyOwnedAmbientInterface(node)) {
+          return;
+        }
+
+        const interfaceName = node.id?.name;
+        if (!interfaceName || isValidInterfaceName(interfaceName)) {
+          return;
+        }
+
+        context.report({
+          node: node.id ?? node,
+          messageId: "unexpectedInterfaceName",
+          data: {
+            name: interfaceName,
+          },
+        });
+      },
+    };
+  },
+};
+
+export default interfaceNamingConventionRule;

package/src/oxlint/rules/no-conditional-logic-in-tests.ts

@@ -0,0 +1,53 @@
+import type { RuleModule } from "./types.ts";
+import { isTestFile } from "./helpers.ts";
+
+const noConditionalLogicInTestsRule: RuleModule = {
+  meta: {
+    type: "problem" as const,
+    docs: {
+      description: "Ban conditional control flow inside committed test files",
+    },
+    schema: [],
+    messages: {
+      forbiddenConditionalLogic:
+        "Remove this {{ conditionalKind }} from the test. Committed tests must execute assertions deterministically, so use assert(...) for narrowing or failure instead of branching test control flow.",
+    },
+  },
+  create(context) {
+    if (!isTestFile(context.filename)) {
+      return {};
+    }
+
+    return {
+      ConditionalExpression(node) {
+        context.report({
+          node,
+          messageId: "forbiddenConditionalLogic",
+          data: {
+            conditionalKind: "ternary expression",
+          },
+        });
+      },
+      IfStatement(node) {
+        context.report({
+          node,
+          messageId: "forbiddenConditionalLogic",
+          data: {
+            conditionalKind: '"if" statement',
+          },
+        });
+      },
+      SwitchStatement(node) {
+        context.report({
+          node,
+          messageId: "forbiddenConditionalLogic",
+          data: {
+            conditionalKind: '"switch" statement',
+          },
+        });
+      },
+    };
+  },
+};
+
+export default noConditionalLogicInTestsRule;

package/src/oxlint/rules/no-fixture-exports-outside-fixture-entrypoint.ts

@@ -0,0 +1,68 @@
+import type { RuleModule } from "./types.ts";
+import { isFixtureLikeName, isFixturesFile, readDeclarationIdentifierNames } from "./helpers.ts";
+
+const noFixtureExportsOutsideFixtureEntrypointRule: RuleModule = {
+  meta: {
+    type: "problem" as const,
+    docs: {
+      description:
+        'Disallow exporting fixture_ or factory_ bindings outside nested "fixtures.ts" or "fixtures.tsx" entrypoints under "__tests__/" or "stories/"',
+    },
+    schema: [],
+    messages: {
+      unexpectedFixtureExport:
+        'Move "{{ name }}" into a nested "fixtures.ts" or "fixtures.tsx" entrypoint under "__tests__/" or "stories/" and export it only from there.',
+    },
+  },
+  create(context) {
+    if (isFixturesFile(context.filename)) {
+      return {};
+    }
+
+    return {
+      ExportNamedDeclaration(node) {
+        if (node.declaration) {
+          readDeclarationIdentifierNames(node.declaration).forEach((name) => {
+            if (!isFixtureLikeName(name)) {
+              return;
+            }
+
+            context.report({
+              node: node.declaration,
+              messageId: "unexpectedFixtureExport",
+              data: {
+                name,
+              },
+            });
+          });
+        }
+
+        node.specifiers.forEach((specifier) => {
+          if (specifier.type !== "ExportSpecifier") {
+            return;
+          }
+
+          const localName =
+            specifier.local.type === "Identifier" ? specifier.local.name : String(specifier.local.value);
+          const exportedName =
+            specifier.exported.type === "Identifier" ? specifier.exported.name : String(specifier.exported.value);
+          const fixtureLikeName = [exportedName, localName].find((name) => isFixtureLikeName(name));
+
+          if (!fixtureLikeName) {
+            return;
+          }
+
+          context.report({
+            node: specifier,
+            messageId: "unexpectedFixtureExport",
+            data: {
+              name: fixtureLikeName,
+            },
+          });
+        });
+      },
+    };
+  },
+};
+
+export default noFixtureExportsOutsideFixtureEntrypointRule;

package/src/oxlint/rules/no-imports-from-tests-directory.ts

@@ -0,0 +1,114 @@
+import type { TSESTree } from "@typescript-eslint/types";
+import type { RuleContext, RuleModule } from "./types.ts";
+import { isInTestsDirectory, isTestsDirectoryPath } from "./helpers.ts";
+
+type StringLiteralValueNode = TSESTree.Expression | TSESTree.Literal | null | undefined;
+
+function readStringLiteralValue(node: StringLiteralValueNode): string | null {
+  if (node?.type === "Literal" && typeof node.value === "string") {
+    return node.value;
+  }
+
+  if (node?.type === "TemplateLiteral" && node.expressions.length === 0) {
+    return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw ?? null;
+  }
+
+  return null;
+}
+
+function reportUnexpectedTestsDirectoryImport(context: RuleContext, node: TSESTree.Node, importPath: string): void {
+  context.report({
+    node,
+    messageId: "unexpectedTestsDirectoryImport",
+    data: {
+      importPath,
+    },
+  });
+}
+
+const noImportsFromTestsDirectoryRule: RuleModule = {
+  meta: {
+    type: "problem" as const,
+    docs: {
+      description:
+        'Disallow files outside "__tests__" from importing, requiring, or re-exporting modules from a "__tests__" directory',
+    },
+    schema: [],
+    messages: {
+      unexpectedTestsDirectoryImport:
+        'Remove this dependency on "{{ importPath }}". Files outside "__tests__" must not import, require, or re-export modules from a "__tests__" directory.',
+    },
+  },
+  create(context) {
+    if (isInTestsDirectory(context.filename)) {
+      return {};
+    }
+
+    return {
+      ImportDeclaration(node) {
+        const importPath = readStringLiteralValue(node.source);
+        if (!importPath || !isTestsDirectoryPath(importPath)) {
+          return;
+        }
+
+        reportUnexpectedTestsDirectoryImport(context, node.source, importPath);
+      },
+      ExportNamedDeclaration(node) {
+        const source = node.source;
+        const importPath = readStringLiteralValue(source);
+        if (!source || !importPath || !isTestsDirectoryPath(importPath)) {
+          return;
+        }
+
+        reportUnexpectedTestsDirectoryImport(context, source, importPath);
+      },
+      ExportAllDeclaration(node) {
+        const importPath = readStringLiteralValue(node.source);
+        if (!importPath || !isTestsDirectoryPath(importPath)) {
+          return;
+        }
+
+        reportUnexpectedTestsDirectoryImport(context, node.source, importPath);
+      },
+      ImportExpression(node) {
+        const importPath = readStringLiteralValue(node.source);
+        if (!importPath || !isTestsDirectoryPath(importPath)) {
+          return;
+        }
+
+        reportUnexpectedTestsDirectoryImport(context, node.source, importPath);
+      },
+      CallExpression(node) {
+        if (node.callee.type !== "Identifier" || node.callee.name !== "require") {
+          return;
+        }
+
+        const firstArgument = node.arguments[0];
+        if (!firstArgument || firstArgument.type === "SpreadElement") {
+          return;
+        }
+
+        const importPath = readStringLiteralValue(firstArgument);
+        if (!importPath || !isTestsDirectoryPath(importPath)) {
+          return;
+        }
+
+        reportUnexpectedTestsDirectoryImport(context, firstArgument, importPath);
+      },
+      TSImportEqualsDeclaration(node) {
+        if (node.moduleReference.type !== "TSExternalModuleReference") {
+          return;
+        }
+
+        const importPath = readStringLiteralValue(node.moduleReference.expression);
+        if (!importPath || !isTestsDirectoryPath(importPath)) {
+          return;
+        }
+
+        reportUnexpectedTestsDirectoryImport(context, node.moduleReference.expression, importPath);
+      },
+    };
+  },
+};
+
+export default noImportsFromTestsDirectoryRule;

package/src/oxlint/rules/no-inline-fixture-bindings-in-tests.ts

@@ -0,0 +1,54 @@
+import type { RuleModule } from "./types.ts";
+import { isFixtureConsumerFile, isFixtureLikeName, readPatternIdentifierNames } from "./helpers.ts";
+
+const noInlineFixtureBindingsInTestsRule: RuleModule = {
+  meta: {
+    type: "problem" as const,
+    docs: {
+      description: "Disallow inline fixture_ and factory_ bindings inside test and story files",
+    },
+    schema: [],
+    messages: {
+      unexpectedInlineFixtureBinding:
+        'Delete the inline "{{ name }}" declaration from this file and import it from a relative "fixtures" module under the same "__tests__/" or "stories/" tree instead.',
+    },
+  },
+  create(context) {
+    if (!isFixtureConsumerFile(context.filename)) {
+      return {};
+    }
+
+    return {
+      FunctionDeclaration(node) {
+        if (!node.id || !isFixtureLikeName(node.id.name)) {
+          return;
+        }
+
+        context.report({
+          node: node.id,
+          messageId: "unexpectedInlineFixtureBinding",
+          data: {
+            name: node.id.name,
+          },
+        });
+      },
+      VariableDeclarator(node) {
+        readPatternIdentifierNames(node.id).forEach((name) => {
+          if (!isFixtureLikeName(name)) {
+            return;
+          }
+
+          context.report({
+            node,
+            messageId: "unexpectedInlineFixtureBinding",
+            data: {
+              name,
+            },
+          });
+        });
+      },
+    };
+  },
+};
+
+export default noInlineFixtureBindingsInTestsRule;

package/src/oxlint/rules/no-inline-type-expressions.ts

@@ -0,0 +1,169 @@
+import type { TSESTree } from "@typescript-eslint/types";
+import type { RuleContext, RuleModule } from "./types.ts";
+import { isAstNode, isTypeDeclaration } from "./helpers.ts";
+
+type InlineTypeExpressionNode =
+  | TSESTree.TSConditionalType
+  | TSESTree.TSConstructorType
+  | TSESTree.TSFunctionType
+  | TSESTree.TSIntersectionType
+  | TSESTree.TSMappedType
+  | TSESTree.TSTupleType
+  | TSESTree.TSTypeLiteral
+  | TSESTree.TSUnionType;
+
+const INLINE_TYPE_LABEL_BY_NODE_TYPE: Readonly<Record<InlineTypeExpressionNode["type"], string>> = {
+  TSConditionalType: "conditional type expression",
+  TSConstructorType: "constructor-signature type expression",
+  TSFunctionType: "function-signature type expression",
+  TSIntersectionType: "intersection type expression",
+  TSMappedType: "mapped type expression",
+  TSTupleType: "tuple type expression",
+  TSTypeLiteral: "object-literal type expression",
+  TSUnionType: "union type expression",
+};
+
+function isInlineTypeExpressionNode(node: TSESTree.Node | null | undefined): node is InlineTypeExpressionNode {
+  return (
+    node?.type === "TSConditionalType" ||
+    node?.type === "TSConstructorType" ||
+    node?.type === "TSFunctionType" ||
+    node?.type === "TSIntersectionType" ||
+    node?.type === "TSMappedType" ||
+    node?.type === "TSTupleType" ||
+    node?.type === "TSTypeLiteral" ||
+    node?.type === "TSUnionType"
+  );
+}
+
+function isNullishTypeNode(node: TSESTree.TypeNode | null | undefined): boolean {
+  return node?.type === "TSNullKeyword" || node?.type === "TSUndefinedKeyword";
+}
+
+function isAllowedNullableUnionType(node: TSESTree.TypeNode | null | undefined): node is TSESTree.TSUnionType {
+  if (node?.type !== "TSUnionType") {
+    return false;
+  }
+
+  let nonNullishTypeCount = 0;
+  let hasNullishType = false;
+
+  for (const memberType of node.types) {
+    if (isNullishTypeNode(memberType)) {
+      hasNullishType = true;
+      continue;
+    }
+
+    nonNullishTypeCount += 1;
+    if (nonNullishTypeCount > 1) {
+      return false;
+    }
+  }
+
+  return hasNullishType && nonNullishTypeCount === 1;
+}
+
+function readParentNode(node: TSESTree.Node): TSESTree.Node | undefined {
+  const parentNode: unknown = Reflect.get(node, "parent");
+  return isAstNode(parentNode) ? parentNode : undefined;
+}
+
+function isInsideAllowedTypeDeclaration(node: TSESTree.Node): boolean {
+  let current = readParentNode(node);
+
+  while (current) {
+    if (isTypeDeclaration(current)) {
+      return true;
+    }
+
+    current = readParentNode(current);
+  }
+
+  return false;
+}
+
+function hasInlineTypeExpressionAncestor(node: TSESTree.Node): boolean {
+  let current = readParentNode(node);
+
+  while (current) {
+    if (isTypeDeclaration(current)) {
+      return false;
+    }
+
+    if (isInlineTypeExpressionNode(current)) {
+      if (isAllowedNullableUnionType(current)) {
+        current = readParentNode(current);
+        continue;
+      }
+
+      return true;
+    }
+
+    current = readParentNode(current);
+  }
+
+  return false;
+}
+
+function reportUnexpectedInlineTypeExpression(context: RuleContext, node: InlineTypeExpressionNode): void {
+  if (
+    isInsideAllowedTypeDeclaration(node) ||
+    hasInlineTypeExpressionAncestor(node) ||
+    isAllowedNullableUnionType(node)
+  ) {
+    return;
+  }
+
+  context.report({
+    node,
+    messageId: "unexpectedInlineTypeExpression",
+    data: {
+      kind: INLINE_TYPE_LABEL_BY_NODE_TYPE[node.type],
+    },
+  });
+}
+
+const noInlineTypeExpressionsRule: RuleModule = {
+  meta: {
+    type: "problem" as const,
+    docs: {
+      description:
+        "Disallow inline type expressions outside type declarations; require named type declarations or inference instead, except for nullable or undefinable wrappers around a single existing type",
+    },
+    schema: [],
+    messages: {
+      unexpectedInlineTypeExpression:
+        "Do not define an inline {{ kind }} here. First, reuse an existing named type declaration if one already models this contract. If no suitable named type exists, extract this contract into a named type declaration and reference that declaration. Only remove the annotation and let TypeScript infer the type when the type is already obvious from context.",
+    },
+  },
+  create(context) {
+    return {
+      TSConditionalType(node) {
+        reportUnexpectedInlineTypeExpression(context, node);
+      },
+      TSConstructorType(node) {
+        reportUnexpectedInlineTypeExpression(context, node);
+      },
+      TSFunctionType(node) {
+        reportUnexpectedInlineTypeExpression(context, node);
+      },
+      TSIntersectionType(node) {
+        reportUnexpectedInlineTypeExpression(context, node);
+      },
+      TSMappedType(node) {
+        reportUnexpectedInlineTypeExpression(context, node);
+      },
+      TSTupleType(node) {
+        reportUnexpectedInlineTypeExpression(context, node);
+      },
+      TSTypeLiteral(node) {
+        reportUnexpectedInlineTypeExpression(context, node);
+      },
+      TSUnionType(node) {
+        reportUnexpectedInlineTypeExpression(context, node);
+      },
+    };
+  },
+};
+
+export default noInlineTypeExpressionsRule;

package/src/oxlint/rules/no-local-type-declarations-in-fixture-files.ts

@@ -0,0 +1,55 @@
+import type { RuleModule } from "./types.ts";
+import { isInFixturesArea } from "./helpers.ts";
+
+const DECLARATION_MESSAGE_ID_BY_TYPE = {
+  TSEnumDeclaration: "unexpectedEnumDeclaration",
+  TSInterfaceDeclaration: "unexpectedInterfaceDeclaration",
+  TSTypeAliasDeclaration: "unexpectedTypeAliasDeclaration",
+};
+
+const noLocalTypeDeclarationsInFixtureFilesRule: RuleModule = {
+  meta: {
+    type: "problem" as const,
+    docs: {
+      description:
+        'Disallow local type aliases, interfaces, and enums anywhere in nested fixture files under "__tests__/" or "stories/"',
+    },
+    schema: [],
+    messages: {
+      unexpectedEnumDeclaration:
+        "Remove this local enum declaration from the fixture file. Define it elsewhere and import it here.",
+      unexpectedInterfaceDeclaration:
+        "Remove this local interface declaration from the fixture file. Define it elsewhere and import it here.",
+      unexpectedTypeAliasDeclaration:
+        "Remove this local type alias declaration from the fixture file. Define it elsewhere and import it here.",
+    },
+  },
+  create(context) {
+    if (!isInFixturesArea(context.filename)) {
+      return {};
+    }
+
+    return {
+      TSEnumDeclaration(node) {
+        context.report({
+          node,
+          messageId: DECLARATION_MESSAGE_ID_BY_TYPE[node.type],
+        });
+      },
+      TSInterfaceDeclaration(node) {
+        context.report({
+          node,
+          messageId: DECLARATION_MESSAGE_ID_BY_TYPE[node.type],
+        });
+      },
+      TSTypeAliasDeclaration(node) {
+        context.report({
+          node,
+          messageId: DECLARATION_MESSAGE_ID_BY_TYPE[node.type],
+        });
+      },
+    };
+  },
+};
+
+export default noLocalTypeDeclarationsInFixtureFilesRule;

package/src/oxlint/rules/no-module-mocking.ts

@@ -0,0 +1,85 @@
+import type { AstExpression, RuleModule } from "./types.ts";
+
+type CalleePath = string[];
+
+function readCalleePath(node: AstExpression): CalleePath | null {
+  if (node.type === "Identifier") {
+    return [node.name];
+  }
+
+  if (node.type !== "MemberExpression" || node.computed || node.property.type !== "Identifier") {
+    return null;
+  }
+
+  if (node.object.type !== "Identifier" && node.object.type !== "MemberExpression") {
+    return null;
+  }
+
+  const objectPath = readCalleePath(node.object);
+  if (!objectPath) {
+    return null;
+  }
+
+  return [...objectPath, node.property.name];
+}
+
+function hasPathSuffix(path: readonly string[], suffix: readonly string[]): boolean {
+  if (path.length < suffix.length) {
+    return false;
+  }
+
+  return suffix.every((segment, index) => path[path.length - suffix.length + index] === segment);
+}
+
+const MODULE_MOCKING_SUFFIXES = [
+  ["jest", "mock"],
+  ["jest", "doMock"],
+  ["jest", "setMock"],
+  ["jest", "createMockFromModule"],
+  ["jest", "enableAutomock"],
+  ["jest", "unstable_mockModule"],
+  ["vi", "mock"],
+  ["vi", "doMock"],
+  ["vi", "importMock"],
+  ["mock", "module"],
+] as const;
+
+const noModuleMockingRule: RuleModule = {
+  meta: {
+    type: "problem" as const,
+    docs: {
+      description: "Disallow module-mocking APIs across common test interfaces; use dependency injection instead",
+    },
+    schema: [],
+    messages: {
+      noModuleMocking:
+        'Remove "{{ fullName }}". Pass collaborators into the unit under test and stub those injected dependencies in the test instead of mocking the whole module.',
+    },
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        const calleePath = readCalleePath(node.callee);
+
+        if (!calleePath) {
+          return;
+        }
+
+        const isModuleMockingCall = MODULE_MOCKING_SUFFIXES.some((suffix) => hasPathSuffix(calleePath, suffix));
+        if (!isModuleMockingCall) {
+          return;
+        }
+
+        context.report({
+          node,
+          messageId: "noModuleMocking",
+          data: {
+            fullName: calleePath.join("."),
+          },
+        });
+      },
+    };
+  },
+};
+
+export default noModuleMockingRule;