Terraform Formatter & Validator (fmt, HCL ⇄ JSON)

About the Terraform Formatter & Validator (fmt, HCL ⇄ JSON)

Paste a .tf file, or open several files or a ZIP of a module (up to 5 MB): every file is laid out in Terraform’s canonical style, the way terraform fmt and tofu fmt write it — two spaces per level, the = signs of neighbouring arguments aligned, one space around operators and inside braces, none inside brackets — with labels quoted, "${var.x}" unwrapped to var.x and legacy types such as "string" turned into string. Syntax errors are reported with their line and column, and the file is left as it is, as fmt does.

The module is then checked as a whole: duplicate blocks, references to variables, locals, modules, resources or data sources it does not declare, a missing required_version, providers without a version constraint, module sources that are not pinned (git without ?ref=, the registry without version), variables without a type or description, secret-looking defaults and keys written into the code, count together with for_each, and pre-0.12 syntax. Each finding says how to fix it. You can also convert files to Terraform’s JSON syntax and back, see the dependency graph of resources, data sources and modules drawn from their references, and open a terraform.tfstate to list its resources and outputs and the secrets it keeps in plain text.

Everything runs in your browser; nothing is uploaded. Without a pass the result is a free preview: the first lines of each formatted file, every count with the first findings, and the graph under a mark. Whole files, every finding, the ZIP of formatted files and every copy and download unlock with a Pro pass.

What formatting changes, and what it never touches

The layout follows the conventions of Terraform’s style guide and the behaviour of terraform fmt: indentation by bracket level, aligned = signs for consecutive single-line arguments (a value that opens a bracket or a blank line ends the group), aligned trailing comments, and normalised spaces between tokens. Besides whitespace it makes only Terraform’s own rewrites: quoted block labels, a "${…}" that is the whole value unwrapped (in parentheses when it spans lines), and the legacy variable types "string", "list" and "map" (and a bare list, map or set) written as type expressions. The text of strings, heredocs and comments, blank lines and a missing final newline stay as they are, and // comments are not rewritten to # (that one is reported as a note instead).

The checks

• Errors Terraform would refuse: duplicate resources, data sources, modules, variables or outputs; a provider configured twice without different aliases; duplicate local values; references to things the module does not declare; count and for_each together; a block in an override file with nothing to override.
• Warnings: no required_version; providers without a version constraint in required_providers; registry modules without version and git modules without ?ref=; variables without a type; secret-looking variable defaults; keys and tokens written into the code (AWS access keys, private keys, GitHub, Slack, Stripe and Google API keys); quoted references in depends_on and provider.
• Notes: variables without a description, interpolation-only strings and legacy types (which formatting fixes), // and /* */ comments, names with capitals or dashes.

Each folder is a module of its own, as in Terraform. Override files (override.tf and any *_override.tf) are merged into the blocks of the other files, as Terraform merges them, so their blocks are not duplicates. A single pasted file is checked on its own, so references to things declared in its other files are warnings, not errors.

JSON syntax, the graph and state files

The JSON conversion follows Terraform’s JSON configuration syntax: one nested object per block label, arrays for repeated blocks and provisioners, expressions as "${…}" templates, and the arguments Terraform takes literally written as they are: a variable’s type, default and description, a module’s source, version and providers map. References are plain strings such as "aws_instance.web": depends_on, provider, ignore_changes, replace_triggered_by, and the addresses of moved, removed and import blocks. Going back from JSON, nested blocks of a provider cannot be told from map arguments without the provider’s schema, so lists of objects become blocks and every such guess is listed.

The graph is drawn from the references in each block and from depends_on; a dependency through a local value or a variable shows as an edge between the things it connects. State files (format version 4, written by Terraform 0.12 and later and by OpenTofu) list each resource with its instances, the outputs, and the attributes kept in plain text: those the provider marks sensitive, sensitive outputs, and attributes named like secrets. Their values are shown masked.

Limitations

• The formatter is MySmartCoPilot’s own implementation of the canonical style, matched against the reference formatter’s published examples; Terraform may add formatting rules in a new version.
• The checks read the configuration only: providers are not downloaded, so provider arguments, resource types and values are not validated (terraform validate does that with the providers installed).
• References into child modules (module.x.output) are checked for the module, not for the output; outputs of a remote module are not known.
• Up to 5 MB of files at a time; the graph is easiest to read with a few hundred resources at most.

Privacy

On this device: nothing is sent

Everything happens in your browser. What you enter or open here is not uploaded or stored by MySmartCoPilot.