Merge pull request #247 from MichaelMure/bridge-origin

bridge: move keyOrigin to core package

14 files changed, 103 insertions, 101 deletions

diff --git a/bridge/core/bridge.go b/bridge/core/bridge.go
index e419ed77..a3133b9c 100644
--- a/bridge/core/bridge.go
+++ b/bridge/core/bridge.go
@@ -20,8 +20,8 @@ var ErrImportNotSupported = errors.New("import is not supported")
 var ErrExportNotSupported = errors.New("export is not supported")
 
 const (
-	KeyTarget = "target"
-	KeyOrigin = "origin"
+	ConfigKeyTarget = "target"
+	MetaKeyOrigin   = "origin"
 
 	bridgeConfigKeyPrefix = "git-bug.bridge"
 )
@@ -102,7 +102,7 @@ func LoadBridge(repo *cache.RepoCache, name string) (*Bridge, error) {
 		return nil, err
 	}
 
-	target := conf[KeyTarget]
+	target := conf[ConfigKeyTarget]
 	bridge, err := NewBridge(repo, target, name)
 	if err != nil {
 		return nil, err
diff --git a/bridge/github/config.go b/bridge/github/config.go
index 16abfa09..434a2c63 100644
--- a/bridge/github/config.go
+++ b/bridge/github/config.go
@@ -114,7 +114,7 @@ func (g *Github) Configure(repo repository.RepoCommon, params core.BridgeParams)
 		return nil, fmt.Errorf("project doesn't exist or authentication token has an incorrect scope")
 	}
 
-	conf[core.KeyTarget] = target
+	conf[core.ConfigKeyTarget] = target
 	conf[keyToken] = token
 	conf[keyOwner] = owner
 	conf[keyProject] = project
@@ -128,8 +128,8 @@ func (g *Github) Configure(repo repository.RepoCommon, params core.BridgeParams)
 }
 
 func (*Github) ValidateConfig(conf core.Configuration) error {
-	if v, ok := conf[core.KeyTarget]; !ok {
-		return fmt.Errorf("missing %s key", core.KeyTarget)
+	if v, ok := conf[core.ConfigKeyTarget]; !ok {
+		return fmt.Errorf("missing %s key", core.ConfigKeyTarget)
 	} else if v != target {
 		return fmt.Errorf("unexpected target name: %v", v)
 	}
diff --git a/bridge/github/export.go b/bridge/github/export.go
index a79256fc..e2a185b0 100644
--- a/bridge/github/export.go
+++ b/bridge/github/export.go
@@ -174,16 +174,16 @@ func (ge *githubExporter) exportBug(ctx context.Context, b *cache.BugCache, sinc
 	author := snapshot.Author
 
 	// skip bug if origin is not allowed
-	origin, ok := snapshot.GetCreateMetadata(keyOrigin)
+	origin, ok := snapshot.GetCreateMetadata(core.MetaKeyOrigin)
 	if ok && origin != target {
 		out <- core.NewExportNothing(b.Id(), fmt.Sprintf("issue tagged with origin: %s", origin))
 		return
 	}
 
 	// get github bug ID
-	githubID, ok := snapshot.GetCreateMetadata(keyGithubId)
+	githubID, ok := snapshot.GetCreateMetadata(metaKeyGithubId)
 	if ok {
-		githubURL, ok := snapshot.GetCreateMetadata(keyGithubUrl)
+		githubURL, ok := snapshot.GetCreateMetadata(metaKeyGithubUrl)
 		if !ok {
 			// if we find github ID, github URL must be found too
 			err := fmt.Errorf("incomplete Github metadata: expected to find issue URL")
@@ -258,7 +258,7 @@ func (ge *githubExporter) exportBug(ctx context.Context, b *cache.BugCache, sinc
 
 		// ignore operations already existing in github (due to import or export)
 		// cache the ID of already exported or imported issues and events from Github
-		if id, ok := op.GetMetadata(keyGithubId); ok {
+		if id, ok := op.GetMetadata(metaKeyGithubId); ok {
 			ge.cachedOperationIDs[op.Id()] = id
 			out <- core.NewExportNothing(op.Id(), "already exported operation")
 			continue
@@ -437,8 +437,8 @@ func markOperationAsExported(b *cache.BugCache, target entity.Id, githubID, gith
 	_, err := b.SetMetadata(
 		target,
 		map[string]string{
-			keyGithubId:  githubID,
-			keyGithubUrl: githubURL,
+			metaKeyGithubId:  githubID,
+			metaKeyGithubUrl: githubURL,
 		},
 	)
 
diff --git a/bridge/github/export_test.go b/bridge/github/export_test.go
index e39ace01..dba72f3f 100644
--- a/bridge/github/export_test.go
+++ b/bridge/github/export_test.go
@@ -233,27 +233,27 @@ func TestPushPull(t *testing.T) {
 			for _, op := range tt.bug.Snapshot().Operations {
 				// Check if the originals operations (*not* SetMetadata) are tagged properly
 				if _, ok := op.(*bug.SetMetadataOperation); !ok {
-					_, haveIDMetadata := op.GetMetadata(keyGithubId)
+					_, haveIDMetadata := op.GetMetadata(metaKeyGithubId)
 					require.True(t, haveIDMetadata)
 
-					_, haveURLMetada := op.GetMetadata(keyGithubUrl)
+					_, haveURLMetada := op.GetMetadata(metaKeyGithubUrl)
 					require.True(t, haveURLMetada)
 				}
 			}
 
 			// get bug github ID
-			bugGithubID, ok := tt.bug.Snapshot().GetCreateMetadata(keyGithubId)
+			bugGithubID, ok := tt.bug.Snapshot().GetCreateMetadata(metaKeyGithubId)
 			require.True(t, ok)
 
 			// retrieve bug from backendTwo
-			importedBug, err := backendTwo.ResolveBugCreateMetadata(keyGithubId, bugGithubID)
+			importedBug, err := backendTwo.ResolveBugCreateMetadata(metaKeyGithubId, bugGithubID)
 			require.NoError(t, err)
 
 			// verify bug have same number of original operations
 			require.Len(t, importedBug.Snapshot().Operations, tt.numOrOp)
 
 			// verify bugs are taged with origin=github
-			issueOrigin, ok := importedBug.Snapshot().GetCreateMetadata(keyOrigin)
+			issueOrigin, ok := importedBug.Snapshot().GetCreateMetadata(core.MetaKeyOrigin)
 			require.True(t, ok)
 			require.Equal(t, issueOrigin, target)
 
diff --git a/bridge/github/import.go b/bridge/github/import.go
index 7c4deb50..d3d56cbc 100644
--- a/bridge/github/import.go
+++ b/bridge/github/import.go
@@ -15,10 +15,9 @@ import (
 )
 
 const (
-	keyOrigin      = "origin"
-	keyGithubId    = "github-id"
-	keyGithubUrl   = "github-url"
-	keyGithubLogin = "github-login"
+	metaKeyGithubId    = "github-id"
+	metaKeyGithubUrl   = "github-url"
+	metaKeyGithubLogin = "github-login"
 )
 
 // githubImporter implement the Importer interface
@@ -92,7 +91,7 @@ func (gi *githubImporter) ensureIssue(repo *cache.RepoCache, issue issueTimeline
 	}
 
 	// resolve bug
-	b, err := repo.ResolveBugCreateMetadata(keyGithubUrl, issue.Url.String())
+	b, err := repo.ResolveBugCreateMetadata(metaKeyGithubUrl, issue.Url.String())
 	if err != nil && err != bug.ErrBugNotExist {
 		return nil, err
 	}
@@ -119,9 +118,9 @@ func (gi *githubImporter) ensureIssue(repo *cache.RepoCache, issue issueTimeline
 				cleanText,
 				nil,
 				map[string]string{
-					keyOrigin:    target,
-					keyGithubId:  parseId(issue.Id),
-					keyGithubUrl: issue.Url.String(),
+					core.MetaKeyOrigin: target,
+					metaKeyGithubId:    parseId(issue.Id),
+					metaKeyGithubUrl:   issue.Url.String(),
 				})
 			if err != nil {
 				return nil, err
@@ -157,9 +156,9 @@ func (gi *githubImporter) ensureIssue(repo *cache.RepoCache, issue issueTimeline
 					cleanText,
 					nil,
 					map[string]string{
-						keyOrigin:    target,
-						keyGithubId:  parseId(issue.Id),
-						keyGithubUrl: issue.Url.String(),
+						core.MetaKeyOrigin: target,
+						metaKeyGithubId:    parseId(issue.Id),
+						metaKeyGithubUrl:   issue.Url.String(),
 					},
 				)
 
@@ -173,7 +172,7 @@ func (gi *githubImporter) ensureIssue(repo *cache.RepoCache, issue issueTimeline
 			}
 
 			// other edits will be added as CommentEdit operations
-			target, err := b.ResolveOperationWithMetadata(keyGithubId, parseId(issue.Id))
+			target, err := b.ResolveOperationWithMetadata(metaKeyGithubId, parseId(issue.Id))
 			if err != nil {
 				return nil, err
 			}
@@ -206,7 +205,7 @@ func (gi *githubImporter) ensureTimelineItem(repo *cache.RepoCache, b *cache.Bug
 
 	case "LabeledEvent":
 		id := parseId(item.LabeledEvent.Id)
-		_, err := b.ResolveOperationWithMetadata(keyGithubId, id)
+		_, err := b.ResolveOperationWithMetadata(metaKeyGithubId, id)
 		if err == nil {
 			reason := fmt.Sprintf("operation already imported: %v", item.Typename)
 			gi.out <- core.NewImportNothing("", reason)
@@ -227,7 +226,7 @@ func (gi *githubImporter) ensureTimelineItem(repo *cache.RepoCache, b *cache.Bug
 				string(item.LabeledEvent.Label.Name),
 			},
 			nil,
-			map[string]string{keyGithubId: id},
+			map[string]string{metaKeyGithubId: id},
 		)
 		if err != nil {
 			return err
@@ -238,7 +237,7 @@ func (gi *githubImporter) ensureTimelineItem(repo *cache.RepoCache, b *cache.Bug
 
 	case "UnlabeledEvent":
 		id := parseId(item.UnlabeledEvent.Id)
-		_, err := b.ResolveOperationWithMetadata(keyGithubId, id)
+		_, err := b.ResolveOperationWithMetadata(metaKeyGithubId, id)
 		if err == nil {
 			reason := fmt.Sprintf("operation already imported: %v", item.Typename)
 			gi.out <- core.NewImportNothing("", reason)
@@ -259,7 +258,7 @@ func (gi *githubImporter) ensureTimelineItem(repo *cache.RepoCache, b *cache.Bug
 			[]string{
 				string(item.UnlabeledEvent.Label.Name),
 			},
-			map[string]string{keyGithubId: id},
+			map[string]string{metaKeyGithubId: id},
 		)
 		if err != nil {
 			return err
@@ -270,7 +269,7 @@ func (gi *githubImporter) ensureTimelineItem(repo *cache.RepoCache, b *cache.Bug
 
 	case "ClosedEvent":
 		id := parseId(item.ClosedEvent.Id)
-		_, err := b.ResolveOperationWithMetadata(keyGithubId, id)
+		_, err := b.ResolveOperationWithMetadata(metaKeyGithubId, id)
 		if err != cache.ErrNoMatchingOp {
 			return err
 		}
@@ -286,7 +285,7 @@ func (gi *githubImporter) ensureTimelineItem(repo *cache.RepoCache, b *cache.Bug
 		op, err := b.CloseRaw(
 			author,
 			item.ClosedEvent.CreatedAt.Unix(),
-			map[string]string{keyGithubId: id},
+			map[string]string{metaKeyGithubId: id},
 		)
 
 		if err != nil {
@@ -298,7 +297,7 @@ func (gi *githubImporter) ensureTimelineItem(repo *cache.RepoCache, b *cache.Bug
 
 	case "ReopenedEvent":
 		id := parseId(item.ReopenedEvent.Id)
-		_, err := b.ResolveOperationWithMetadata(keyGithubId, id)
+		_, err := b.ResolveOperationWithMetadata(metaKeyGithubId, id)
 		if err != cache.ErrNoMatchingOp {
 			return err
 		}
@@ -314,7 +313,7 @@ func (gi *githubImporter) ensureTimelineItem(repo *cache.RepoCache, b *cache.Bug
 		op, err := b.OpenRaw(
 			author,
 			item.ReopenedEvent.CreatedAt.Unix(),
-			map[string]string{keyGithubId: id},
+			map[string]string{metaKeyGithubId: id},
 		)
 
 		if err != nil {
@@ -326,7 +325,7 @@ func (gi *githubImporter) ensureTimelineItem(repo *cache.RepoCache, b *cache.Bug
 
 	case "RenamedTitleEvent":
 		id := parseId(item.RenamedTitleEvent.Id)
-		_, err := b.ResolveOperationWithMetadata(keyGithubId, id)
+		_, err := b.ResolveOperationWithMetadata(metaKeyGithubId, id)
 		if err != cache.ErrNoMatchingOp {
 			return err
 		}
@@ -343,7 +342,7 @@ func (gi *githubImporter) ensureTimelineItem(repo *cache.RepoCache, b *cache.Bug
 			author,
 			item.RenamedTitleEvent.CreatedAt.Unix(),
 			string(item.RenamedTitleEvent.CurrentTitle),
-			map[string]string{keyGithubId: id},
+			map[string]string{metaKeyGithubId: id},
 		)
 		if err != nil {
 			return err
@@ -367,7 +366,7 @@ func (gi *githubImporter) ensureTimelineComment(repo *cache.RepoCache, b *cache.
 		return err
 	}
 
-	targetOpID, err := b.ResolveOperationWithMetadata(keyGithubId, parseId(item.Id))
+	targetOpID, err := b.ResolveOperationWithMetadata(metaKeyGithubId, parseId(item.Id))
 	if err == nil {
 		gi.out <- core.NewImportNothing("", "comment already imported")
 	} else if err != cache.ErrNoMatchingOp {
@@ -390,8 +389,8 @@ func (gi *githubImporter) ensureTimelineComment(repo *cache.RepoCache, b *cache.
 				cleanText,
 				nil,
 				map[string]string{
-					keyGithubId:  parseId(item.Id),
-					keyGithubUrl: parseId(item.Url.String()),
+					metaKeyGithubId:  parseId(item.Id),
+					metaKeyGithubUrl: parseId(item.Url.String()),
 				},
 			)
 			if err != nil {
@@ -428,8 +427,8 @@ func (gi *githubImporter) ensureTimelineComment(repo *cache.RepoCache, b *cache.
 					cleanText,
 					nil,
 					map[string]string{
-						keyGithubId:  parseId(item.Id),
-						keyGithubUrl: item.Url.String(),
+						metaKeyGithubId:  parseId(item.Id),
+						metaKeyGithubUrl: item.Url.String(),
 					},
 				)
 				if err != nil {
@@ -451,7 +450,7 @@ func (gi *githubImporter) ensureTimelineComment(repo *cache.RepoCache, b *cache.
 }
 
 func (gi *githubImporter) ensureCommentEdit(repo *cache.RepoCache, b *cache.BugCache, target entity.Id, edit userContentEdit) error {
-	_, err := b.ResolveOperationWithMetadata(keyGithubId, parseId(edit.Id))
+	_, err := b.ResolveOperationWithMetadata(metaKeyGithubId, parseId(edit.Id))
 	if err == nil {
 		gi.out <- core.NewImportNothing(b.Id(), "edition already imported")
 		return nil
@@ -485,7 +484,7 @@ func (gi *githubImporter) ensureCommentEdit(repo *cache.RepoCache, b *cache.BugC
 			target,
 			cleanText,
 			map[string]string{
-				keyGithubId: parseId(edit.Id),
+				metaKeyGithubId: parseId(edit.Id),
 			},
 		)
 
@@ -508,7 +507,7 @@ func (gi *githubImporter) ensurePerson(repo *cache.RepoCache, actor *actor) (*ca
 	}
 
 	// Look first in the cache
-	i, err := repo.ResolveIdentityImmutableMetadata(keyGithubLogin, string(actor.Login))
+	i, err := repo.ResolveIdentityImmutableMetadata(metaKeyGithubLogin, string(actor.Login))
 	if err == nil {
 		return i, nil
 	}
@@ -543,7 +542,7 @@ func (gi *githubImporter) ensurePerson(repo *cache.RepoCache, actor *actor) (*ca
 		string(actor.Login),
 		string(actor.AvatarUrl),
 		map[string]string{
-			keyGithubLogin: string(actor.Login),
+			metaKeyGithubLogin: string(actor.Login),
 		},
 	)
 
@@ -557,7 +556,7 @@ func (gi *githubImporter) ensurePerson(repo *cache.RepoCache, actor *actor) (*ca
 
 func (gi *githubImporter) getGhost(repo *cache.RepoCache) (*cache.IdentityCache, error) {
 	// Look first in the cache
-	i, err := repo.ResolveIdentityImmutableMetadata(keyGithubLogin, "ghost")
+	i, err := repo.ResolveIdentityImmutableMetadata(metaKeyGithubLogin, "ghost")
 	if err == nil {
 		return i, nil
 	}
@@ -592,7 +591,7 @@ func (gi *githubImporter) getGhost(repo *cache.RepoCache) (*cache.IdentityCache,
 		string(q.User.Login),
 		string(q.User.AvatarUrl),
 		map[string]string{
-			keyGithubLogin: string(q.User.Login),
+			metaKeyGithubLogin: string(q.User.Login),
 		},
 	)
 }
diff --git a/bridge/github/import_test.go b/bridge/github/import_test.go
index 41bcb58d..f1558831 100644
--- a/bridge/github/import_test.go
+++ b/bridge/github/import_test.go
@@ -163,7 +163,7 @@ func Test_Importer(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			b, err := backend.ResolveBugCreateMetadata(keyGithubUrl, tt.url)
+			b, err := backend.ResolveBugCreateMetadata(metaKeyGithubUrl, tt.url)
 			require.NoError(t, err)
 
 			ops := b.Snapshot().Operations
diff --git a/bridge/gitlab/config.go b/bridge/gitlab/config.go
index a673af8c..f2e667a8 100644
--- a/bridge/gitlab/config.go
+++ b/bridge/gitlab/config.go
@@ -80,7 +80,7 @@ func (g *Gitlab) Configure(repo repository.RepoCommon, params core.BridgeParams)
 
 	conf[keyProjectID] = strconv.Itoa(id)
 	conf[keyToken] = token
-	conf[core.KeyTarget] = target
+	conf[core.ConfigKeyTarget] = target
 
 	err = g.ValidateConfig(conf)
 	if err != nil {
@@ -91,8 +91,8 @@ func (g *Gitlab) Configure(repo repository.RepoCommon, params core.BridgeParams)
 }
 
 func (g *Gitlab) ValidateConfig(conf core.Configuration) error {
-	if v, ok := conf[core.KeyTarget]; !ok {
-		return fmt.Errorf("missing %s key", core.KeyTarget)
+	if v, ok := conf[core.ConfigKeyTarget]; !ok {
+		return fmt.Errorf("missing %s key", core.ConfigKeyTarget)
 	} else if v != target {
 		return fmt.Errorf("unexpected target name: %v", v)
 	}
diff --git a/bridge/gitlab/export.go b/bridge/gitlab/export.go
index 251d720a..44778b44 100644
--- a/bridge/gitlab/export.go
+++ b/bridge/gitlab/export.go
@@ -141,7 +141,7 @@ func (ge *gitlabExporter) exportBug(ctx context.Context, b *cache.BugCache, sinc
 	// from Gitlab) and we do not have the token of the bug author, there is nothing we can do.
 
 	// skip bug if origin is not allowed
-	origin, ok := snapshot.GetCreateMetadata(core.KeyOrigin)
+	origin, ok := snapshot.GetCreateMetadata(core.MetaKeyOrigin)
 	if ok && origin != target {
 		out <- core.NewExportNothing(b.Id(), fmt.Sprintf("issue tagged with origin: %s", origin))
 		return
@@ -152,9 +152,9 @@ func (ge *gitlabExporter) exportBug(ctx context.Context, b *cache.BugCache, sinc
 	author := snapshot.Author
 
 	// get gitlab bug ID
-	gitlabID, ok := snapshot.GetCreateMetadata(keyGitlabId)
+	gitlabID, ok := snapshot.GetCreateMetadata(metaKeyGitlabId)
 	if ok {
-		projectID, ok := snapshot.GetCreateMetadata(keyGitlabProject)
+		projectID, ok := snapshot.GetCreateMetadata(metaKeyGitlabProject)
 		if !ok {
 			err := fmt.Errorf("expected to find gitlab project id")
 			out <- core.NewExportError(err, b.Id())
@@ -199,9 +199,9 @@ func (ge *gitlabExporter) exportBug(ctx context.Context, b *cache.BugCache, sinc
 		_, err = b.SetMetadata(
 			createOp.Id(),
 			map[string]string{
-				keyGitlabId:      idString,
-				keyGitlabUrl:     url,
-				keyGitlabProject: ge.repositoryID,
+				metaKeyGitlabId:      idString,
+				metaKeyGitlabUrl:     url,
+				metaKeyGitlabProject: ge.repositoryID,
 			},
 		)
 		if err != nil {
@@ -235,7 +235,7 @@ func (ge *gitlabExporter) exportBug(ctx context.Context, b *cache.BugCache, sinc
 
 		// ignore operations already existing in gitlab (due to import or export)
 		// cache the ID of already exported or imported issues and events from Gitlab
-		if id, ok := op.GetMetadata(keyGitlabId); ok {
+		if id, ok := op.GetMetadata(metaKeyGitlabId); ok {
 			ge.cachedOperationIDs[op.Id().String()] = id
 			out <- core.NewExportNothing(op.Id(), "already exported operation")
 			continue
@@ -378,8 +378,8 @@ func markOperationAsExported(b *cache.BugCache, target entity.Id, gitlabID, gitl
 	_, err := b.SetMetadata(
 		target,
 		map[string]string{
-			keyGitlabId:  gitlabID,
-			keyGitlabUrl: gitlabURL,
+			metaKeyGitlabId:  gitlabID,
+			metaKeyGitlabUrl: gitlabURL,
 		},
 	)
 
diff --git a/bridge/gitlab/export_test.go b/bridge/gitlab/export_test.go
index 3d3f406f..26b47bfb 100644
--- a/bridge/gitlab/export_test.go
+++ b/bridge/gitlab/export_test.go
@@ -236,27 +236,27 @@ func TestPushPull(t *testing.T) {
 			for _, op := range tt.bug.Snapshot().Operations {
 				// Check if the originals operations (*not* SetMetadata) are tagged properly
 				if _, ok := op.(*bug.SetMetadataOperation); !ok {
-					_, haveIDMetadata := op.GetMetadata(keyGitlabId)
+					_, haveIDMetadata := op.GetMetadata(metaKeyGitlabId)
 					require.True(t, haveIDMetadata)
 
-					_, haveURLMetada := op.GetMetadata(keyGitlabUrl)
+					_, haveURLMetada := op.GetMetadata(metaKeyGitlabUrl)
 					require.True(t, haveURLMetada)
 				}
 			}
 
 			// get bug gitlab ID
-			bugGitlabID, ok := tt.bug.Snapshot().GetCreateMetadata(keyGitlabId)
+			bugGitlabID, ok := tt.bug.Snapshot().GetCreateMetadata(metaKeyGitlabId)
 			require.True(t, ok)
 
 			// retrieve bug from backendTwo
-			importedBug, err := backendTwo.ResolveBugCreateMetadata(keyGitlabId, bugGitlabID)
+			importedBug, err := backendTwo.ResolveBugCreateMetadata(metaKeyGitlabId, bugGitlabID)
 			require.NoError(t, err)
 
 			// verify bug have same number of original operations
 			require.Len(t, importedBug.Snapshot().Operations, tt.numOpImp)
 
 			// verify bugs are taged with origin=gitlab
-			issueOrigin, ok := importedBug.Snapshot().GetCreateMetadata(core.KeyOrigin)
+			issueOrigin, ok := importedBug.Snapshot().GetCreateMetadata(core.MetaKeyOrigin)
 			require.True(t, ok)
 			require.Equal(t, issueOrigin, target)
 
diff --git a/bridge/gitlab/gitlab.go b/bridge/gitlab/gitlab.go
index 05721bfe..d976d813 100644
--- a/bridge/gitlab/gitlab.go
+++ b/bridge/gitlab/gitlab.go
@@ -12,10 +12,10 @@ import (
 const (
 	target = "gitlab"
 
-	keyGitlabId      = "gitlab-id"
-	keyGitlabUrl     = "gitlab-url"
-	keyGitlabLogin   = "gitlab-login"
-	keyGitlabProject = "gitlab-project-id"
+	metaKeyGitlabId      = "gitlab-id"
+	metaKeyGitlabUrl     = "gitlab-url"
+	metaKeyGitlabLogin   = "gitlab-login"
+	metaKeyGitlabProject = "gitlab-project-id"
 
 	keyProjectID = "project-id"
 	keyToken     = "token"
diff --git a/bridge/gitlab/import.go b/bridge/gitlab/import.go
index e2015773..e92067af 100644
--- a/bridge/gitlab/import.go
+++ b/bridge/gitlab/import.go
@@ -97,7 +97,7 @@ func (gi *gitlabImporter) ensureIssue(repo *cache.RepoCache, issue *gitlab.Issue
 	}
 
 	// resolve bug
-	b, err := repo.ResolveBugCreateMetadata(keyGitlabUrl, issue.WebURL)
+	b, err := repo.ResolveBugCreateMetadata(metaKeyGitlabUrl, issue.WebURL)
 	if err == nil {
 		gi.out <- core.NewImportNothing("", "bug already imported")
 		return b, nil
@@ -120,10 +120,10 @@ func (gi *gitlabImporter) ensureIssue(repo *cache.RepoCache, issue *gitlab.Issue
 		cleanText,
 		nil,
 		map[string]string{
-			core.KeyOrigin:   target,
-			keyGitlabId:      parseID(issue.IID),
-			keyGitlabUrl:     issue.WebURL,
-			keyGitlabProject: gi.conf[keyProjectID],
+			core.MetaKeyOrigin:   target,
+			metaKeyGitlabId:      parseID(issue.IID),
+			metaKeyGitlabUrl:     issue.WebURL,
+			metaKeyGitlabProject: gi.conf[keyProjectID],
 		},
 	)
 
@@ -140,7 +140,7 @@ func (gi *gitlabImporter) ensureIssue(repo *cache.RepoCache, issue *gitlab.Issue
 func (gi *gitlabImporter) ensureNote(repo *cache.RepoCache, b *cache.BugCache, note *gitlab.Note) error {
 	gitlabID := parseID(note.ID)
 
-	id, errResolve := b.ResolveOperationWithMetadata(keyGitlabId, gitlabID)
+	id, errResolve := b.ResolveOperationWithMetadata(metaKeyGitlabId, gitlabID)
 	if errResolve != nil && errResolve != cache.ErrNoMatchingOp {
 		return errResolve
 	}
@@ -162,7 +162,7 @@ func (gi *gitlabImporter) ensureNote(repo *cache.RepoCache, b *cache.BugCache, n
 			author,
 			note.CreatedAt.Unix(),
 			map[string]string{
-				keyGitlabId: gitlabID,
+				metaKeyGitlabId: gitlabID,
 			},
 		)
 		if err != nil {
@@ -180,7 +180,7 @@ func (gi *gitlabImporter) ensureNote(repo *cache.RepoCache, b *cache.BugCache, n
 			author,
 			note.CreatedAt.Unix(),
 			map[string]string{
-				keyGitlabId: gitlabID,
+				metaKeyGitlabId: gitlabID,
 			},
 		)
 		if err != nil {
@@ -204,7 +204,7 @@ func (gi *gitlabImporter) ensureNote(repo *cache.RepoCache, b *cache.BugCache, n
 				firstComment.Id(),
 				issue.Description,
 				map[string]string{
-					keyGitlabId: gitlabID,
+					metaKeyGitlabId: gitlabID,
 				},
 			)
 			if err != nil {
@@ -230,7 +230,7 @@ func (gi *gitlabImporter) ensureNote(repo *cache.RepoCache, b *cache.BugCache, n
 				cleanText,
 				nil,
 				map[string]string{
-					keyGitlabId: gitlabID,
+					metaKeyGitlabId: gitlabID,
 				},
 			)
 			if err != nil {
@@ -278,7 +278,7 @@ func (gi *gitlabImporter) ensureNote(repo *cache.RepoCache, b *cache.BugCache, n
 			note.CreatedAt.Unix(),
 			body,
 			map[string]string{
-				keyGitlabId: gitlabID,
+				metaKeyGitlabId: gitlabID,
 			},
 		)
 		if err != nil {
@@ -311,7 +311,7 @@ func (gi *gitlabImporter) ensureNote(repo *cache.RepoCache, b *cache.BugCache, n
 }
 
 func (gi *gitlabImporter) ensureLabelEvent(repo *cache.RepoCache, b *cache.BugCache, labelEvent *gitlab.LabelEvent) error {
-	_, err := b.ResolveOperationWithMetadata(keyGitlabId, parseID(labelEvent.ID))
+	_, err := b.ResolveOperationWithMetadata(metaKeyGitlabId, parseID(labelEvent.ID))
 	if err != cache.ErrNoMatchingOp {
 		return err
 	}
@@ -330,7 +330,7 @@ func (gi *gitlabImporter) ensureLabelEvent(repo *cache.RepoCache, b *cache.BugCa
 			[]string{labelEvent.Label.Name},
 			nil,
 			map[string]string{
-				keyGitlabId: parseID(labelEvent.ID),
+				metaKeyGitlabId: parseID(labelEvent.ID),
 			},
 		)
 
@@ -341,7 +341,7 @@ func (gi *gitlabImporter) ensureLabelEvent(repo *cache.RepoCache, b *cache.BugCa
 			nil,
 			[]string{labelEvent.Label.Name},
 			map[string]string{
-				keyGitlabId: parseID(labelEvent.ID),
+				metaKeyGitlabId: parseID(labelEvent.ID),
 			},
 		)
 
@@ -354,7 +354,7 @@ func (gi *gitlabImporter) ensureLabelEvent(repo *cache.RepoCache, b *cache.BugCa
 
 func (gi *gitlabImporter) ensurePerson(repo *cache.RepoCache, id int) (*cache.IdentityCache, error) {
 	// Look first in the cache
-	i, err := repo.ResolveIdentityImmutableMetadata(keyGitlabId, strconv.Itoa(id))
+	i, err := repo.ResolveIdentityImmutableMetadata(metaKeyGitlabId, strconv.Itoa(id))
 	if err == nil {
 		return i, nil
 	}
@@ -376,8 +376,8 @@ func (gi *gitlabImporter) ensurePerson(repo *cache.RepoCache, id int) (*cache.Id
 		user.AvatarURL,
 		map[string]string{
 			// because Gitlab
-			keyGitlabId:    strconv.Itoa(id),
-			keyGitlabLogin: user.Username,
+			metaKeyGitlabId:    strconv.Itoa(id),
+			metaKeyGitlabLogin: user.Username,
 		},
 	)
 	if err != nil {
diff --git a/bridge/gitlab/import_test.go b/bridge/gitlab/import_test.go
index a6fd8524..8e596349 100644
--- a/bridge/gitlab/import_test.go
+++ b/bridge/gitlab/import_test.go
@@ -116,7 +116,7 @@ func TestImport(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			b, err := backend.ResolveBugCreateMetadata(keyGitlabUrl, tt.url)
+			b, err := backend.ResolveBugCreateMetadata(metaKeyGitlabUrl, tt.url)
 			require.NoError(t, err)
 
 			ops := b.Snapshot().Operations
diff --git a/bridge/launchpad/config.go b/bridge/launchpad/config.go
index 6669d0fa..be81c0ac 100644
--- a/bridge/launchpad/config.go
+++ b/bridge/launchpad/config.go
@@ -62,7 +62,7 @@ func (l *Launchpad) Configure(repo repository.RepoCommon, params core.BridgePara
 	}
 
 	conf[keyProject] = project
-	conf[core.KeyTarget] = target
+	conf[core.ConfigKeyTarget] = target
 
 	err = l.ValidateConfig(conf)
 	if err != nil {
@@ -77,8 +77,8 @@ func (*Launchpad) ValidateConfig(conf core.Configuration) error {
 		return fmt.Errorf("missing %s key", keyProject)
 	}
 
-	if _, ok := conf[core.KeyTarget]; !ok {
-		return fmt.Errorf("missing %s key", core.KeyTarget)
+	if _, ok := conf[core.ConfigKeyTarget]; !ok {
+		return fmt.Errorf("missing %s key", core.ConfigKeyTarget)
 	}
 
 	return nil
diff --git a/bridge/launchpad/import.go b/bridge/launchpad/import.go
index 7f50d898..178945b6 100644
--- a/bridge/launchpad/import.go
+++ b/bridge/launchpad/import.go
@@ -20,12 +20,14 @@ func (li *launchpadImporter) Init(conf core.Configuration) error {
 	return nil
 }
 
-const keyLaunchpadID = "launchpad-id"
-const keyLaunchpadLogin = "launchpad-login"
+const (
+	metaKeyLaunchpadID    = "launchpad-id"
+	metaKeyLaunchpadLogin = "launchpad-login"
+)
 
 func (li *launchpadImporter) ensurePerson(repo *cache.RepoCache, owner LPPerson) (*cache.IdentityCache, error) {
 	// Look first in the cache
-	i, err := repo.ResolveIdentityImmutableMetadata(keyLaunchpadLogin, owner.Login)
+	i, err := repo.ResolveIdentityImmutableMetadata(metaKeyLaunchpadLogin, owner.Login)
 	if err == nil {
 		return i, nil
 	}
@@ -39,7 +41,7 @@ func (li *launchpadImporter) ensurePerson(repo *cache.RepoCache, owner LPPerson)
 		owner.Login,
 		"",
 		map[string]string{
-			keyLaunchpadLogin: owner.Login,
+			metaKeyLaunchpadLogin: owner.Login,
 		},
 	)
 }
@@ -65,7 +67,7 @@ func (li *launchpadImporter) ImportAll(ctx context.Context, repo *cache.RepoCach
 				return
 			default:
 				lpBugID := fmt.Sprintf("%d", lpBug.ID)
-				b, err := repo.ResolveBugCreateMetadata(keyLaunchpadID, lpBugID)
+				b, err := repo.ResolveBugCreateMetadata(metaKeyLaunchpadID, lpBugID)
 				if err != nil && err != bug.ErrBugNotExist {
 					out <- core.NewImportError(err, entity.Id(lpBugID))
 					return
@@ -86,7 +88,8 @@ func (li *launchpadImporter) ImportAll(ctx context.Context, repo *cache.RepoCach
 						lpBug.Description,
 						nil,
 						map[string]string{
-							keyLaunchpadID: lpBugID,
+							core.MetaKeyOrigin: target,
+							metaKeyLaunchpadID: lpBugID,
 						},
 					)
 					if err != nil {
@@ -108,7 +111,7 @@ func (li *launchpadImporter) ImportAll(ctx context.Context, repo *cache.RepoCach
 				// The Launchpad API returns the bug description as the first
 				// comment, so skip it.
 				for _, lpMessage := range lpBug.Messages[1:] {
-					_, err := b.ResolveOperationWithMetadata(keyLaunchpadID, lpMessage.ID)
+					_, err := b.ResolveOperationWithMetadata(metaKeyLaunchpadID, lpMessage.ID)
 					if err != nil && err != cache.ErrNoMatchingOp {
 						out <- core.NewImportError(err, entity.Id(lpMessage.ID))
 						return
@@ -136,7 +139,7 @@ func (li *launchpadImporter) ImportAll(ctx context.Context, repo *cache.RepoCach
 						lpMessage.Content,
 						nil,
 						map[string]string{
-							keyLaunchpadID: lpMessage.ID,
+							metaKeyLaunchpadID: lpMessage.ID,
 						})
 					if err != nil {
 						out <- core.NewImportError(err, op.Id())