feat: KBC ignore, pull command

internal/pkg/model/objectstate.go

@@ -43,12 +43,14 @@ type ConfigState struct {
 	*ConfigManifest
 	Remote *Config
 	Local  *Config
+	Ignore bool
 }
 
 type ConfigRowState struct {
 	*ConfigRowManifest
 	Remote *ConfigRow
 	Local  *ConfigRow
+	Ignore bool
 }
 
 // ToAPIObjectKey ...

internal/pkg/plan/push/push.go

@@ -7,7 +7,7 @@ import (
 	"github.com/keboola/keboola-as-code/internal/pkg/utils/errors"
 )
 
-func NewPlan(diffResults *diff.Results, allowTargetEnv bool) (*diffop.Plan, error) {
+func NewPlan(diffResults *diff.Results) (*diffop.Plan, error) {
 	plan := diffop.NewPlan(`push`)
 	for _, result := range diffResults.Results {
 		switch result.State {

internal/pkg/state/registry/registry.go

@@ -2,10 +2,12 @@ package registry
 
 import (
 	"context"
+	"strings"
 	"sync"
 
 	"github.com/keboola/go-utils/pkg/orderedmap"
 
+	"github.com/keboola/keboola-as-code/internal/pkg/filesystem"
 	"github.com/keboola/keboola-as-code/internal/pkg/filesystem/knownpaths"
 	. "github.com/keboola/keboola-as-code/internal/pkg/model"
 	"github.com/keboola/keboola-as-code/internal/pkg/naming"
@@ -14,6 +16,8 @@ import (
 
 type pathsRO = knownpaths.PathsReadOnly
 
+const KBCIgnoreFilePath = ".keboola/kbc_ignore"
+
 type Registry struct {
 	*pathsRO
 	paths          *knownpaths.Paths
@@ -150,6 +154,35 @@ func (s *Registry) Configs() (configs []*ConfigState) {
 	return configs
 }
 
+func (s *Registry) IgnoreConfig(ignoreID string, componentID string) {
+	for _, object := range s.All() {
+		if v, ok := object.(*ConfigState); ok {
+			if v.ID.String() == ignoreID && v.ComponentID.String() == componentID {
+				// ignore configuration
+				v.Ignore = true
+
+				// ignore rows of the configuration
+				if len(s.ConfigRowsFrom(v.ConfigKey)) > 0 {
+					for _, configRowState := range s.ConfigRowsFrom(v.ConfigKey) {
+						configRowState.Ignore = true
+					}
+				}
+			}
+		}
+	}
+}
+
+func (s *Registry) IgnoredConfigs() (configs []*ConfigState) {
+	for _, object := range s.All() {
+		if v, ok := object.(*ConfigState); ok {
+			if v.Ignore {
+				configs = append(configs, v)
+			}
+		}
+	}
+	return configs
+}
+
 func (s *Registry) ConfigsFrom(branch BranchKey) (configs []*ConfigState) {
 	for _, object := range s.All() {
 		if v, ok := object.(*ConfigState); ok {
@@ -171,6 +204,27 @@ func (s *Registry) ConfigRows() (rows []*ConfigRowState) {
 	return rows
 }
 
+func (s *Registry) IgnoreConfigRow(configID, rowID string) {
+	for _, object := range s.All() {
+		if v, ok := object.(*ConfigRowState); ok {
+			if v.ConfigID.String() == configID && v.ID.String() == rowID {
+				v.Ignore = true
+			}
+		}
+	}
+}
+
+func (s *Registry) IgnoredConfigRows() (rows []*ConfigRowState) {
+	for _, object := range s.All() {
+		if v, ok := object.(*ConfigRowState); ok {
+			if v.Ignore {
+				rows = append(rows, v)
+			}
+		}
+	}
+	return rows
+}
+
 func (s *Registry) ConfigRowsFrom(config ConfigKey) (rows []*ConfigRowState) {
 	for _, object := range s.All() {
 		if v, ok := object.(*ConfigRowState); ok {
@@ -183,6 +237,19 @@ func (s *Registry) ConfigRowsFrom(config ConfigKey) (rows []*ConfigRowState) {
 	return rows
 }
 
+func (s *Registry) SetIgnoredConfigsOrRows(ctx context.Context, fs filesystem.Fs, path string) error {
+	content, err := fs.ReadFile(ctx, filesystem.NewFileDef(path))
+	if err != nil {
+		return err
+	}
+
+	if content.Content == "" {
+		return nil
+	}
+
+	return s.applyIgnoredPatterns(content.Content)
+}
+
 func (s *Registry) GetPath(key Key) (AbsPath, bool) {
 	objectState, found := s.Get(key)
 	if !found {
@@ -261,3 +328,47 @@ func (s *Registry) GetOrCreateFrom(manifest ObjectManifest) (ObjectState, error)
 
 	return s.CreateFrom(manifest)
 }
+
+// applyIgnorePattern applies a single ignore pattern, marking the appropriate config or row as ignored.
+func (s *Registry) applyIgnorePattern(pattern string) error {
+	parts := strings.Split(pattern, "/")
+
+	switch len(parts) {
+	case 2:
+		// Ignore config by ID and name.
+		configID, componentID := parts[1], parts[0]
+		s.IgnoreConfig(configID, componentID)
+	case 3:
+		// Ignore specific config row.
+		configID, rowID := parts[1], parts[2]
+		s.IgnoreConfigRow(configID, rowID)
+	default:
+		return errors.Errorf("invalid ignore pattern format: %s", pattern)
+	}
+
+	return nil
+}
+
+// applyIgnoredPatterns parses the content for ignore patterns and applies them to configurations or rows.
+func (s *Registry) applyIgnoredPatterns(content string) error {
+	for _, pattern := range parseIgnoredPatterns(content) {
+		if err := s.applyIgnorePattern(pattern); err != nil {
+			continue
+		}
+	}
+	return nil
+}
+
+func parseIgnoredPatterns(content string) []string {
+	var ignorePatterns []string
+	lines := strings.Split(content, "\n")
+	for _, line := range lines {
+		trimmedLine := strings.TrimSpace(line)
+		// Skip empty lines and comments
+		if trimmedLine != "" && !strings.HasPrefix(trimmedLine, "#") {
+			ignorePatterns = append(ignorePatterns, trimmedLine)
+		}
+	}
+
+	return ignorePatterns
+}

internal/pkg/state/registry/registry_test.go

@@ -2,9 +2,11 @@ package registry
 
 import (
 	"context"
+	"fmt"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"github.com/keboola/keboola-as-code/internal/pkg/filesystem"
 	"github.com/keboola/keboola-as-code/internal/pkg/filesystem/aferofs"
@@ -175,6 +177,21 @@ func TestStateTrackRecordInvalid(t *testing.T) {
 	assert.Empty(t, s.UntrackedPaths())
 }
 
+func TestRegistry_SetIgnoredConfigsOrRows(t *testing.T) {
+	t.Parallel()
+	ctx := context.Background()
+	registry := newTestState(t, knownpaths.NewNop(ctx))
+	fs := aferofs.NewMemoryFs()
+	require.NoError(t, fs.WriteFile(ctx, filesystem.NewRawFile(`foo/bar1`, "keboola.bar/678/34\nkeboola.foo/345")))
+
+	require.NoError(t, registry.SetIgnoredConfigsOrRows(ctx, fs, "foo/bar1"))
+
+	assert.Len(t, registry.IgnoredConfigRows(), 1)
+	assert.Len(t, registry.IgnoredConfigs(), 1)
+	assert.Equal(t, registry.IgnoredConfigRows()[0].ID.String(), "34")
+	assert.Equal(t, registry.IgnoredConfigs()[0].ID.String(), "345")
+}
+
 func TestRegistry_GetPath(t *testing.T) {
 	t.Parallel()
 	ctx := context.Background()
@@ -301,3 +318,126 @@ func newTestState(t *testing.T, paths *knownpaths.Paths) *Registry {
 
 	return registry
 }
+
+func Test_parseIgnoredPatterns(t *testing.T) {
+	t.Parallel()
+	type args struct {
+		content string
+	}
+	tests := []struct {
+		name string
+		args args
+		want []string
+	}{
+		{
+			name: "with comments",
+			args: args{
+				content: "##dataapps\nkeboola.data-apps/12345\n##dataapps2\nkeboola.data-apps/123/rowId123\n##dataaps3\nkeboola.data-apps/12",
+			},
+			want: []string{
+				"keboola.data-apps/12345",
+				"keboola.data-apps/123/rowId123",
+				"keboola.data-apps/12",
+			},
+		},
+		{
+			name: "with empty lines",
+			args: args{
+				content: "##dataapps\n\n\n\n\n\nkeboola.data-apps/12345\n\t##dataapps2\nkeboola.data-apps/123\n##dataaps3\nkeboola.data-apps/12",
+			},
+			want: []string{
+				"keboola.data-apps/12345",
+				"keboola.data-apps/123",
+				"keboola.data-apps/12",
+			},
+		},
+		{
+			name: "empty file",
+			args: args{
+				content: "\n",
+			},
+			want: nil,
+		},
+		{
+			name: "error",
+			args: args{
+				content: "##dataapps\n\n\n\n\n\nkeboola.data-apps/12345\n\t##dataapps2\nkeboola.data-apps/123\n##dataaps3\nkeboola.data-apps/12",
+			},
+			want: []string{
+				"keboola.data-apps/12345",
+				"keboola.data-apps/123",
+				"keboola.data-apps/12",
+			},
+		},
+		{
+			name: "empty file",
+			args: args{
+				content: "\n",
+			},
+			want: nil,
+		},
+	}
+
+	for _, tt := range tests {
+		got := parseIgnoredPatterns(tt.args.content)
+		assert.Equal(t, tt.want, got)
+	}
+}
+
+func TestRegistry_applyIgnoredPatterns(t *testing.T) {
+	t.Parallel()
+	ctx := context.Background()
+	registry := newTestState(t, knownpaths.NewNop(ctx))
+
+	type args struct {
+		pattern string
+	}
+
+	tests := []struct {
+		name    string
+		args    args
+		wantErr assert.ErrorAssertionFunc
+	}{
+		{
+			name: "empty patterns",
+			args: args{
+				pattern: "",
+			},
+			wantErr: assert.Error,
+		},
+		{
+			name: "wrong pattern",
+			args: args{
+				pattern: "wrong pattern",
+			},
+			wantErr: assert.Error,
+		},
+		{
+			name: "too long pattern",
+			args: args{
+				pattern: "keboola.bar/687/1234/1234",
+			},
+			wantErr: assert.Error,
+		},
+		{
+			name: "short pattern",
+			args: args{
+				pattern: "keboola.bar",
+			},
+			wantErr: assert.Error,
+		},
+		{
+			name: "correct pattern",
+			args: args{
+				pattern: "keboola.bar/687",
+			},
+			wantErr: assert.NoError,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			tt.wantErr(t, registry.applyIgnorePattern(tt.args.pattern), fmt.Sprintf("applyIgnoredPatterns(%v)", tt.args.pattern))
+		})
+	}
+}

pkg/lib/operation/project/sync/pull/operation.go

@@ -11,6 +11,7 @@ import (
 	"github.com/keboola/keboola-as-code/internal/pkg/plan/pull"
 	"github.com/keboola/keboola-as-code/internal/pkg/project"
 	"github.com/keboola/keboola-as-code/internal/pkg/project/cachefile"
+	"github.com/keboola/keboola-as-code/internal/pkg/state/registry"
 	"github.com/keboola/keboola-as-code/internal/pkg/telemetry"
 	"github.com/keboola/keboola-as-code/internal/pkg/utils/errors"
 	saveManifest "github.com/keboola/keboola-as-code/pkg/lib/operation/project/local/manifest/save"
@@ -49,6 +50,13 @@ func Run(ctx context.Context, projectState *project.State, o Options, d dependen
 
 	logger := d.Logger()
 
+	if projectState.Fs().Exists(ctx, registry.KBCIgnoreFilePath) {
+		if err := projectState.SetIgnoredConfigsOrRows(ctx, projectState.Fs(), registry.KBCIgnoreFilePath); err != nil {
+			return err
+		}
+		ignoreConfigsAndRows(projectState)
+	}
+
 	// Diff
 	results, err := createDiff.Run(ctx, createDiff.Options{Objects: projectState}, d, diff.WithIgnoreBranchName(projectState.ProjectManifest().AllowTargetENV()))
 	if err != nil {
@@ -118,3 +126,17 @@ func Run(ctx context.Context, projectState *project.State, o Options, d dependen
 
 	return nil
 }
+
+func ignoreConfigsAndRows(projectState *project.State) {
+	if len(projectState.IgnoredConfigRows()) > 0 {
+		for _, v := range projectState.IgnoredConfigRows() {
+			v.SetRemoteState(nil)
+		}
+	}
+
+	if len(projectState.IgnoredConfigs()) > 0 {
+		for _, v := range projectState.IgnoredConfigs() {
+			v.SetRemoteState(nil)
+		}
+	}
+}

pkg/lib/operation/project/sync/push/operation.go

@@ -72,7 +72,7 @@ func Run(ctx context.Context, projectState *project.State, o Options, d dependen
 	}
 
 	// Get plan
-	plan, err := push.NewPlan(results, projectState.ProjectManifest().AllowTargetENV())
+	plan, err := push.NewPlan(results)
 	if err != nil {
 		return err
 	}

test/cli/allow-target-env/pull-ignore-configs/args

@@ -0,0 +1 @@
+pull --storage-api-token %%TEST_KBC_STORAGE_API_TOKEN%%

test/cli/allow-target-env/pull-ignore-configs/env

@@ -0,0 +1,2 @@
+KBC_PROJECT_ID=%%TEST_KBC_PROJECT_ID%%
+KBC_BRANCH_ID=%%TEST_BRANCH_MAIN_ID%%

test/cli/allow-target-env/pull-ignore-configs/expected-code

@@ -0,0 +1 @@
+0