draft: begin implementing integration / third party repository service

ee/tabby-db/migrations/0029_merged-provider-tables.up.sql

@@ -11,6 +11,7 @@ CREATE TABLE integration_access_tokens(
 CREATE TABLE provided_repositories(
  id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
  integration_access_token_id INTEGER NOT NULL,
+ kind TEXT NOT NULL,
  vendor_id TEXT NOT NULL,
  name TEXT NOT NULL,
  git_url TEXT NOT NULL,

ee/tabby-db/src/lib.rs

@@ -15,6 +15,7 @@ pub use gitlab_repository_provider::{GitlabProvidedRepositoryDAO, GitlabReposito
 pub use invitations::InvitationDAO;
 pub use job_runs::JobRunDAO;
 pub use oauth_credential::OAuthCredentialDAO;
+pub use provided_repositories::ProvidedRepositoryDAO;
 pub use repositories::RepositoryDAO;
 pub use server_setting::ServerSettingDAO;
 use sqlx::{

ee/tabby-db/src/provided_repositories.rs

@@ -7,6 +7,7 @@ use crate::{DateTimeUtc, DbConn};
 #[derive(FromRow)]
 pub struct ProvidedRepositoryDAO {
  pub id: i64,
+ pub kind: String,
  pub vendor_id: String,
  pub integration_access_token_id: i64,
  pub name: String,
@@ -51,7 +52,7 @@ impl DbConn {
  pub async fn get_provided_repository(&self, id: i64) -> Result<ProvidedRepositoryDAO> {
  let repo = query_as!(
  ProvidedRepositoryDAO,
- "SELECT id, vendor_id, name, git_url, active, integration_access_token_id, created_at, updated_at FROM provided_repositories WHERE id = ?",
+ "SELECT id, vendor_id, kind, name, git_url, active, integration_access_token_id, created_at, updated_at FROM provided_repositories WHERE id = ?",
  id
  )
  .fetch_one(&self.pool)
@@ -95,6 +96,7 @@ impl DbConn {
  "vendor_id",
  "name",
  "git_url",
+ "kind",
  "active",
  "integration_access_token_id",
  "created_at" as "created_at: DateTimeUtc",

ee/tabby-schema/src/dao.rs

@@ -4,20 +4,25 @@ use lazy_static::lazy_static;
 use tabby_db::{
  EmailSettingDAO, GithubProvidedRepositoryDAO, GithubRepositoryProviderDAO,
  GitlabProvidedRepositoryDAO, GitlabRepositoryProviderDAO, InvitationDAO, JobRunDAO,
- OAuthCredentialDAO, RepositoryDAO, ServerSettingDAO, UserDAO, UserEventDAO,
+ OAuthCredentialDAO, ProvidedRepositoryDAO, RepositoryDAO, ServerSettingDAO, UserDAO,
+ UserEventDAO,
 };
 
-use crate::schema::{
- auth::{self, OAuthCredential, OAuthProvider},
- email::{AuthMethod, EmailSetting, Encryption},
- job,
- repository::{
- GitRepository, GithubProvidedRepository, GithubRepositoryProvider,
- GitlabProvidedRepository, GitlabRepositoryProvider, RepositoryProviderStatus,
+use crate::{
+ integration::IntegrationKind,
+ repository::ProvidedRepository,
+ schema::{
+ auth::{self, OAuthCredential, OAuthProvider},
+ email::{AuthMethod, EmailSetting, Encryption},
+ job,
+ repository::{
+ GitRepository, GithubProvidedRepository, GithubRepositoryProvider,
+ GitlabProvidedRepository, GitlabRepositoryProvider, RepositoryProviderStatus,
+ },
+ setting::{NetworkSetting, SecuritySetting},
+ user_event::{EventKind, UserEvent},
+ CoreError,
  },
- setting::{NetworkSetting, SecuritySetting},
- user_event::{EventKind, UserEvent},
- CoreError,
 };
 
 impl From<InvitationDAO> for auth::Invitation {
@@ -124,6 +129,22 @@ impl From<ServerSettingDAO> for NetworkSetting {
  }
 }
 
+impl TryFrom<ProvidedRepositoryDAO> for ProvidedRepository {
+ type Error = anyhow::Error;
+ fn try_from(value: ProvidedRepositoryDAO) -> Result<Self, Self::Error> {
+ Ok(Self {
+ integration_id: value.integration_access_token_id.as_id(),
+ active: value.active,
+ kind: IntegrationKind::from_enum_str(&value.kind)?,
+ display_name: value.name,
+ git_url: value.git_url,
+ vendor_id: value.vendor_id,
+ created_at: *value.created_at,
+ updated_at: *value.updated_at,
+ })
+ }
+}
+
 impl From<GithubRepositoryProviderDAO> for GithubRepositoryProvider {
  fn from(value: GithubRepositoryProviderDAO) -> Self {
  Self {
@@ -254,6 +275,23 @@ impl DbEnum for EventKind {
  }
 }
 
+impl DbEnum for IntegrationKind {
+ fn as_enum_str(&self) -> &'static str {
+ match self {
+ IntegrationKind::Github => "github",
+ IntegrationKind::Gitlab => "gitlab",
+ }
+ }
+
+ fn from_enum_str(s: &str) -> anyhow::Result<Self> {
+ match s {
+ "github" => Ok(IntegrationKind::Github),
+ "gitlab" => Ok(IntegrationKind::Gitlab),
+ _ => bail!("{s} is not a valid value for ProviderKind"),
+ }
+ }
+}
+
 impl DbEnum for Encryption {
  fn as_enum_str(&self) -> &'static str {
  match self {

ee/tabby-schema/src/schema/integration.rs

@@ -0,0 +1,52 @@
+use async_trait::async_trait;
+use chrono::{DateTime, Utc};
+use juniper::ID;
+use strum::EnumIter;
+
+use crate::Result;
+
+#[derive(Clone, EnumIter)]
+pub enum IntegrationKind {
+ Github,
+ Gitlab,
+}
+
+pub enum IntegrationStatus {
+ Ready,
+ Pending,
+ Failed,
+}
+
+pub struct IntegrationAccessToken {
+ pub id: ID,
+ pub kind: IntegrationKind,
+ pub display_name: String,
+ pub access_token: String,
+ pub created_at: DateTime<Utc>,
+ pub updated_at: DateTime<Utc>,
+ pub status: IntegrationStatus,
+}
+
+#[async_trait]
+pub trait IntegrationService: Send + Sync {
+ async fn create_integration(
+ &self,
+ kind: IntegrationKind,
+ display_name: String,
+ access_token: String,
+ ) -> Result<ID>;
+
+ async fn delete_integration(&self, id: ID) -> Result<()>;
+ async fn update_integration(&self, id: ID, display_name: String, access_token: Option<String>);
+ async fn list_integrations(
+ &self,
+ ids: Option<Vec<ID>>,
+ kind: Option<IntegrationKind>,
+ after: Option<String>,
+ before: Option<String>,
+ first: Option<usize>,
+ last: Option<usize>,
+ ) -> Result<Vec<IntegrationAccessToken>>;
+
+ async fn sync_resources(&self, id: ID) -> Result<()>;
+}

ee/tabby-schema/src/schema/mod.rs

@@ -2,6 +2,7 @@ pub mod analytic;
 pub mod auth;
 pub mod constants;
 pub mod email;
+pub mod integration;
 pub mod job;
 pub mod license;
 pub mod repository;

ee/tabby-schema/src/schema/repository/mod.rs

@@ -10,6 +10,9 @@ pub use github::{GithubProvidedRepository, GithubRepositoryProvider, GithubRepos
 mod gitlab;
 use std::{path::PathBuf, sync::Arc};
 
+mod third_party;
+pub use third_party::{ProvidedRepository, ThirdPartyRepositoryService};
+
 use async_trait::async_trait;
 pub use gitlab::{GitlabProvidedRepository, GitlabRepositoryProvider, GitlabRepositoryService};
 use juniper::{GraphQLEnum, GraphQLObject, ID};

ee/tabby-schema/src/schema/repository/third_party.rs

@@ -0,0 +1,32 @@
+use crate::{integration::IntegrationKind, schema::Result};
+use async_trait::async_trait;
+use chrono::{DateTime, Utc};
+use juniper::ID;
+
+pub struct ProvidedRepository {
+ pub integration_id: ID,
+ pub active: bool,
+ pub kind: IntegrationKind,
+ pub display_name: String,
+ pub git_url: String,
+ pub vendor_id: String,
+ pub created_at: DateTime<Utc>,
+ pub updated_at: DateTime<Utc>,
+}
+
+#[async_trait]
+pub trait ThirdPartyRepositoryService: Send + Sync {
+ async fn list_repositories(
+ &self,
+ integration_ids: Option<Vec<ID>>,
+ kind: Option<IntegrationKind>,
+ active: Option<bool>,
+ after: Option<String>,
+ before: Option<String>,
+ first: Option<usize>,
+ last: Option<usize>,
+ ) -> Result<Vec<ProvidedRepository>>;
+
+ async fn update_repository_active(&self, id: ID, active: bool) -> Result<()>;
+ async fn list_active_git_urls(&self) -> Result<Vec<String>>;
+}

ee/tabby-webserver/Cargo.toml

@@ -51,6 +51,7 @@ gitlab = "0.1610.0"
 apalis = { git = "https://github.com/wsxiaoys/apalis", rev = "91526e8", features = ["sqlite", "cron" ] }
 uuid.workspace = true
 hyper-util = { version = "0.1.3", features = ["client-legacy"] }
+strum.workspace = true
 
 [dev-dependencies]
 assert_matches = "1.5.0"

ee/tabby-webserver/src/service/repository/mod.rs

@@ -1,6 +1,7 @@
 mod git;
 mod github;
 mod gitlab;
+mod third_party;
 
 use std::sync::Arc;
 

ee/tabby-webserver/src/service/repository/third_party.rs

@@ -0,0 +1,78 @@
+use juniper::ID;
+use std::marker::PhantomData;
+use strum::IntoEnumIterator;
+use tabby_schema::{
+ integration::IntegrationKind, repository::ProvidedRepository, AsRowid, DbEnum, Result,
+};
+use url::Url;
+
+use async_trait::async_trait;
+use tabby_db::DbConn;
+use tabby_schema::repository::{RepositoryProvider, ThirdPartyRepositoryService};
+
+use crate::service::graphql_pagination_to_filter;
+
+struct ThirdPartyRepositoryServiceImpl {
+ db: DbConn,
+}
+
+#[async_trait]
+impl ThirdPartyRepositoryService for ThirdPartyRepositoryServiceImpl {
+ async fn list_repositories(
+ &self,
+ integration_ids: Option<Vec<ID>>,
+ kind: Option<IntegrationKind>,
+ active: Option<bool>,
+ after: Option<String>,
+ before: Option<String>,
+ first: Option<usize>,
+ last: Option<usize>,
+ ) -> Result<Vec<ProvidedRepository>> {
+ let (limit, skip_id, backwards) = graphql_pagination_to_filter(after, before, first, last)?;
+
+ let integration_ids = integration_ids
+ .into_iter()
+ .flatten()
+ .map(|id| id.as_rowid())
+ .collect::<Result<Vec<_>, _>>()?;
+
+ let kind = kind.map(|kind| kind.as_enum_str().to_string());
+
+ Ok(self
+ .db
+ .list_provided_repositories(integration_ids, kind, active, limit, skip_id, backwards)
+ .await?
+ .into_iter()
+ .map(ProvidedRepository::try_from)
+ .collect::<Result<_, _>>()?)
+ }
+
+ async fn update_repository_active(&self, id: ID, active: bool) -> Result<()> {
+ self.db
+ .update_provided_repository_active(id.as_rowid()?, active)
+ .await?;
+ Ok(())
+ }
+
+ async fn list_active_git_urls(&self) -> Result<Vec<String>> {
+ let mut urls = vec![];
+ }
+}
+
+fn format_authenticated_url(
+ kind: &IntegrationKind,
+ git_url: &str,
+ access_token: &str,
+) -> Result<String> {
+ let mut url = Url::parse(git_url).map_err(anyhow::Error::from)?;
+ match kind {
+ IntegrationKind::Github => {
+ let _ = url.set_username(access_token);
+ }
+ IntegrationKind::Gitlab => {
+ let _ = url.set_username("oauth2");
+ let _ = url.set_password(Some(access_token));
+ }
+ }
+ Ok(url.to_string())
+}