query works

crates/desktop/artcraft/src/core/lifecycle/startup/bootstrap_task_database.rs

@@ -3,8 +3,8 @@ use crate::core::state::task_database::TaskDatabase;
 use errors::AnyhowResult;
 use tauri::{AppHandle, Manager};
 
-pub async fn bootstrap_task_database(app: &AppHandle, root: &AppDataRoot) -> AnyhowResult<()> {
+pub async fn bootstrap_task_database(app: &AppHandle, root: &AppDataRoot) -> AnyhowResult<TaskDatabase> {
   let task_database = TaskDatabase::connect(root).await?;
-  app.manage(task_database); 
-  Ok(())
+  app.manage(task_database.clone());
+  Ok(task_database)
 }

crates/desktop/artcraft/src/core/lifecycle/startup/handle_tauri_startup.rs

@@ -1,9 +1,25 @@
 use crate::core::lifecycle::startup::bootstrap_task_database::bootstrap_task_database;
+use crate::core::lifecycle::startup::spawn_storytoller_task_polling_thread::spawn_storyteller_task_polling_thread;
+use crate::core::state::app_env_configs::app_env_configs::AppEnvConfigs;
 use crate::core::state::data_dir::app_data_root::AppDataRoot;
+use crate::services::storyteller::state::storyteller_credential_manager::StorytellerCredentialManager;
 use errors::AnyhowResult;
-use tauri::AppHandle;
+use tauri::{AppHandle, Manager};
+
+pub async fn handle_tauri_startup(
+  app: AppHandle,
+  root: AppDataRoot,
+  app_env_configs: AppEnvConfigs,
+  storyteller_creds_manager: StorytellerCredentialManager,
+) -> AnyhowResult<()> {
+  let task_database = bootstrap_task_database(&app, &root).await?;
+
+  spawn_storyteller_task_polling_thread(
+    &app,
+    &app_env_configs,
+    &task_database,
+    &storyteller_creds_manager,
+  )?;
 
-pub async fn handle_tauri_startup(app: AppHandle, root: AppDataRoot) -> AnyhowResult<()> {
-  bootstrap_task_database(&app, &root).await?;
   Ok(())
 }

crates/desktop/artcraft/src/core/lifecycle/startup/mod.rs

@@ -1,2 +1,3 @@
 pub mod bootstrap_task_database;
-pub mod handle_tauri_startup;
+pub mod handle_tauri_startup;
+mod spawn_storytoller_task_polling_thread;

crates/desktop/artcraft/src/core/lifecycle/startup/spawn_storytoller_task_polling_thread.rs

@@ -0,0 +1,23 @@
+use crate::core::state::app_env_configs::app_env_configs::AppEnvConfigs;
+use crate::core::state::task_database::TaskDatabase;
+use crate::services::storyteller::state::storyteller_credential_manager::StorytellerCredentialManager;
+use crate::services::storyteller::threads::storyteller_task_polling_thread::storyteller_task_polling_thread;
+use errors::AnyhowResult;
+use tauri::{AppHandle, Manager};
+
+pub fn spawn_storyteller_task_polling_thread(
+  app: &AppHandle,
+  app_env_configs: &AppEnvConfigs,
+  task_database: &TaskDatabase,
+  storyteller_creds_manager: &StorytellerCredentialManager,
+) -> AnyhowResult<()> {
+  
+  tauri::async_runtime::spawn(storyteller_task_polling_thread(
+    app.clone(),
+    app_env_configs.clone(),
+    task_database.clone(),
+    storyteller_creds_manager.clone(),
+  ));
+  
+  Ok(())
+}

crates/desktop/artcraft/src/lib.rs

@@ -129,11 +129,13 @@ pub fn run() {
       //  )?;
       //}
       let app = app.handle().clone();
-      let app2 = app.clone();
+      let handle = app.clone();
       let root = app_data_root_2.clone();
+      let env_config = app_env_configs_2.clone();
+      let storyteller_creds = storyteller_creds_manager_2.clone();
 
       tauri::async_runtime::block_on(async move {
-        if let Err(err) = handle_tauri_startup(app2, root).await {
+        if let Err(err) = handle_tauri_startup(handle, root, env_config, storyteller_creds).await {
           error!("Failed to handle Tauri startup: {:?}", err);
           panic!("Failed to handle Tauri startup: {:?}", err);
         }

crates/desktop/artcraft/src/services/storyteller/threads/storyteller_task_polling_thread.rs

@@ -1,4 +1,3 @@
-use std::collections::HashMap;
 use crate::core::events::basic_sendable_event_trait::BasicSendableEvent;
 use crate::core::events::generation_events::common::{GenerationAction, GenerationServiceProvider};
 use crate::core::events::generation_events::generation_complete_event::GenerationCompleteEvent;
@@ -7,32 +6,32 @@ use crate::core::events::sendable_event_trait::SendableEvent;
 use crate::core::state::app_env_configs::app_env_configs::AppEnvConfigs;
 use crate::core::state::data_dir::app_data_root::AppDataRoot;
 use crate::core::state::data_dir::trait_data_subdir::DataSubdir;
+use crate::core::state::task_database::TaskDatabase;
 use crate::services::sora::state::sora_credential_manager::SoraCredentialManager;
 use crate::services::sora::state::sora_task_queue::SoraTaskQueue;
 use crate::services::storyteller::state::storyteller_credential_manager::StorytellerCredentialManager;
-use errors::AnyhowResult;
-use log::{error, info};
-use reqwest::Url;
-use std::fs::File;
-use std::io::Write;
-use std::path::PathBuf;
 use anyhow::anyhow;
-use storyteller_client::media_files::upload_image_media_file_from_file::upload_image_media_file_from_file;
-use tauri::AppHandle;
-use tempdir::TempDir;
 use enums::common::generation_provider::GenerationProvider;
 use enums::common::job_status_plus::JobStatusPlus;
 use enums::tauri::tasks::task_status::TaskStatus;
+use errors::AnyhowResult;
+use log::{error, info};
+use reqwest::Url;
 use sqlite_tasks::queries::list_tasks_by_provider_and_tokens::{list_tasks_by_provider_and_tokens, ListTasksArgs, Task};
+use std::collections::HashMap;
+use std::fs::File;
+use std::io::Write;
+use std::path::PathBuf;
 use storyteller_client::error::api_error::ApiError;
 use storyteller_client::error::storyteller_error::StorytellerError;
 use storyteller_client::jobs::list_session_jobs::{list_session_jobs, States};
-use crate::core::state::task_database::TaskDatabase;
+use storyteller_client::media_files::upload_image_media_file_from_file::upload_image_media_file_from_file;
+use tauri::AppHandle;
+use tempdir::TempDir;
 
 pub async fn storyteller_task_polling_thread(
   app_handle: AppHandle,
   app_env_configs: AppEnvConfigs,
-  app_data_root: AppDataRoot,
   task_database: TaskDatabase,
   storyteller_creds_manager: StorytellerCredentialManager,
 ) -> ! {
@@ -40,7 +39,6 @@ pub async fn storyteller_task_polling_thread(
     let res = polling_loop(
       &app_handle,
       &app_env_configs,
-      &app_data_root,
       &task_database,
       &storyteller_creds_manager,
     ).await;
@@ -55,7 +53,6 @@ pub async fn storyteller_task_polling_thread(
 async fn polling_loop(
   app_handle: &AppHandle,
   app_env_configs: &AppEnvConfigs,
-  app_data_root: &AppDataRoot,
   task_database: &TaskDatabase,
   storyteller_creds_manager: &StorytellerCredentialManager,
 ) -> AnyhowResult<()> {

crates/schema/database/sqlite_tasks/src/queries/list_tasks_by_provider_and_tokens.rs

@@ -3,7 +3,9 @@ use crate::error::SqliteTasksError;
 use enums::common::generation_provider::GenerationProvider;
 use enums::tauri::tasks::task_status::TaskStatus;
 use enums::tauri::tasks::task_type::TaskType;
-use sqlx::{QueryBuilder, Sqlite};
+use log::info;
+use sqlx::{Execute, QueryBuilder, Sqlite};
+use tokens::tokens::sqlite::tasks::TaskId;
 
 pub struct ListTasksArgs<'a> {
   pub db: &'a TaskDbConnection,
@@ -17,6 +19,7 @@ pub struct TaskList {
 
 #[derive(Debug, Clone)]
 pub struct Task {
+  pub id: TaskId,
   pub status: TaskStatus,
   pub task_type: TaskType,
   pub provider: GenerationProvider,
@@ -28,7 +31,8 @@ pub struct Task {
 #[derive(Debug)]
 #[derive(sqlx::FromRow)]
 struct RawTask {
-  status: String,
+  id: String,
+  task_status: String,
   task_type: String,
   provider: String,
   provider_job_id: Option<String>,
@@ -50,7 +54,7 @@ pub async fn list_tasks_by_provider_and_tokens(
       frontend_subscriber_id,
       frontend_subscriber_payload
     FROM tasks
-    WHERE provider = ?
+    WHERE provider =
   "#);
 
   // TODO(bt,2025-07-15): Fix this. The sqlx mysql queries never required temporaries
@@ -58,16 +62,9 @@ pub async fn list_tasks_by_provider_and_tokens(
 
   query_builder.push_bind(provider);
 
+  /*
   if let Some(provider_job_ids) = args.provider_job_ids {
     query_builder.push(" AND provider_job_id IN (");
-    //for (i, job_id) in provider_job_ids.iter().enumerate() {
-    //  if i > 0 {
-    //    query_builder.push(", ");
-    //  }
-    //  query_builder.push_bind(job_id);
-    //}
-    //query_builder.push(")");
-
     let mut separated = query_builder.separated(", ");
 
     for job_id in provider_job_ids.into_iter() {
@@ -76,17 +73,22 @@ pub async fn list_tasks_by_provider_and_tokens(
 
     separated.push_unseparated(") ");
   }
+  */
 
   //let query = query_builder.build();
 
   let query = query_builder.build_query_as::<RawTask>();
+
+  info!("Query: {:?}", query.sql());
+
   let results = query.fetch_all(args.db.get_pool()).await?;
 
   let mut tasks: Vec<Task> = Vec::new();
 
   for task in results {
     tasks.push(Task {
-      status: TaskStatus::from_str(&task.status)
+      id: TaskId::new_from_str(&task.id),
+      status: TaskStatus::from_str(&task.task_status)
           .map_err(|err| SqliteTasksError::TaskParseError(err))?,
       task_type: TaskType::from_str(&task.task_type)
           .map_err(|err| SqliteTasksError::TaskParseError(err))?,