From 102a7f88999102a795646d3136475e7ac1238dfe Mon Sep 17 00:00:00 2001
From: Chewing_Bever <roosensjef@gmail.com>
Date: Tue, 14 Jun 2022 22:25:40 +0200
Subject: [PATCH] refactor: renamed codebase to "targets"

---
 src/build/build.v                             |  6 +-
 src/build/shell.v                             |  6 +-
 src/build/shell_test.v                        |  6 +-
 src/client/logs.v                             |  6 +-
 src/client/targets.v                          | 36 +++----
 src/console/logs/logs.v                       | 22 ++---
 src/console/targets/targets.v                 |  6 +-
 src/cron/daemon/daemon.v                      |  8 +-
 src/db/db.v                                   |  8 +-
 src/db/git.v                                  | 99 -------------------
 src/db/logs.v                                 | 12 +--
 .../migrations/002-rename-to-targets/down.sql |  5 +
 .../migrations/002-rename-to-targets/up.sql   |  5 +
 src/db/targets.v                              | 99 +++++++++++++++++++
 src/models/logs.v                             |  6 +-
 src/models/models.v                           |  4 +-
 src/models/{git.v => targets.v}               | 18 ++--
 src/server/api_logs.v                         | 14 +--
 src/server/api_targets.v                      | 30 +++---
 19 files changed, 205 insertions(+), 191 deletions(-)
 delete mode 100644 src/db/git.v
 create mode 100644 src/db/migrations/002-rename-to-targets/down.sql
 create mode 100644 src/db/migrations/002-rename-to-targets/up.sql
 create mode 100644 src/db/targets.v
 rename src/models/{git.v => targets.v} (75%)

diff --git a/src/build/build.v b/src/build/build.v
index 2e86471..3c6b439 100644
--- a/src/build/build.v
+++ b/src/build/build.v
@@ -6,7 +6,7 @@ import time
 import os
 import strings
 import util
-import models { GitRepo }
+import models { Target }
 
 const (
 	container_build_dir = '/build'
@@ -91,9 +91,9 @@ pub:
 }
 
 // build_repo builds, packages & publishes a given Arch package based on the
-// provided GitRepo. The base image ID should be of an image previously created
+// provided target. The base image ID should be of an image previously created
 // by create_build_image. It returns the logs of the container.
-pub fn build_repo(address string, api_key string, base_image_id string, repo &GitRepo) ?BuildResult {
+pub fn build_repo(address string, api_key string, base_image_id string, repo &Target) ?BuildResult {
 	mut dd := docker.new_conn()?
 
 	defer {
diff --git a/src/build/shell.v b/src/build/shell.v
index a3121fe..c5944bf 100644
--- a/src/build/shell.v
+++ b/src/build/shell.v
@@ -1,6 +1,6 @@
 module build
 
-import models { GitRepo }
+import models { Target }
 
 // escape_shell_string escapes any characters that could be interpreted
 // incorrectly by a shell. The resulting value should be safe to use inside an
@@ -22,8 +22,8 @@ pub fn echo_commands(cmds []string) []string {
 	return out
 }
 
-// create_build_script generates a shell script that builds a given GitRepo.
-fn create_build_script(address string, repo &GitRepo, build_arch string) string {
+// create_build_script generates a shell script that builds a given Target.
+fn create_build_script(address string, repo &Target, build_arch string) string {
 	repo_url := '$address/$repo.repo'
 
 	commands := echo_commands([
diff --git a/src/build/shell_test.v b/src/build/shell_test.v
index 46ab350..8534054 100644
--- a/src/build/shell_test.v
+++ b/src/build/shell_test.v
@@ -1,15 +1,15 @@
 module build
 
-import models { GitRepo }
+import models { Target }
 
 fn test_create_build_script() {
-	repo := GitRepo{
+	target := Target{
 		id: 1
 		url: 'https://examplerepo.com'
 		branch: 'main'
 		repo: 'vieter'
 	}
-	build_script := create_build_script('https://example.com', repo, 'x86_64')
+	build_script := create_build_script('https://example.com', target, 'x86_64')
 	expected := $embed_file('build_script.sh')
 
 	assert build_script == expected.to_string().trim_space()
diff --git a/src/client/logs.v b/src/client/logs.v
index 2d78fc1..49ef679 100644
--- a/src/client/logs.v
+++ b/src/client/logs.v
@@ -13,10 +13,10 @@ pub fn (c &Client) get_build_logs(filter BuildLogFilter) ?Response<[]BuildLog> {
 	return data
 }
 
-// get_build_logs_for_repo returns all build logs for a given repo.
-pub fn (c &Client) get_build_logs_for_repo(repo_id int) ?Response<[]BuildLog> {
+// get_build_logs_for_target returns all build logs for a given target.
+pub fn (c &Client) get_build_logs_for_target(target_id int) ?Response<[]BuildLog> {
 	params := {
-		'repo': repo_id.str()
+		'repo': target_id.str()
 	}
 
 	data := c.send_request<[]BuildLog>(Method.get, '/api/v1/logs', params)?
diff --git a/src/client/targets.v b/src/client/targets.v
index 90ff1a2..86d8c2a 100644
--- a/src/client/targets.v
+++ b/src/client/targets.v
@@ -1,46 +1,46 @@
 module client
 
-import models { GitRepo, GitRepoFilter }
+import models { Target, TargetFilter }
 import net.http { Method }
 import response { Response }
 
-// get_targets returns a list of GitRepo's, given a filter object.
-pub fn (c &Client) get_targets(filter GitRepoFilter) ?[]GitRepo {
+// get_targets returns a list of targets, given a filter object.
+pub fn (c &Client) get_targets(filter TargetFilter) ?[]Target {
 	params := models.params_from(filter)
-	data := c.send_request<[]GitRepo>(Method.get, '/api/v1/targets', params)?
+	data := c.send_request<[]Target>(Method.get, '/api/v1/targets', params)?
 
 	return data.data
 }
 
-// get_all_targets retrieves *all* GitRepo's from the API using the default
+// get_all_targets retrieves *all* targs from the API using the default
 // limit.
-pub fn (c &Client) get_all_targets() ?[]GitRepo {
-	mut repos := []GitRepo{}
+pub fn (c &Client) get_all_targets() ?[]Target {
+	mut targets := []Target{}
 	mut offset := u64(0)
 
 	for {
-		sub_repos := c.get_targets(offset: offset)?
+		sub_targets := c.get_targets(offset: offset)?
 
-		if sub_repos.len == 0 {
+		if sub_targets.len == 0 {
 			break
 		}
 
-		repos << sub_repos
+		targets << sub_targets
 
-		offset += u64(sub_repos.len)
+		offset += u64(sub_targets.len)
 	}
 
-	return repos
+	return targets
 }
 
-// get_target returns the repo for a specific ID.
-pub fn (c &Client) get_target(id int) ?GitRepo {
-	data := c.send_request<GitRepo>(Method.get, '/api/v1/targets/$id', {})?
+// get_target returns the target for a specific id.
+pub fn (c &Client) get_target(id int) ?Target {
+	data := c.send_request<Target>(Method.get, '/api/v1/targets/$id', {})?
 
 	return data.data
 }
 
-// add_target adds a new repo to the server.
+// add_target adds a new target to the server.
 pub fn (c &Client) add_target(url string, branch string, repo string, arch []string) ?Response<string> {
 	mut params := {
 		'url':    url
@@ -57,14 +57,14 @@ pub fn (c &Client) add_target(url string, branch string, repo string, arch []str
 	return data
 }
 
-// remove_target removes the repo with the given ID from the server.
+// remove_target removes the target with the given id from the server.
 pub fn (c &Client) remove_target(id int) ?Response<string> {
 	data := c.send_request<string>(Method.delete, '/api/v1/targets/$id', {})?
 
 	return data
 }
 
-// patch_target sends a PATCH request to the given repo with the params as
+// patch_target sends a PATCH request to the given target with the params as
 // payload.
 pub fn (c &Client) patch_target(id int, params map[string]string) ?Response<string> {
 	data := c.send_request<string>(Method.patch, '/api/v1/targets/$id', params)?
diff --git a/src/console/logs/logs.v b/src/console/logs/logs.v
index f9dd363..5155ae8 100644
--- a/src/console/logs/logs.v
+++ b/src/console/logs/logs.v
@@ -12,7 +12,7 @@ struct Config {
 	api_key string [required]
 }
 
-// cmd returns the cli module that handles the build repos API.
+// cmd returns the cli module that handles the build logs API.
 pub fn cmd() cli.Command {
 	return cli.Command{
 		name: 'logs'
@@ -33,8 +33,8 @@ pub fn cmd() cli.Command {
 						flag: cli.FlagType.int
 					},
 					cli.Flag{
-						name: 'repo'
-						description: 'Only return logs for this repo id.'
+						name: 'target'
+						description: 'Only return logs for this target id.'
 						flag: cli.FlagType.int
 					},
 					cli.Flag{
@@ -79,9 +79,9 @@ pub fn cmd() cli.Command {
 						filter.offset = u64(offset)
 					}
 
-					repo_id := cmd.flags.get_int('repo')?
-					if repo_id != 0 {
-						filter.repo = repo_id
+					target_id := cmd.flags.get_int('target')?
+					if target_id != 0 {
+						filter.target = target_id
 					}
 
 					tz_offset := time.offset()
@@ -168,10 +168,10 @@ pub fn cmd() cli.Command {
 
 // print_log_list prints a list of logs.
 fn print_log_list(logs []BuildLog) ? {
-	data := logs.map([it.id.str(), it.repo_id.str(), it.start_time.local().str(),
+	data := logs.map([it.id.str(), it.target_id.str(), it.start_time.local().str(),
 		it.exit_code.str()])
 
-	println(console.pretty_table(['id', 'repo', 'start time', 'exit code'], data)?)
+	println(console.pretty_table(['id', 'target', 'start time', 'exit code'], data)?)
 }
 
 // list prints a list of all build logs.
@@ -182,10 +182,10 @@ fn list(conf Config, filter BuildLogFilter) ? {
 	print_log_list(logs)?
 }
 
-// list prints a list of all build logs for a given repo.
-fn list_for_repo(conf Config, repo_id int) ? {
+// list prints a list of all build logs for a given target.
+fn list_for_target(conf Config, target_id int) ? {
 	c := client.new(conf.address, conf.api_key)
-	logs := c.get_build_logs_for_repo(repo_id)?.data
+	logs := c.get_build_logs_for_target(target_id)?.data
 
 	print_log_list(logs)?
 }
diff --git a/src/console/targets/targets.v b/src/console/targets/targets.v
index 9917913..530184d 100644
--- a/src/console/targets/targets.v
+++ b/src/console/targets/targets.v
@@ -5,7 +5,7 @@ import vieter.vconf
 import cron.expression { parse_expression }
 import client
 import console
-import models { GitRepoFilter }
+import models { TargetFilter }
 
 struct Config {
 	address    string [required]
@@ -43,7 +43,7 @@ pub fn cmd() cli.Command {
 					config_file := cmd.flags.get_string('config-file')?
 					conf := vconf.load<Config>(prefix: 'VIETER_', default_path: config_file)?
 
-					mut filter := GitRepoFilter{}
+					mut filter := TargetFilter{}
 
 					limit := cmd.flags.get_int('limit')?
 					if limit != 0 {
@@ -168,7 +168,7 @@ pub fn cmd() cli.Command {
 // ID. If multiple or none are found, an error is raised.
 
 // list prints out a list of all repositories.
-fn list(conf Config, filter GitRepoFilter) ? {
+fn list(conf Config, filter TargetFilter) ? {
 	c := client.new(conf.address, conf.api_key)
 	repos := c.get_targets(filter)?
 	data := repos.map([it.id.str(), it.url, it.branch, it.repo])
diff --git a/src/cron/daemon/daemon.v b/src/cron/daemon/daemon.v
index 1f36e74..7b514aa 100644
--- a/src/cron/daemon/daemon.v
+++ b/src/cron/daemon/daemon.v
@@ -9,7 +9,7 @@ import build
 import docker
 import os
 import client
-import models { GitRepo }
+import models { Target }
 
 const (
 	// How many seconds to wait before retrying to update API if failed
@@ -20,7 +20,7 @@ const (
 
 struct ScheduledBuild {
 pub:
-	repo      GitRepo
+	repo      Target
 	timestamp time.Time
 }
 
@@ -38,7 +38,7 @@ mut:
 	api_update_frequency    int
 	image_rebuild_frequency int
 	// Repos currently loaded from API.
-	repos []GitRepo
+	repos []Target
 	// At what point to update the list of repositories.
 	api_update_timestamp  time.Time
 	image_build_timestamp time.Time
@@ -149,7 +149,7 @@ pub fn (mut d Daemon) run() {
 }
 
 // schedule_build adds the next occurence of the given repo build to the queue.
-fn (mut d Daemon) schedule_build(repo GitRepo) {
+fn (mut d Daemon) schedule_build(repo Target) {
 	ce := if repo.schedule != '' {
 		parse_expression(repo.schedule) or {
 			// TODO This shouldn't return an error if the expression is empty.
diff --git a/src/db/db.v b/src/db/db.v
index fac1458..64a57d2 100644
--- a/src/db/db.v
+++ b/src/db/db.v
@@ -13,8 +13,12 @@ struct MigrationVersion {
 }
 
 const (
-	migrations_up   = [$embed_file('migrations/001-initial/up.sql')]
-	migrations_down = [$embed_file('migrations/001-initial/down.sql')]
+	migrations_up   = [
+		$embed_file('migrations/001-initial/up.sql'),
+		$embed_file('migrations/002-rename-to-targets/up.sql'),
+	]
+	migrations_down = [$embed_file('migrations/001-initial/down.sql'),
+		$embed_file('migrations/002-rename-to-targets/down.sql')]
 )
 
 // init initializes a database & adds the correct tables.
diff --git a/src/db/git.v b/src/db/git.v
deleted file mode 100644
index 8cc493f..0000000
--- a/src/db/git.v
+++ /dev/null
@@ -1,99 +0,0 @@
-module db
-
-import models { GitRepo, GitRepoArch, GitRepoFilter }
-
-// get_git_repos returns all GitRepo's in the database.
-pub fn (db &VieterDb) get_git_repos(filter GitRepoFilter) []GitRepo {
-	// This seems to currently be blocked by a bug in the ORM, I'll have to ask
-	// around.
-	if filter.repo != '' {
-		res := sql db.conn {
-			select from GitRepo where repo == filter.repo order by id limit filter.limit offset filter.offset
-		}
-
-		return res
-	}
-
-	res := sql db.conn {
-		select from GitRepo order by id limit filter.limit offset filter.offset
-	}
-
-	return res
-}
-
-// get_git_repo tries to return a specific GitRepo.
-pub fn (db &VieterDb) get_git_repo(repo_id int) ?GitRepo {
-	res := sql db.conn {
-		select from GitRepo where id == repo_id
-	}
-
-	// If a select statement fails, it returns a zeroed object. By
-	// checking one of the required fields, we can see whether the query
-	// returned a result or not.
-	if res.id == 0 {
-		return none
-	}
-
-	return res
-}
-
-// add_git_repo inserts the given GitRepo into the database.
-pub fn (db &VieterDb) add_git_repo(repo GitRepo) {
-	sql db.conn {
-		insert repo into GitRepo
-	}
-}
-
-// delete_git_repo deletes the repo with the given ID from the database.
-pub fn (db &VieterDb) delete_git_repo(repo_id int) {
-	sql db.conn {
-		delete from GitRepo where id == repo_id
-		delete from GitRepoArch where repo_id == repo_id
-	}
-}
-
-// update_git_repo updates any non-array values for a given GitRepo.
-pub fn (db &VieterDb) update_git_repo(repo_id int, params map[string]string) {
-	mut values := []string{}
-
-	// TODO does this allow for SQL injection?
-	$for field in GitRepo.fields {
-		if field.name in params {
-			// Any fields that are array types require their own update method
-			$if field.typ is string {
-				values << "$field.name = '${params[field.name]}'"
-			}
-		}
-	}
-	values_str := values.join(', ')
-	// I think this is actual SQL & not the ORM language
-	query := 'update GitRepo set $values_str where id == $repo_id'
-
-	db.conn.exec_none(query)
-}
-
-// update_git_repo_archs updates a given GitRepo's arch value.
-pub fn (db &VieterDb) update_git_repo_archs(repo_id int, archs []GitRepoArch) {
-	archs_with_id := archs.map(GitRepoArch{
-		...it
-		repo_id: repo_id
-	})
-
-	sql db.conn {
-		delete from GitRepoArch where repo_id == repo_id
-	}
-
-	for arch in archs_with_id {
-		sql db.conn {
-			insert arch into GitRepoArch
-		}
-	}
-}
-
-// git_repo_exists is a utility function that checks whether a repo with the
-// given id exists.
-pub fn (db &VieterDb) git_repo_exists(repo_id int) bool {
-	db.get_git_repo(repo_id) or { return false }
-
-	return true
-}
diff --git a/src/db/logs.v b/src/db/logs.v
index cac08e7..af5f53c 100644
--- a/src/db/logs.v
+++ b/src/db/logs.v
@@ -7,8 +7,8 @@ import time
 pub fn (db &VieterDb) get_build_logs(filter BuildLogFilter) []BuildLog {
 	mut where_parts := []string{}
 
-	if filter.repo != 0 {
-		where_parts << 'repo_id == $filter.repo'
+	if filter.target != 0 {
+		where_parts << 'target_id == $filter.target'
 	}
 
 	if filter.before != time.Time{} {
@@ -55,11 +55,11 @@ pub fn (db &VieterDb) get_build_logs(filter BuildLogFilter) []BuildLog {
 	return res
 }
 
-// get_build_logs_for_repo returns all BuildLog's in the database for a given
-// repo.
-pub fn (db &VieterDb) get_build_logs_for_repo(repo_id int) []BuildLog {
+// get_build_logs_for_target returns all BuildLog's in the database for a given
+// target.
+pub fn (db &VieterDb) get_build_logs_for_target(target_id int) []BuildLog {
 	res := sql db.conn {
-		select from BuildLog where repo_id == repo_id order by id
+		select from BuildLog where target_id == target_id order by id
 	}
 
 	return res
diff --git a/src/db/migrations/002-rename-to-targets/down.sql b/src/db/migrations/002-rename-to-targets/down.sql
new file mode 100644
index 0000000..861bfa9
--- /dev/null
+++ b/src/db/migrations/002-rename-to-targets/down.sql
@@ -0,0 +1,5 @@
+ALTER TABLE Target RENAME TO GitRepo;
+ALTER TABLE TargetArch RENAME TO GitRepoArch;
+
+ALTER TABLE GitRepoArch RENAME COLUMN target_id TO repo_id;
+ALTER TABLE BuildLog RENAME COLUMN target_id TO repo_id;
diff --git a/src/db/migrations/002-rename-to-targets/up.sql b/src/db/migrations/002-rename-to-targets/up.sql
new file mode 100644
index 0000000..081e3ee
--- /dev/null
+++ b/src/db/migrations/002-rename-to-targets/up.sql
@@ -0,0 +1,5 @@
+ALTER TABLE GitRepo RENAME TO Target;
+ALTER TABLE GitRepoArch RENAME TO TargetArch;
+
+ALTER TABLE TargetArch RENAME COLUMN repo_id TO target_id;
+ALTER TABLE BuildLog RENAME COLUMN repo_id TO target_id;
diff --git a/src/db/targets.v b/src/db/targets.v
new file mode 100644
index 0000000..9102033
--- /dev/null
+++ b/src/db/targets.v
@@ -0,0 +1,99 @@
+module db
+
+import models { Target, TargetArch, TargetFilter }
+
+// get_targets returns all targets in the database.
+pub fn (db &VieterDb) get_targets(filter TargetFilter) []Target {
+	// This seems to currently be blocked by a bug in the ORM, I'll have to ask
+	// around.
+	if filter.repo != '' {
+		res := sql db.conn {
+			select from Target where repo == filter.repo order by id limit filter.limit offset filter.offset
+		}
+
+		return res
+	}
+
+	res := sql db.conn {
+		select from Target order by id limit filter.limit offset filter.offset
+	}
+
+	return res
+}
+
+// get_target tries to return a specific target.
+pub fn (db &VieterDb) get_target(target_id int) ?Target {
+	res := sql db.conn {
+		select from Target where id == target_id
+	}
+
+	// If a select statement fails, it returns a zeroed object. By
+	// checking one of the required fields, we can see whether the query
+	// returned a result or not.
+	if res.id == 0 {
+		return none
+	}
+
+	return res
+}
+
+// add_target inserts the given target into the database.
+pub fn (db &VieterDb) add_target(repo Target) {
+	sql db.conn {
+		insert repo into Target
+	}
+}
+
+// delete_target deletes the target with the given id from the database.
+pub fn (db &VieterDb) delete_target(target_id int) {
+	sql db.conn {
+		delete from Target where id == target_id
+		delete from TargetArch where target_id == target_id
+	}
+}
+
+// update_target updates any non-array values for a given target.
+pub fn (db &VieterDb) update_target(target_id int, params map[string]string) {
+	mut values := []string{}
+
+	// TODO does this allow for SQL injection?
+	$for field in Target.fields {
+		if field.name in params {
+			// Any fields that are array types require their own update method
+			$if field.typ is string {
+				values << "$field.name = '${params[field.name]}'"
+			}
+		}
+	}
+	values_str := values.join(', ')
+	// I think this is actual SQL & not the ORM language
+	query := 'update Target set $values_str where id == $target_id'
+
+	db.conn.exec_none(query)
+}
+
+// update_target_archs updates a given target's arch value.
+pub fn (db &VieterDb) update_target_archs(target_id int, archs []TargetArch) {
+	archs_with_id := archs.map(TargetArch{
+		...it
+		target_id: target_id
+	})
+
+	sql db.conn {
+		delete from TargetArch where target_id == target_id
+	}
+
+	for arch in archs_with_id {
+		sql db.conn {
+			insert arch into TargetArch
+		}
+	}
+}
+
+// target_exists is a utility function that checks whether a target with the
+// given id exists.
+pub fn (db &VieterDb) target_exists(target_id int) bool {
+	db.get_target(target_id) or { return false }
+
+	return true
+}
diff --git a/src/models/logs.v b/src/models/logs.v
index 7f5a5fe..12907d8 100644
--- a/src/models/logs.v
+++ b/src/models/logs.v
@@ -5,7 +5,7 @@ import time
 pub struct BuildLog {
 pub mut:
 	id         int       [primary; sql: serial]
-	repo_id    int       [nonull]
+	target_id  int       [nonull]
 	start_time time.Time [nonull]
 	end_time   time.Time [nonull]
 	arch       string    [nonull]
@@ -16,7 +16,7 @@ pub mut:
 pub fn (bl &BuildLog) str() string {
 	mut parts := [
 		'id: $bl.id',
-		'repo id: $bl.repo_id',
+		'target id: $bl.target_id',
 		'start time: $bl.start_time.local()',
 		'end time: $bl.end_time.local()',
 		'duration: ${bl.end_time - bl.start_time}',
@@ -33,7 +33,7 @@ pub struct BuildLogFilter {
 pub mut:
 	limit      u64 = 25
 	offset     u64
-	repo       int
+	target     int
 	before     time.Time
 	after      time.Time
 	arch       string
diff --git a/src/models/models.v b/src/models/models.v
index 3a127bc..b6103d3 100644
--- a/src/models/models.v
+++ b/src/models/models.v
@@ -23,8 +23,8 @@ pub fn patch_from_params<T>(mut o T, params map[string]string) ? {
 				o.$(field.name) = params[field.name].int()
 			} $else $if field.typ is u64 {
 				o.$(field.name) = params[field.name].u64()
-			} $else $if field.typ is []GitRepoArch {
-				o.$(field.name) = params[field.name].split(',').map(GitRepoArch{ value: it })
+			} $else $if field.typ is []TargetArch {
+				o.$(field.name) = params[field.name].split(',').map(TargetArch{ value: it })
 			} $else $if field.typ is time.Time {
 				o.$(field.name) = time.unix(params[field.name].int())
 			} $else $if field.typ is []string {
diff --git a/src/models/git.v b/src/models/targets.v
similarity index 75%
rename from src/models/git.v
rename to src/models/targets.v
index 5dcc13a..537bbc4 100644
--- a/src/models/git.v
+++ b/src/models/targets.v
@@ -1,18 +1,18 @@
 module models
 
-pub struct GitRepoArch {
+pub struct TargetArch {
 pub:
-	id      int    [primary; sql: serial]
-	repo_id int    [nonull]
-	value   string [nonull]
+	id        int    [primary; sql: serial]
+	target_id int    [nonull]
+	value     string [nonull]
 }
 
 // str returns a string representation.
-pub fn (gra &GitRepoArch) str() string {
+pub fn (gra &TargetArch) str() string {
 	return gra.value
 }
 
-pub struct GitRepo {
+pub struct Target {
 pub mut:
 	id int [primary; sql: serial]
 	// URL of the Git repository
@@ -25,11 +25,11 @@ pub mut:
 	schedule string
 	// On which architectures the package is allowed to be built. In reality,
 	// this controls which builders will periodically build the image.
-	arch []GitRepoArch [fkey: 'repo_id']
+	arch []TargetArch [fkey: 'target_id']
 }
 
 // str returns a string representation.
-pub fn (gr &GitRepo) str() string {
+pub fn (gr &Target) str() string {
 	mut parts := [
 		'id: $gr.id',
 		'url: $gr.url',
@@ -44,7 +44,7 @@ pub fn (gr &GitRepo) str() string {
 }
 
 [params]
-pub struct GitRepoFilter {
+pub struct TargetFilter {
 pub mut:
 	limit  u64 = 25
 	offset u64
diff --git a/src/server/api_logs.v b/src/server/api_logs.v
index 748c3a6..fa3338e 100644
--- a/src/server/api_logs.v
+++ b/src/server/api_logs.v
@@ -10,7 +10,7 @@ import os
 import util
 import models { BuildLog, BuildLogFilter }
 
-// v1_get_logs returns all build logs in the database. A 'repo' query param can
+// v1_get_logs returns all build logs in the database. A 'target' query param can
 // optionally be added to limit the list of build logs to that repository.
 ['/api/v1/logs'; get]
 fn (mut app App) v1_get_logs() web.Result {
@@ -47,7 +47,7 @@ fn (mut app App) v1_get_log_content(id int) web.Result {
 
 	log := app.db.get_build_log(id) or { return app.not_found() }
 	file_name := log.start_time.custom_format('YYYY-MM-DD_HH-mm-ss')
-	full_path := os.join_path(app.conf.data_dir, logs_dir_name, log.repo_id.str(), log.arch,
+	full_path := os.join_path(app.conf.data_dir, logs_dir_name, log.target_id.str(), log.arch,
 		file_name)
 
 	return app.file(full_path)
@@ -96,15 +96,15 @@ fn (mut app App) v1_post_log() web.Result {
 
 	arch := app.query['arch']
 
-	repo_id := app.query['repo'].int()
+	target_id := app.query['target'].int()
 
-	if !app.db.git_repo_exists(repo_id) {
-		return app.json(http.Status.bad_request, new_response('Unknown Git repo.'))
+	if !app.db.target_exists(target_id) {
+		return app.json(http.Status.bad_request, new_response('Unknown target.'))
 	}
 
 	// Store log in db
 	log := BuildLog{
-		repo_id: repo_id
+		target_id: target_id
 		start_time: start_time
 		end_time: end_time
 		arch: arch
@@ -113,7 +113,7 @@ fn (mut app App) v1_post_log() web.Result {
 
 	app.db.add_build_log(log)
 
-	repo_logs_dir := os.join_path(app.conf.data_dir, logs_dir_name, repo_id.str(), arch)
+	repo_logs_dir := os.join_path(app.conf.data_dir, logs_dir_name, target_id.str(), arch)
 
 	// Create the logs directory of it doesn't exist
 	if !os.exists(repo_logs_dir) {
diff --git a/src/server/api_targets.v b/src/server/api_targets.v
index 67117b9..f807fe9 100644
--- a/src/server/api_targets.v
+++ b/src/server/api_targets.v
@@ -4,36 +4,36 @@ import web
 import net.http
 import response { new_data_response, new_response }
 import db
-import models { GitRepo, GitRepoArch, GitRepoFilter }
+import models { Target, TargetArch, TargetFilter }
 
-// v1_get_targets returns the current list of repos.
+// v1_get_targets returns the current list of targets.
 ['/api/v1/targets'; get]
 fn (mut app App) v1_get_targets() web.Result {
 	if !app.is_authorized() {
 		return app.json(http.Status.unauthorized, new_response('Unauthorized.'))
 	}
 
-	filter := models.from_params<GitRepoFilter>(app.query) or {
+	filter := models.from_params<TargetFilter>(app.query) or {
 		return app.json(http.Status.bad_request, new_response('Invalid query parameters.'))
 	}
-	repos := app.db.get_git_repos(filter)
+	repos := app.db.get_targets(filter)
 
 	return app.json(http.Status.ok, new_data_response(repos))
 }
 
-// v1_get_single_target returns the information for a single repo.
+// v1_get_single_target returns the information for a single target.
 ['/api/v1/targets/:id'; get]
 fn (mut app App) v1_get_single_target(id int) web.Result {
 	if !app.is_authorized() {
 		return app.json(http.Status.unauthorized, new_response('Unauthorized.'))
 	}
 
-	repo := app.db.get_git_repo(id) or { return app.not_found() }
+	repo := app.db.get_target(id) or { return app.not_found() }
 
 	return app.json(http.Status.ok, new_data_response(repo))
 }
 
-// v1_post_target creates a new repo from the provided query string.
+// v1_post_target creates a new target from the provided query string.
 ['/api/v1/targets'; post]
 fn (mut app App) v1_post_target() web.Result {
 	if !app.is_authorized() {
@@ -48,40 +48,40 @@ fn (mut app App) v1_post_target() web.Result {
 		params['arch'] = app.conf.default_arch
 	}
 
-	new_repo := models.from_params<GitRepo>(params) or {
+	new_repo := models.from_params<Target>(params) or {
 		return app.json(http.Status.bad_request, new_response(err.msg()))
 	}
 
-	app.db.add_git_repo(new_repo)
+	app.db.add_target(new_repo)
 
 	return app.json(http.Status.ok, new_response('Repo added successfully.'))
 }
 
-// v1_delete_target removes a given repo from the server's list.
+// v1_delete_target removes a given target from the server's list.
 ['/api/v1/targets/:id'; delete]
 fn (mut app App) v1_delete_target(id int) web.Result {
 	if !app.is_authorized() {
 		return app.json(http.Status.unauthorized, new_response('Unauthorized.'))
 	}
 
-	app.db.delete_git_repo(id)
+	app.db.delete_target(id)
 
 	return app.json(http.Status.ok, new_response('Repo removed successfully.'))
 }
 
-// v1_patch_target updates a repo's data with the given query params.
+// v1_patch_target updates a target's data with the given query params.
 ['/api/v1/targets/:id'; patch]
 fn (mut app App) v1_patch_target(id int) web.Result {
 	if !app.is_authorized() {
 		return app.json(http.Status.unauthorized, new_response('Unauthorized.'))
 	}
 
-	app.db.update_git_repo(id, app.query)
+	app.db.update_target(id, app.query)
 
 	if 'arch' in app.query {
-		arch_objs := app.query['arch'].split(',').map(GitRepoArch{ value: it })
+		arch_objs := app.query['arch'].split(',').map(TargetArch{ value: it })
 
-		app.db.update_git_repo_archs(id, arch_objs)
+		app.db.update_target_archs(id, arch_objs)
 	}
 
 	return app.json(http.Status.ok, new_response('Repo updated successfully.'))