[upgrade] added specta to generate ts binding from rust

codad5 · codad5 · commit 8ee68696acf9 · 2023-12-18T14:03:12.000+01:00
diff --git a/src-tauri/Cargo.lock b/src-tauri/Cargo.lock
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
@@ -27,6 +27,8 @@ tauri-plugin-single-instance = { git = "https://github.com/tauri-apps/plugins-wo
 dotenv = "0.15.0"
 lazy_static = "1.4.0"
 strum = { version = "0.25.0", features = ["strum_macros"] }
+specta = "1.0.5"
+tauri-specta = { version = "1.0.2", features = ["javascript", "typescript"] }
 
 [features]
 # this feature is used for production builds or when `devPath` points to the filesystem
diff --git a/src-tauri/src/libs.rs b/src-tauri/src/libs.rs
@@ -1,4 +1,5 @@
 pub mod response;
 pub mod auth;
 pub mod filehelper;
-pub mod tauri_actions;
+pub mod tauri_actions;
+pub mod argument;
diff --git a/src-tauri/src/libs/argument.rs b/src-tauri/src/libs/argument.rs
@@ -0,0 +1,9 @@
+use specta::Type;
+use serde::{Deserialize, Serialize};
+
+
+#[derive(Deserialize, Type)]
+pub struct MyCustomArgumentType {
+    pub foo: String,
+    pub bar: i32,
+}
diff --git a/src-tauri/src/libs/auth.rs b/src-tauri/src/libs/auth.rs
@@ -10,7 +10,7 @@ use borsh::{BorshDeserialize, to_vec};
 
 
 
-#[derive(borsh::BorshDeserialize, borsh::BorshSerialize, Debug, serde::Serialize, serde::Deserialize, Clone)]
+#[derive(borsh::BorshDeserialize, borsh::BorshSerialize, Debug, serde::Serialize, serde::Deserialize, Clone, specta::Type)]
 pub struct AccessToken {
     access_token: String,
     expires_in: i32,
@@ -64,7 +64,7 @@ impl AccessToken {
 pub struct Auth;
 
 impl Auth {
-    pub fn save_auth_code(code: String) -> String {
+    pub fn save_auth_code(code: String) -> SaveTokenResponse {
         let encoded = to_vec(&code).unwrap();
         let password: String = env::var("DB_PASSWORD").unwrap();
         let mut cocoon = Cocoon::new(password.as_bytes());
@@ -79,7 +79,7 @@ impl Auth {
             success: true,
             token: code,
         };
-        serde_json::to_string(&response).expect("JSON serialization error")
+        return response;
     }
 
     pub fn load_auth_code() -> String {
@@ -95,18 +95,15 @@ impl Auth {
         };
     }
 
-    pub fn save_access_token(token: String) -> String {
+    pub fn save_access_token(token: String) -> SaveAccessTokenResponse {
         let content : AccessToken = serde_json::from_str(&token).unwrap();
         let response : SaveAccessTokenResponse = content.save();
-        // Serialize the response object to JSON and return as a string
-        serde_json::to_string(&response).expect("JSON serialization error")
+        return response;
     }
 
-    pub fn load_access_token() -> String {
+    pub fn load_access_token() -> AccessToken {
         let response : AccessToken = AccessToken::load();
-        println!("response: {:?}", response);
-        // Serialize the response object to JSON and return as a string
-        serde_json::to_string(&response).expect("JSON serialization error")
+        return response;
     }
 }
 
diff --git a/src-tauri/src/libs/response.rs b/src-tauri/src/libs/response.rs
@@ -1,16 +1,24 @@
+use specta::Type;
+use serde::{Deserialize, Serialize};
 use super::auth::AccessToken;
 // save token response 
-#[derive(serde::Serialize)]
+#[derive(Serialize, Type)]
 pub struct SaveTokenResponse {
     pub message: String,
     pub token: String,
     pub success: bool,
 }
 
 
-#[derive(serde::Serialize, serde::Deserialize)]
+#[derive(Serialize, Type)]
 pub struct SaveAccessTokenResponse {
     pub message: String,
     pub success: bool,
     pub token: AccessToken,
 }
+
+
+#[derive(Serialize, Type)]
+pub struct GreetResponse {
+    pub message: String,
+}
diff --git a/src-tauri/src/libs/tauri_actions.rs b/src-tauri/src/libs/tauri_actions.rs
@@ -5,54 +5,52 @@ use tauri;
 // super mod imports;
 use super::auth::{AccessToken, Auth};
 use super::filehelper::{ENV_FILE, ACCESS_TOKEN_FILE};
+use super::response::{SaveAccessTokenResponse, SaveTokenResponse, GreetResponse};
 
 
-#[derive(serde::Serialize)] // Add this derive to enable JSON serialization
-struct GreetResponse {
-    message: String,
-}
-
 
 #[tauri::command]
+#[specta::specta]
 pub fn test_command() -> String {
     println!("access token path: {}", &*ACCESS_TOKEN_FILE);
     println!("ENV_FILE: {}", ENV_FILE);
     return env::var("DB_PASSWORD").unwrap();
 }
 
-// Learn more about Tauri commands at https://tauri.app/v1/guides/features/command
 #[tauri::command]
-pub fn greet(name: String) -> String {
-    let response = GreetResponse {
+#[specta::specta]
+pub fn greet(name: String) -> GreetResponse {
+    return GreetResponse {
         message: format!("Hello, {}! You've been greeted from Rust!", name),
     };
-
-    // Serialize the response object to JSON and return as a string
-    serde_json::to_string(&response).expect("JSON serialization error")
 }
 
 // remember to call `.manage(MyState::default())`
 #[tauri::command]
-pub fn save_access_token(token: String) -> String {
+#[specta::specta]
+pub fn save_access_token(token: String) -> SaveAccessTokenResponse {
     dotenv::from_filename(ENV_FILE).ok();
     return Auth::save_access_token(token);
 }
 
 // a command to load the access token from the file
 #[tauri::command]
-pub fn load_access_token() -> String {
+#[specta::specta]
+pub fn load_access_token() -> AccessToken {
     dotenv::from_filename(ENV_FILE).ok();
     return Auth::load_access_token();
 }
 
 
 #[tauri::command]
-pub fn save_code(code: String) -> String {
+#[specta::specta]
+pub fn save_code(code: String) -> SaveTokenResponse {
     dotenv::from_filename(ENV_FILE).ok();
     return Auth::save_auth_code(code);
 }
 
 #[tauri::command]
+#[specta::specta]
 pub fn load_code() -> String {
     dotenv::from_filename(ENV_FILE).ok();
     return Auth::load_auth_code();
diff --git a/src-tauri/src/main.rs b/src-tauri/src/main.rs
@@ -4,33 +4,55 @@
 mod libs;
 
 use tauri_plugin_log::{LogTarget};
+use specta::collect_types;
+use tauri_specta::{ts, js};
+
+
 use libs::tauri_actions::{save_access_token,load_access_token, greet, test_command, save_code, load_code};
 use libs::filehelper::{ENV_FILE, initialize_user_files};
 
 
-fn main() {
-    dotenv::from_filename(ENV_FILE).ok();
-    initialize_user_files();
-    tauri::Builder::default()
-        .plugin(tauri_plugin_single_instance::init(|app, argv, cwd| {
-            println!("{}, {argv:?}, {cwd}", app.package_info().name);
-            // app.emit_all("single-instance", Payload { args: argv, cwd }).unwrap();
-        }))
-        .plugin(tauri_plugin_context_menu::init())
-        .plugin(tauri_plugin_oauth::init())
-        .plugin(tauri_plugin_log::Builder::default().targets([
-            LogTarget::LogDir,
-            LogTarget::Stdout,
-            LogTarget::Webview,
-        ]).build())
-        .invoke_handler(tauri::generate_handler![
+fn run_specta() {
+
+    println!("Running specta to generate typescript bindings");
+
+     #[cfg(debug_assertions)]
+    ts::export(collect_types![
             save_access_token,
             load_access_token,
             greet,
             test_command,
             save_code,
             load_code,
-        ])
-        .run(tauri::generate_context!())
-        .expect("error while running tauri application");
+    ], "../src/helpers/commands.ts").unwrap();
+}
+
+fn main() {
+    dotenv::from_filename(ENV_FILE).ok();
+    initialize_user_files();
+    run_specta();
+
+    tauri::Builder::default()
+    .plugin(tauri_plugin_single_instance::init(|app, argv, cwd| {
+        println!("{}, {argv:?}, {cwd}", app.package_info().name);
+        // app.emit_all("single-instance", Payload { args: argv, cwd }).unwrap();
+    }))
+    .plugin(tauri_plugin_context_menu::init())
+    .plugin(tauri_plugin_oauth::init())
+    .plugin(tauri_plugin_log::Builder::default().targets([
+        LogTarget::LogDir,
+        LogTarget::Stdout,
+        LogTarget::Webview,
+    ])
+    .build())
+    .invoke_handler(tauri::generate_handler![
+        save_access_token,
+        load_access_token,
+        greet,
+        test_command,
+        save_code,
+        load_code,
+    ])
+    .run(tauri::generate_context!())
+    .expect("error while running tauri application");
 }
diff --git a/src/App.tsx b/src/App.tsx
@@ -1,7 +1,7 @@
 import { useState , useEffect} from "react";
 import { Box, Button, Spinner, useToast  } from '@chakra-ui/react'
 import { fetchUserProfile,getUserProfileFromStorage,  getAccessToken, openAuthWindow, saveAccessToken, saveAuthCode, saveUserProfile, getAccessTokenFromStorage, deleteAccessToken } from "./helpers/auth";
-import { AccessToken, UserProfile } from "./types/googleapis";
+import { UserProfile } from "./types/googleapis";
 import { loadContextmenu , pushNotification } from "./helpers/windowhelper";
 import TaskPage from "./components/TaskPage";
 import { useRecoilState, useRecoilValue, useSetRecoilState } from "recoil";
@@ -10,6 +10,7 @@ import Header from "./components/ui/Header";
 import { task } from "./types/taskapi";
 import { listen_for_auth_code } from "./helpers/eventlistner";
 import { test_command } from "./helpers/invoker";
+import { AccessToken } from "./helpers/commands";
 
 // disable default context menu on build
 loadContextmenu();
@@ -114,7 +115,7 @@ function App() {
     if (!accessToken) throw new Error("Signin required");
     pushNotification("Login Successful")
     const profile = navigator.onLine ? await fetchUserProfile(accessToken.access_token) : await getUserProfileFromStorage();
-    if(!profile) throw new Error("Something went wrong, please try again");
+    if(!profile || !profile?.email) throw new Error("Something went wrong, please try again");
     setProfile(profile);
     setAccessToken(accessToken.access_token);
     pushNotification(`welcome back ${profile.name}`)
diff --git a/src/helpers/auth.ts b/src/helpers/auth.ts
@@ -1,10 +1,11 @@
 import { shell } from "@tauri-apps/api";
 import axios from "axios";
-import { AccessToken, UserProfile } from "../types/googleapis";
+import { UserProfile } from "../types/googleapis";
 import { readTextFile, removeFile, writeTextFile, exists } from "@tauri-apps/api/fs";
 import { CLIENT_ID, CLIENT_SECRET } from "../config/credentials";
 import settings from "../config/settings";
 import { generate_oauth_port, get_access_token, get_auth_code, save_access_token, save_auth_code } from "./invoker";
+import { AccessToken } from "./commands";
 
 
 const DEFAULT_DIRECTORY = settings.fs.DEFAULT_DIRECTORY;
@@ -159,13 +160,12 @@ export async function getAccessTokenFromStorage() {
     try {
         // if file does not exist, return null
         if(! await exists(STORAGE_PATHS.access_token, { dir: DEFAULT_DIRECTORY })) throw new Error("File does not exist");
-        const accessTokenText: string = (await get_access_token()) as string;
+        let accessToken = await get_access_token();
         console.log('new access token found')
-        let accessToken = JSON.parse(accessTokenText) as AccessToken;
         // check if the access token is expired
         console.log(accessToken, "accessToken");
         const lastLogin = parseInt(localStorage.getItem("lastLogin") || "0");
-        if ((accessToken.expiry_in < Date.now() || Date.now() - lastLogin > 3620) && navigator.onLine){
+        if ((accessToken.expires_in < Date.now() || Date.now() - lastLogin > 3620) && navigator.onLine){
             console.log("Access token expired");
             accessToken = await refreshAndSaveAccessToken(accessToken.refresh_token);
         }
diff --git a/src/helpers/commands.ts b/src/helpers/commands.ts
@@ -0,0 +1,40 @@
+/* eslint-disable */
+// This file was generated by [tauri-specta](https://github.com/oscartbeaumont/tauri-specta). Do not edit this file manually.
+
+declare global {
+    interface Window {
+        __TAURI_INVOKE__<T>(cmd: string, args?: Record<string, unknown>): Promise<T>;
+    }
+}
+
+// Function avoids 'window not defined' in SSR
+const invoke = () => window.__TAURI_INVOKE__;
+
+export function saveAccessToken(token: string) {
+    return invoke()<SaveAccessTokenResponse>("save_access_token", { token })
+}
+
+export function loadAccessToken() {
+    return invoke()<AccessToken>("load_access_token")
+}
+
+export function greet(name: string) {
+    return invoke()<GreetResponse>("greet", { name })
+}
+
+export function testCommand() {
+    return invoke()<string>("test_command")
+}
+
+export function saveCode(code: string) {
+    return invoke()<SaveTokenResponse>("save_code", { code })
+}
+
+export function loadCode() {
+    return invoke()<string>("load_code")
+}
+
+export type GreetResponse = { message: string }
+export type SaveTokenResponse = { message: string; token: string; success: boolean }
+export type SaveAccessTokenResponse = { message: string; success: boolean; token: AccessToken }
+export type AccessToken = { access_token: string; expires_in: number; refresh_token: string; scope: string; token_type: string; id_token: string }
diff --git a/src/helpers/googleapihelper.ts b/src/helpers/googleapihelper.ts
@@ -1,7 +1,8 @@
 import { readTextFile } from "@tauri-apps/api/fs";
 import settings from "../config/settings";
-import { AccessToken, GoogleServices } from "../types/googleapis";
+import {GoogleServices } from "../types/googleapis";
 import axios, { AxiosInstance } from "axios";
+import { AccessToken } from "./commands";
 
 
 const STORAGE_PATHS = settings.storage.paths;
diff --git a/src/helpers/invoker.ts b/src/helpers/invoker.ts
@@ -1,29 +1,30 @@
-import {invoke} from '@tauri-apps/api/tauri';
-import { AccessToken } from '../types/googleapis';
+import { invoke } from '@tauri-apps/api/tauri';
+import * as commands from './commands';
+import { AccessToken } from './commands';
 
 export async function save_auth_code(code: string) {
-    return await invoke('save_code', {code});
+    return await commands.saveCode(code);
 }
 
 export async function get_auth_code() {
-    return await invoke('load_code');
+    return await commands.loadCode();
 }
 
 export async function save_access_token(token: string|AccessToken) {
     const accessTokenText: string = typeof token === "string" ? token : JSON.stringify(token, null, 2);
-    return await invoke('save_access_token', {token : accessTokenText});
+    return await commands.saveAccessToken(accessTokenText);
 }
 
 export async function get_access_token() {
-    return await invoke<String|string>('load_access_token');
+    return await commands.loadAccessToken();
 }
 
 export async function test_command() {
-    return await invoke<string>('test_command');
+    return await commands.testCommand();
 }
 
 export async function greet(name: string) {
-    return await invoke('greet', {name});
+    return await commands.greet(name);
 }
 
 export async function generate_oauth_port() {
diff --git a/src/types/googleapis.ts b/src/types/googleapis.ts
