Dummy Pr 3200

Cargo.toml

@@ -59,6 +59,7 @@ tailcall-http-cache = { path = "tailcall-http-cache", optional = true }
 tailcall-version = { path = "./tailcall-version", optional = true }
 genai = { git = "https://github.com/laststylebender14/rust-genai.git", rev = "63a542ce20132503c520f4e07108e0d768f243c3", optional = true }
 ctrlc = { version = "3.4.5", optional = true }
+tailcall-enterprise = { path = "./tailcall-enterprise", optional = true }
 
 # dependencies safe for wasm:
 
@@ -237,6 +238,7 @@ cli = [
     "dep:tailcall-version",
     "dep:genai",
     "dep:ctrlc",
+    "dep:tailcall-enterprise",
 ]
 
 # Feature flag to enable all default features.
@@ -262,7 +264,8 @@ members = [
     "tailcall-wasm",
     "tailcall-hasher",
     "tailcall-http-cache",
-    "tailcall-version",
+    "tailcall-version", 
+    "tailcall-enterprise",
 ]
 
 # Boost execution_spec snapshot diffing performance

src/cli/tc/start.rs

@@ -1,4 +1,6 @@
 use anyhow::Result;
+use tailcall_enterprise::Enterprise;
+use tracing::info;
 
 use super::helpers::log_endpoint_set;
 use crate::cli::fmt::Fmt;
@@ -12,6 +14,16 @@
     let config_module = config_reader.read_all(&file_paths).await?;
     log_endpoint_set(&config_module.extensions().endpoint_set);
     Fmt::log_n_plus_one(false, config_module.config());
+
+    // config module understand the configuration and the features enabled in the
+    // configuration.
+    if config_module.is_enterprise_features_enabled() {
+        let enterprise = Enterprise::try_new().await?;
+        if enterprise.is_validated() {
+            info!("TAILCALL_TOKEN validated successfully. Enabling all enterprise features")
+        }
+    }
+
     let server = Server::new(config_module);
     server.fork_start().await?;
     Ok(())

src/core/config/config_module.rs

@@ -6,6 +6,7 @@
 use rustls_pki_types::{CertificateDer, PrivateKeyDer};
 use tailcall_valid::{Valid, Validator};
 
+use super::LinkType;
 use crate::core::config::Config;
 use crate::core::macros::MergeRight;
 use crate::core::merge_right::MergeRight;
@@ -53,6 +54,17 @@
         ConfigModule { cache: Cache::from(config), extensions }
     }
 
+    /// Identifies if an enterprise feature is being used
+    pub fn is_enterprise_features_enabled(&self) -> bool {
+        let js_capability_enabled = self
+            .config()
+            .links
+            .iter()
+            .any(|link| matches!(link.type_of, LinkType::Script));
+        let telemetry_capability_enabled = self.config().telemetry.is_enabled();
+        js_capability_enabled || telemetry_capability_enabled
+    }
+
     pub fn set_extensions(mut self, extensions: Extensions) -> Self {
         self.extensions = extensions;
         self

src/core/config/directives/telemetry.rs

@@ -97,6 +97,10 @@
 }
 
 impl Telemetry {
+    pub fn is_enabled(&self) -> bool {
+        self.export.is_some()
+    }
+
     pub fn merge_right(mut self, other: Self) -> Self {
         self.export = match (&self.export, other.export) {
             (None, None) => None,

tailcall-enterprise/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "tailcall-enterprise"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+tokio = { workspace = true }
+reqwest = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+thiserror = { workspace = true }
+postgrest = "1.6.0"
+keygen-rs = "0.3.1"

tailcall-enterprise/src/enterprise.rs

@@ -0,0 +1,123 @@
+#![allow(dead_code)]
+use std::env;
+
+use keygen_rs::config::KeygenConfig;
+use keygen_rs::errors::Error;
+use postgrest::Postgrest;
+use serde::Deserialize;
+use thiserror::Error;
+
+const TOKEN_NAME: &str = "TAILCALL_TOKEN";
+
+// Supabase configurations
+const TABLE_NAME: &str = "---Add-Table-Name-Here---";
+const ANON_KEY: &str = "---Add-Anonymous-Key-Here---";
+const API_URL: &str = "---Add-Api-Url-Here---";
+
+#[derive(Error, Debug)]
+pub enum EnterpriseError {
+    #[error("TAILCALL_TOKEN is not provided. Please connect via https://tailcall.run/contact/ if you haven't already got a token.")]
+    TokenNotProvided,
+    #[error("Failed to fetch public key: {0}")]
+    PublicKeyFetchError(String),
+    #[error("Failed to parse public key: {0}")]
+    PublicKeyParsingError(String),
+    #[error(transparent)]
+    KeygenError(#[from] Box<Error>),
+    #[error(transparent)]
+    DatabaseClientError(#[from] reqwest::Error),
+}
+
+#[derive(Debug)]
+pub struct Enterprise {
+    license_key: Option<String>,
+    config: Option<KeygenConfig>,
+}
+
+#[derive(Deserialize, Debug)]
+struct KeygenData {
+    public_key: String,
+    account: String,
+    product: String,
+    api_url: String,
+    api_version: String,
+    api_prefix: String,
+}
+
+impl From<KeygenData> for KeygenConfig {
+    fn from(data: KeygenData) -> Self {
+        KeygenConfig {
+            public_key: Some(data.public_key),
+            account: data.account,
+            product: data.product,
+            api_url: data.api_url,
+            api_version: data.api_version,
+            api_prefix: data.api_prefix,
+            ..Default::default()
+        }
+    }
+}
+
+impl Enterprise {
+    pub fn is_validated(&self) -> bool {
+        self.config.is_some() && self.license_key.is_some()
+    }
+
+    pub async fn try_new() -> Result<Self, EnterpriseError> {
+        match env::var(TOKEN_NAME) {
+            Ok(signed_key) => {
+                let keygen_data = Self::fetch_public_key().await?;
+                let mut config: KeygenConfig = keygen_data.into();
+                config.license_key = Some(signed_key.clone());
+                keygen_rs::config::set_config(config);
+                let _signed_key_result =
+                    keygen_rs::verify(keygen_rs::license::SchemeCode::Ed25519Sign, &signed_key)
+                        .map_err(|e| match e {
+                            Error::LicenseKeyMissing => EnterpriseError::TokenNotProvided,
+                            _ => EnterpriseError::KeygenError(Box::new(e)),
+                        })?;
+                Ok(Self {
+                    license_key: Some(signed_key),
+                    config: Some(keygen_rs::config::get_config()),
+                })
+            }
+            Err(_) => Err(EnterpriseError::TokenNotProvided),
+        }
+    }
+
+    async fn fetch_public_key() -> Result<KeygenData, EnterpriseError> {
+        let client = Postgrest::new(API_URL).insert_header("apiKey", ANON_KEY);
+        // pick the latest key from the database.
+        let result = client
+            .from(TABLE_NAME)
+            .select("*")
+            .order("id.desc")
+            .limit(1)
+            .single()
+            .execute()
+            .await?;
+        let body = result.json::<KeygenData>().await?;
+        Ok(body)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::env;
+
+    use super::*;
+
+    #[tokio::test]
+    async fn test_no_token_provided() {
+        env::remove_var(TOKEN_NAME);
+        let result = Enterprise::try_new().await;
+        assert!(result.is_err());
+    }
+
+    #[tokio::test]
+    async fn test_invalid_token() {
+        env::set_var(TOKEN_NAME, "invalid-token");
+        let result = Enterprise::try_new().await;
+        assert!(result.is_err());
+    }
+}

tailcall-enterprise/src/lib.rs

@@ -0,0 +1,3 @@
+mod enterprise;
+
+pub use enterprise::Enterprise;