atlasaction: add schema/lint command (#356)

Author: luantranminh

.github/workflows/ci-go.yaml

@@ -357,6 +357,37 @@ jobs:
             env://url
         env:
           GITHUB_TOKEN: ${{ github.token }}
+  schema-lint:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        test:
+          - url: sqlite://schemarule.db
+          - url: file://ok.lt.hcl
+          - url: file://schema.lt.hcl
+    env:
+      ATLAS_ACTION_LOCAL: 1
+    steps:
+      - uses: ariga/setup-atlas@v0
+        with:
+          cloud-token: ${{ secrets.ATLAS_TOKEN }}
+      - uses: actions/checkout@v3
+      - uses: actions/setup-go@v4
+        with:
+          go-version-file: go.mod
+      - run: go install ./cmd/atlas-action
+        env:
+          CGO_ENABLED: 0
+      - id: schema_lint_test
+        uses: ./schema/lint
+        with:
+          working-directory: atlasaction/testdata/schema-lint
+          config: file://atlas.hcl
+          dev-url: sqlite://file?mode=memory
+          url: ${{ matrix.test.url }}
+          vars: '{"rulefile":"schema.rule.hcl"}'
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
   schema-apply:
     runs-on: ubuntu-latest
     env:

README.md

@@ -19,6 +19,7 @@ To learn more about the recommended way to build workflows, read our guide on
 | [ariga/atlas-action/migrate/test](#arigaatlas-actionmigratetest)              | Test migrations on a database                                                       |
 | [ariga/atlas-action/migrate/autorebase](#arigaatlas-actionmigrateautorebase)  | Fix `atlas.sum` conflicts in migration directory                                    |
 | [ariga/atlas-action/schema/test](#arigaatlas-actionschematest)                | Test schema on a database                                                           |
+| [ariga/atlas-action/schema/lint](#arigaatlas-actionschemalint)                | Lint database schema with Atlas                                                     |
 | [ariga/atlas-action/schema/push](#arigaatlas-actionschemapush)                | Push a schema to [Atlas Registry](https://atlasgo.io/registry)                      |
 | [ariga/atlas-action/schema/plan](#arigaatlas-actionschemaplan)                | Plan a declarative migration for a schema transition                                |
 | [ariga/atlas-action/schema/plan/approve](#arigaatlas-actionschemaplanapprove) | Approve a declarative migration plan                                                |
@@ -439,6 +440,25 @@ Apply a declarative migrations to a database.
 
 * `error` - The error message if the action fails.
 
+### `ariga/atlas-action/schema/lint`
+
+Lint database schema with Atlas.
+
+#### Inputs
+
+* `url` - (Required) Schema URL(s) to lint. For example: `file://schema.hcl`.
+  Read more about [Atlas URLs](https://atlasgo.io/concepts/url).
+* `dev-url` - (Required) The URL of the dev-database to use for analysis. For example: `mysql://root:pass@localhost:3306/dev`.
+  Read more about [dev-databases](https://atlasgo.io/concepts/dev-database).
+* `schema` - (Optional) The database schema(s) to include. For example: `public`.
+* `config` - (Optional) The path to the Atlas configuration file. By default, Atlas will look for a file
+  named `atlas.hcl` in the current directory. For example, `file://config/atlas.hcl`.
+  Learn more about [Atlas configuration files](https://atlasgo.io/atlas-schema/projects).
+* `env` - (Optional) The environment to use from the Atlas configuration file. For example, `dev`.
+* `vars` - (Optional) Stringify JSON object containing variables to be used inside the Atlas configuration file.
+  For example: `'{"var1": "value1", "var2": "value2"}'`.
+* `working-directory` - (Optional) The working directory to run from. Defaults to project root.
+
 ### `ariga/atlas-action/schema/push`
 
 Push a schema to [Atlas Registry](https://atlasgo.io/registry) with an optional tag.

atlasaction/action.go

@@ -30,6 +30,7 @@ import (
 	"ariga.io/atlas-action/atlasaction/cloud"
 	"ariga.io/atlas-go-sdk/atlasexec"
 	"ariga.io/atlas/sql/migrate"
+	"ariga.io/atlas/sql/sqlclient"
 	"github.com/fatih/color"
 )
 
@@ -66,13 +67,16 @@ type (
 		MigrateLint(context.Context, *atlasexec.SummaryReport)
 		SchemaPlan(context.Context, *atlasexec.SchemaPlan)
 		SchemaApply(context.Context, *atlasexec.SchemaApply)
+		SchemaLint(context.Context, *SchemaLintReport)
 	}
 	// SCMClient contains methods for interacting with SCM platforms (GitHub, Gitlab etc...).
 	SCMClient interface {
 		// CommentLint comments on the pull request with the lint report.
 		CommentLint(context.Context, *TriggerContext, *atlasexec.SummaryReport) error
 		// CommentPlan comments on the pull request with the schema plan.
 		CommentPlan(context.Context, *TriggerContext, *atlasexec.SchemaPlan) error
+		// CommentSchemaLint comments on the pull request with the schema lint report.
+		CommentSchemaLint(context.Context, *TriggerContext, *SchemaLintReport) error
 	}
 	Logger interface {
 		// Infof logs an info message.
@@ -115,6 +119,8 @@ type (
 		SchemaTest(context.Context, *atlasexec.SchemaTestParams) (string, error)
 		// SchemaPlan runs the `schema plan` command.
 		SchemaPlan(context.Context, *atlasexec.SchemaPlanParams) (*atlasexec.SchemaPlan, error)
+		// SchemaLint runs the `schema lint` command.
+		SchemaLint(context.Context, *atlasexec.SchemaLintParams) (*atlasexec.SchemaLintReport, error)
 		// SchemaPlanList runs the `schema plan list` command.
 		SchemaPlanList(context.Context, *atlasexec.SchemaPlanListParams) ([]atlasexec.SchemaPlanFile, error)
 		// SchemaPlanLint runs the `schema plan lint` command.
@@ -162,6 +168,10 @@ type (
 		Commit string // Latest commit SHA.
 		Body   string // Body (description) of the pull request.
 	}
+	SchemaLintReport struct {
+		URL []string `json:"URL,omitempty"` // Redacted schema URLs
+		*atlasexec.SchemaLintReport
+	}
 )
 
 // AtlasDirectives returns any directives that are
@@ -297,6 +307,7 @@ const (
 	CmdMigrateAutoRebase = "migrate/autorebase"
 	// Declarative workflow Commands
 	CmdSchemaPush        = "schema/push"
+	CmdSchemaLint        = "schema/lint"
 	CmdSchemaTest        = "schema/test"
 	CmdSchemaPlan        = "schema/plan"
 	CmdSchemaPlanApprove = "schema/plan/approve"
@@ -328,6 +339,8 @@ func (a *Actions) Run(ctx context.Context, act string) error {
 		return a.MigrateAutoRebase(ctx)
 	case CmdSchemaPush:
 		return a.SchemaPush(ctx)
+	case CmdSchemaLint:
+		return a.SchemaLint(ctx)
 	case CmdSchemaTest:
 		return a.SchemaTest(ctx)
 	case CmdSchemaPlan:
@@ -725,6 +738,62 @@ func (a *Actions) SchemaPush(ctx context.Context) error {
 	return nil
 }
 
+// SchemaLint runs the GitHub Action for "ariga/atlas-action/schema/lint"
+func (a *Actions) SchemaLint(ctx context.Context) error {
+	tc, err := a.GetTriggerContext(ctx)
+	switch {
+	case err != nil:
+		return fmt.Errorf("unable to get the trigger context: %w", err)
+	}
+	params := &atlasexec.SchemaLintParams{
+		ConfigURL: a.GetInput("config"),
+		Vars:      a.GetVarsInput("vars"),
+		Env:       a.GetInput("env"),
+		URL:       a.GetArrayInput("url"),
+		Schema:    a.GetArrayInput("schema"),
+		DevURL:    a.GetInput("dev-url"),
+	}
+	report, err := a.Atlas.SchemaLint(ctx, params)
+	if err != nil {
+		a.SetOutput("error", err.Error())
+		return fmt.Errorf("`atlas schema lint` completed with errors:\n%s", err)
+	}
+	if len(report.Steps) == 0 {
+		a.Infof("`atlas schema lint` completed successfully, no issues found")
+		return nil
+	}
+	redactedURLs := make([]string, 0, len(params.URL))
+	for _, u := range params.URL {
+		redacted, err := redactedURL(u)
+		if err != nil {
+			a.Errorf("failed to redact URL: %v", err)
+		} else {
+			redactedURLs = append(redactedURLs, redacted)
+		}
+	}
+	rp := &SchemaLintReport{
+		URL:              redactedURLs,
+		SchemaLintReport: report,
+	}
+	if r, ok := a.Action.(Reporter); ok {
+		r.SchemaLint(ctx, rp)
+	}
+	if tc.PullRequest != nil {
+		switch c, err := tc.SCMClient(); {
+		case errors.Is(err, ErrNoSCM):
+			a.Infof("No SCM client available, skipping PR comment")
+		case err != nil:
+			a.Errorf("failed to get SCM client: %v", err)
+		default:
+			if err = c.CommentSchemaLint(ctx, tc, rp); err != nil {
+				a.Errorf("failed to comment on the pull request: %v", err)
+			}
+		}
+	}
+	a.Infof("`atlas schema lint` completed successfully, no issues found")
+	return nil
+}
+
 // SchemaTest runs the GitHub Action for "ariga/atlas-action/schema/test"
 func (a *Actions) SchemaTest(ctx context.Context) error {
 	result, err := a.Atlas.SchemaTest(ctx, &atlasexec.SchemaTestParams{
@@ -1655,6 +1724,14 @@ func fprintln(name string, val ...any) error {
 	return err
 }
 
+func redactedURL(s string) (string, error) {
+	u, err := sqlclient.ParseURL(s)
+	if err != nil {
+		return "", err
+	}
+	return u.Redacted(), nil
+}
+
 // commentMarker creates a hidden marker to identify the comment as one created by this action.
 func commentMarker(id string) string {
 	return fmt.Sprintf(`<!-- generated by ariga/atlas-action for %v -->`, id)