Decouple core Yaak logic from Tauri (#354)

crates-tauri/yaak-license/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "yaak-license"
+links = "yaak-license"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[dependencies]
+chrono = "0.4.38"
+log = { workspace = true }
+reqwest = { workspace = true, features = ["json"] }
+serde = { workspace = true, features = ["derive"] }
+serde_json = { workspace = true }
+tauri = { workspace = true }
+thiserror = { workspace = true }
+ts-rs = { workspace = true }
+yaak-common = { workspace = true }
+yaak-models = { workspace = true }
+yaak-tauri-utils = { workspace = true }
+
+[build-dependencies]
+tauri-plugin = { workspace = true, features = ["build"] }

crates-tauri/yaak-license/bindings/gen_models.ts

@@ -0,0 +1,3 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type CheckActivationRequestPayload = { appVersion: string, appPlatform: string, };

crates-tauri/yaak-license/bindings/license.ts

@@ -0,0 +1,11 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type APIErrorResponsePayload = { error: string, message: string, };
+
+export type ActivateLicenseRequestPayload = { licenseKey: string, appVersion: string, appPlatform: string, };
+
+export type ActivateLicenseResponsePayload = { activationId: string, };
+
+export type DeactivateLicenseRequestPayload = { appVersion: string, appPlatform: string, };
+
+export type LicenseCheckStatus = { "status": "personal_use", "data": { trial_ended: string, } } | { "status": "trialing", "data": { end: string, } } | { "status": "error", "data": { message: string, code: string, } } | { "status": "active", "data": { periodEnd: string, cancelAt: string | null, } } | { "status": "inactive", "data": { status: string, } } | { "status": "expired", "data": { changes: number, changesUrl: string | null, billingUrl: string, periodEnd: string, } } | { "status": "past_due", "data": { billingUrl: string, periodEnd: string, } };

crates-tauri/yaak-license/bindings/models.ts

@@ -0,0 +1,3 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type CheckActivationRequestPayload = { activationId: string, };

crates-tauri/yaak-license/build.rs

@@ -0,0 +1,5 @@
+const COMMANDS: &[&str] = &["activate", "deactivate", "check"];
+
+fn main() {
+    tauri_plugin::Builder::new(COMMANDS).build();
+}

crates-tauri/yaak-license/index.ts

@@ -0,0 +1,53 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { invoke } from '@tauri-apps/api/core';
+import { listen } from '@tauri-apps/api/event';
+import { appInfo } from '@yaakapp/app/lib/appInfo';
+import { useEffect } from 'react';
+import { LicenseCheckStatus } from './bindings/license';
+
+export * from './bindings/license';
+
+const CHECK_QUERY_KEY = ['license.check'];
+
+export function useLicense() {
+  const queryClient = useQueryClient();
+  const activate = useMutation<void, string, { licenseKey: string }>({
+    mutationKey: ['license.activate'],
+    mutationFn: (payload) => invoke('plugin:yaak-license|activate', payload),
+    onSuccess: () => queryClient.invalidateQueries({ queryKey: CHECK_QUERY_KEY }),
+  });
+
+  const deactivate = useMutation<void, string, void>({
+    mutationKey: ['license.deactivate'],
+    mutationFn: () => invoke('plugin:yaak-license|deactivate'),
+    onSuccess: () => queryClient.invalidateQueries({ queryKey: CHECK_QUERY_KEY }),
+  });
+
+  // Check the license again after a license is activated
+  useEffect(() => {
+    const unlisten = listen('license-activated', async () => {
+      await queryClient.invalidateQueries({ queryKey: CHECK_QUERY_KEY });
+    });
+    return () => {
+      unlisten.then((fn) => fn());
+    };
+  }, []);
+
+  const check = useQuery<LicenseCheckStatus | null, string>({
+    refetchInterval: 1000 * 60 * 60 * 12, // Refetch every 12 hours
+    refetchOnWindowFocus: false,
+    queryKey: CHECK_QUERY_KEY,
+    queryFn: async () => {
+      if (!appInfo.featureLicense) {
+        return null;
+      }
+      return invoke<LicenseCheckStatus>('plugin:yaak-license|check');
+    },
+  });
+
+  return {
+    activate,
+    deactivate,
+    check,
+  } as const;
+}

crates-tauri/yaak-license/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@yaakapp-internal/license",
+  "private": true,
+  "version": "1.0.0",
+  "main": "index.ts"
+}

crates-tauri/yaak-license/permissions/default.toml

@@ -0,0 +1,3 @@
+[default]
+description = "Default permissions for the plugin"
+permissions = ["allow-check", "allow-activate", "allow-deactivate"]

crates-tauri/yaak-license/src/commands.rs

@@ -0,0 +1,18 @@
+use crate::error::Result;
+use crate::{LicenseCheckStatus, activate_license, check_license, deactivate_license};
+use tauri::{Runtime, WebviewWindow, command};
+
+#[command]
+pub async fn check<R: Runtime>(window: WebviewWindow<R>) -> Result<LicenseCheckStatus> {
+    check_license(&window).await
+}
+
+#[command]
+pub async fn activate<R: Runtime>(license_key: &str, window: WebviewWindow<R>) -> Result<()> {
+    activate_license(&window, license_key).await
+}
+
+#[command]
+pub async fn deactivate<R: Runtime>(window: WebviewWindow<R>) -> Result<()> {
+    deactivate_license(&window).await
+}

crates-tauri/yaak-license/src/error.rs

@@ -0,0 +1,34 @@
+use serde::{Serialize, Serializer};
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum Error {
+    #[error("Reqwest error: {0}")]
+    APIError(#[from] reqwest::Error),
+
+    #[error("JSON error: {0}")]
+    JsonError(#[from] serde_json::Error),
+
+    #[error("{message}")]
+    ClientError { message: String, error: String },
+
+    #[error(transparent)]
+    ModelError(#[from] yaak_models::error::Error),
+
+    #[error(transparent)]
+    TauriUtilsError(#[from] yaak_tauri_utils::error::Error),
+
+    #[error("Internal server error")]
+    ServerError,
+}
+
+impl Serialize for Error {
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(self.to_string().as_ref())
+    }
+}
+
+pub type Result<T> = std::result::Result<T, Error>;

crates-tauri/yaak-license/src/lib.rs

@@ -0,0 +1,17 @@
+use tauri::{
+    Runtime, generate_handler,
+    plugin::{Builder, TauriPlugin},
+};
+
+mod commands;
+pub mod error;
+mod license;
+
+use crate::commands::{activate, check, deactivate};
+pub use license::*;
+
+pub fn init<R: Runtime>() -> TauriPlugin<R> {
+    Builder::new("yaak-license")
+        .invoke_handler(generate_handler![check, activate, deactivate])
+        .build()
+}

crates-tauri/yaak-license/src/license.rs

@@ -0,0 +1,243 @@
+use crate::error::Error::{ClientError, JsonError, ServerError};
+use crate::error::Result;
+use chrono::{DateTime, Utc};
+use log::{info, warn};
+use serde::{Deserialize, Serialize};
+use std::ops::Add;
+use std::time::Duration;
+use tauri::{AppHandle, Emitter, Manager, Runtime, WebviewWindow, is_dev};
+use ts_rs::TS;
+use yaak_common::platform::get_os_str;
+use yaak_tauri_utils::api_client::yaak_api_client;
+use yaak_models::db_context::DbContext;
+use yaak_models::query_manager::QueryManager;
+use yaak_models::util::UpdateSource;
+
+/// Extension trait for accessing the QueryManager from Tauri Manager types.
+/// This is needed temporarily until all crates are refactored to not use Tauri.
+trait QueryManagerExt<'a, R> {
+    fn db(&'a self) -> DbContext<'a>;
+}
+
+impl<'a, R: Runtime, M: Manager<R>> QueryManagerExt<'a, R> for M {
+    fn db(&'a self) -> DbContext<'a> {
+        let qm = self.state::<QueryManager>();
+        qm.inner().connect()
+    }
+}
+
+const KV_NAMESPACE: &str = "license";
+const KV_ACTIVATION_ID_KEY: &str = "activation_id";
+const TRIAL_SECONDS: u64 = 3600 * 24 * 30;
+
+#[derive(Debug, Clone, Serialize, Deserialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "gen_models.ts")]
+pub struct CheckActivationRequestPayload {
+    pub app_version: String,
+    pub app_platform: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "license.ts")]
+pub struct ActivateLicenseRequestPayload {
+    pub license_key: String,
+    pub app_version: String,
+    pub app_platform: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "license.ts")]
+pub struct DeactivateLicenseRequestPayload {
+    pub app_version: String,
+    pub app_platform: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "license.ts")]
+pub struct ActivateLicenseResponsePayload {
+    pub activation_id: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "license.ts")]
+pub struct APIErrorResponsePayload {
+    pub error: String,
+    pub message: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, TS)]
+#[serde(rename_all = "snake_case", tag = "status", content = "data")]
+#[ts(export, export_to = "license.ts")]
+pub enum LicenseCheckStatus {
+    // Local Types
+    PersonalUse {
+        trial_ended: DateTime<Utc>,
+    },
+    Trialing {
+        end: DateTime<Utc>,
+    },
+    Error {
+        message: String,
+        code: String,
+    },
+
+    // Server Types
+    Active {
+        #[serde(rename = "periodEnd")]
+        period_end: DateTime<Utc>,
+        #[serde(rename = "cancelAt")]
+        cancel_at: Option<DateTime<Utc>>,
+    },
+    Inactive {
+        status: String,
+    },
+    Expired {
+        changes: i32,
+        #[serde(rename = "changesUrl")]
+        changes_url: Option<String>,
+        #[serde(rename = "billingUrl")]
+        billing_url: String,
+        #[serde(rename = "periodEnd")]
+        period_end: DateTime<Utc>,
+    },
+    PastDue {
+        #[serde(rename = "billingUrl")]
+        billing_url: String,
+        #[serde(rename = "periodEnd")]
+        period_end: DateTime<Utc>,
+    },
+}
+
+pub async fn activate_license<R: Runtime>(
+    window: &WebviewWindow<R>,
+    license_key: &str,
+) -> Result<()> {
+    info!("Activating license {}", license_key);
+    let client = reqwest::Client::new();
+    let payload = ActivateLicenseRequestPayload {
+        license_key: license_key.to_string(),
+        app_platform: get_os_str().to_string(),
+        app_version: window.app_handle().package_info().version.to_string(),
+    };
+    let response = client.post(build_url("/licenses/activate")).json(&payload).send().await?;
+
+    if response.status().is_client_error() {
+        let body: APIErrorResponsePayload = response.json().await?;
+        return Err(ClientError { message: body.message, error: body.error });
+    }
+
+    if response.status().is_server_error() {
+        return Err(ServerError);
+    }
+
+    let body: ActivateLicenseResponsePayload = response.json().await?;
+    window.app_handle().db().set_key_value_str(
+        KV_ACTIVATION_ID_KEY,
+        KV_NAMESPACE,
+        body.activation_id.as_str(),
+        &UpdateSource::from_window_label(window.label()),
+    );
+
+    if let Err(e) = window.emit("license-activated", true) {
+        warn!("Failed to emit check-license event: {}", e);
+    }
+
+    Ok(())
+}
+
+pub async fn deactivate_license<R: Runtime>(window: &WebviewWindow<R>) -> Result<()> {
+    info!("Deactivating activation");
+    let app_handle = window.app_handle();
+    let activation_id = get_activation_id(app_handle).await;
+
+    let client = reqwest::Client::new();
+    let path = format!("/licenses/activations/{}/deactivate", activation_id);
+    let payload = DeactivateLicenseRequestPayload {
+        app_platform: get_os_str().to_string(),
+        app_version: window.app_handle().package_info().version.to_string(),
+    };
+    let response = client.post(build_url(&path)).json(&payload).send().await?;
+
+    if response.status().is_client_error() {
+        let body: APIErrorResponsePayload = response.json().await?;
+        return Err(ClientError { message: body.message, error: body.error });
+    }
+
+    if response.status().is_server_error() {
+        return Err(ServerError);
+    }
+
+    app_handle.db().delete_key_value(
+        KV_ACTIVATION_ID_KEY,
+        KV_NAMESPACE,
+        &UpdateSource::from_window_label(window.label()),
+    )?;
+
+    if let Err(e) = app_handle.emit("license-deactivated", true) {
+        warn!("Failed to emit deactivate-license event: {}", e);
+    }
+
+    Ok(())
+}
+
+pub async fn check_license<R: Runtime>(window: &WebviewWindow<R>) -> Result<LicenseCheckStatus> {
+    let payload = CheckActivationRequestPayload {
+        app_platform: get_os_str().to_string(),
+        app_version: window.package_info().version.to_string(),
+    };
+    let activation_id = get_activation_id(window.app_handle()).await;
+
+    let settings = window.db().get_settings();
+    let trial_end = settings.created_at.add(Duration::from_secs(TRIAL_SECONDS)).and_utc();
+
+    let has_activation_id = !activation_id.is_empty();
+    let trial_period_active = Utc::now() < trial_end;
+
+    match (has_activation_id, trial_period_active) {
+        (false, true) => Ok(LicenseCheckStatus::Trialing { end: trial_end }),
+        (false, false) => Ok(LicenseCheckStatus::PersonalUse { trial_ended: trial_end }),
+        (true, _) => {
+            info!("Checking license activation");
+            // A license has been activated, so let's check the license server
+            let client = yaak_api_client(window.app_handle())?;
+            let path = format!("/licenses/activations/{activation_id}/check-v2");
+            let response = client.post(build_url(&path)).json(&payload).send().await?;
+
+            if response.status().is_client_error() {
+                let body: APIErrorResponsePayload = response.json().await?;
+                return Err(ClientError { message: body.message, error: body.error });
+            }
+
+            if response.status().is_server_error() {
+                warn!("Failed to check license {}", response.status());
+                return Err(ServerError);
+            }
+
+            let body_text = response.text().await?;
+            match serde_json::from_str::<LicenseCheckStatus>(&body_text) {
+                Ok(b) => Ok(b),
+                Err(e) => {
+                    warn!("Failed to decode server response: {} {:?}", body_text, e);
+                    Err(JsonError(e))
+                }
+            }
+        }
+    }
+}
+
+fn build_url(path: &str) -> String {
+    if is_dev() {
+        format!("http://localhost:9444{path}")
+    } else {
+        format!("https://license.yaak.app{path}")
+    }
+}
+
+pub async fn get_activation_id<R: Runtime>(app_handle: &AppHandle<R>) -> String {
+    app_handle.db().get_key_value_str(KV_ACTIVATION_ID_KEY, KV_NAMESPACE, "")
+}