platform-wasm-ui — IMP FORGE

WASM client infrastructure for offline-first admin portals

Tier	platform
Role	unclassified (baselined)
Path	`crates/platform/wasm-ui`
Edition	2021
Targets	platform_wasm_ui
Public items	88 across 5 modules
Tests	20

What it is for

# platform-wasm-ui

WASM client infrastructure for offline-first admin portals.

This crate provides the building blocks for creating offline-capable admin interfaces that sync with a server when connectivity is available.

Core Components

`SyncEngine`<S>: Coordinates syncing with the server, generic over storage
`OutboxManager`<S>: Manages the command outbox queue, generic over storage
`ApiClient`: HTTP client for server communication
`SyncStatus`: Reactive sync status for UI display

Storage Abstraction

This crate is generic over the storage backend via KeyValueStore from infrastructure-kv-store. This allows the same code to run with:

InMemoryStore for testing
IndexedDbStore for browser WASM (enable indexeddb feature)
SqliteStore for Tauri desktop/mobile (future)

Architecture

┌─────────────────────────────────────────────────────────────┐
│                     WASM Admin Client                       │
│                                                             │
│  ┌───────────────┐    ┌───────────────────────────────┐    │
│  │   UI Layer    │───▶│   SyncEngine<S: KeyValueStore>│    │
│  │   (Leptos)    │    └───────────────┬───────────────┘    │
│  └───────────────┘                    │                    │
│          │                ┌───────────┼───────────┐        │
│          ▼                ▼           ▼           ▼        │
│  ┌───────────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐ │
│  │  KeyValueStore│  │ Outbox  │  │  Meta   │  │   API   │ │
│  │  (abstract)   │  │ Manager │  │ Storage │  │  Client │ │
│  └───────────────┘  └─────────┘  └─────────┘  └─────────┘ │
└─────────────────────────────────────────────────────────────┘

Example

use std::sync::Arc;
use platform_wasm_ui::{SyncEngine, SyncConfig};
use infrastructure_kv_store::InMemoryStore;
use infrastructure_sync::{Command, IdempotencyKey};

// Create storage and sync engine
let store = Arc::new(InMemoryStore::new());
let config = SyncConfig::new("https://api.example.com");
let mut engine = SyncEngine::new(config, store).await?;

// Queue a command (works offline)
let cmd = Command::CreatePage {
idempotency_key: IdempotencyKey::new(),
slug: "hello".to_string(),
title: "Hello World".to_string(),
page_type: "post".to_string(),
content: "My first post".to_string(),
};
engine.queue_command(cmd).await?;

// Check sync status
let status = engine.status();
if status.pending_count > 0 {
println!("{} commands pending sync", status.pending_count);
}

Capabilities

`ApiClient`

HTTP API client for server communication.

Item
`pub struct ApiClient`
`ApiClient :: fn new(config : ApiConfig) -> Self`
`ApiClient :: fn set_auth_token(& mut self, token : Option <String>)`
`ApiClient :: fn is_authenticated(& self) -> bool`
`ApiClient :: async fn submit_command(& self, command : & Command) -> WasmResult <ServerAck>`
`ApiClient :: async fn submit_commands(& self, commands : & Command) -> WasmResult <Vec <ServerAck>>`
`ApiClient :: async fn pull_changes(& self, request : & PullRequest) -> WasmResult <PullResponse>`
`ApiClient :: async fn login(& mut self, email : & str, password : & str) -> WasmResult <LoginResponse>`
`ApiClient :: async fn logout(& mut self) -> WasmResult <()>`
`ApiClient :: async fn refresh_token(& mut self) -> WasmResult <String>`
`ApiClient :: async fn health_check(& self) -> WasmResult <bool>`

`ApiConfig`

HTTP API client for server communication.

Item
`pub struct ApiConfig`
`ApiConfig :: fn new(base_url : impl Into <String>) -> Self`
`ApiConfig :: fn with_timeout(mut self, timeout_ms : u32) -> Self`

`LoginResponse`

HTTP API client for server communication.

Item
`pub struct LoginResponse`

`WasmError`

Error types for WASM client operations.

Item
`pub enum WasmError`
`WasmError :: fn storage(msg : impl Into <String>) -> Self`
`WasmError :: fn network(msg : impl Into <String>) -> Self`
`WasmError :: fn serialization(msg : impl Into <String>) -> Self`
`WasmError :: fn not_found(entity_type : impl Into <String>, entity_id : impl Into <String>) -> Self`
`WasmError :: fn server_error(status : u16, message : impl Into <String>) -> Self`
`WasmError :: fn is_retryable(& self) -> bool`
`WasmError :: fn requires_auth(& self) -> bool`
`WasmError :: fn from(err : serde_json::Error) -> Self`
`WasmError :: fn from(err : gloo_storage::errors::StorageError) -> Self`
`WasmError :: fn from(err : gloo_net::Error) -> Self`

`WasmResult`

Error types for WASM client operations.

Item
`pub type WasmResult<T>: Result <T, WasmError>`

`OutboxManager`

Outbox queue manager for pending commands.

Item
`pub struct OutboxManager<S : KeyValueStore>`

`OutboxManager<S>:all`

Outbox queue manager for pending commands.

Item
`OutboxManager<S> :: fn all_pending(& self) -> Vec <& OutboxEntry>`

`OutboxManager<S>:clear`

Outbox queue manager for pending commands.

Item
`OutboxManager<S> :: async fn clear_synced(& mut self) -> WasmResult <usize>`

`OutboxManager<S>:conflicted`

Outbox queue manager for pending commands.

Item
`OutboxManager<S> :: fn conflicted(& self) -> Vec <& OutboxEntry>`

`OutboxManager<S>:discard`

Outbox queue manager for pending commands.

Item
`OutboxManager<S> :: async fn discard(& mut self, entry_id : Uuid) -> WasmResult <()>`

`OutboxManager<S>:failed`

Outbox queue manager for pending commands.

Item
`OutboxManager<S> :: fn failed(& self) -> Vec <& OutboxEntry>`

`OutboxManager<S>:get`

Outbox queue manager for pending commands.

Item
`OutboxManager<S> :: fn get(& self, entry_id : Uuid) -> Option <& OutboxEntry>`

`OutboxManager<S>:handle`

Outbox queue manager for pending commands.

Item
`OutboxManager<S> :: async fn handle_ack(& mut self, entry_id : Uuid, ack : & ServerAck) -> WasmResult <()>`

`OutboxManager<S>:is`

Outbox queue manager for pending commands.

Item
`OutboxManager<S> :: fn is_empty(& self) -> bool`

`OutboxManager<S>:len`

Outbox queue manager for pending commands.

Item
`OutboxManager<S> :: fn len(& self) -> usize`

`OutboxManager<S>:mark`

Outbox queue manager for pending commands.

Item
`OutboxManager<S> :: async fn mark_syncing(& mut self, entry_id : Uuid) -> WasmResult <()>`

`OutboxManager<S>:new`

Outbox queue manager for pending commands.

Item
`OutboxManager<S> :: async fn new(store : Arc <S>) -> WasmResult <Self>`

`OutboxManager<S>:next`

Outbox queue manager for pending commands.

Item
`OutboxManager<S> :: fn next_pending(& mut self) -> Option <& mut OutboxEntry>`

`OutboxManager<S>:queue`

Outbox queue manager for pending commands.

Item
`OutboxManager<S> :: async fn queue(& mut self, command : Command) -> WasmResult <OutboxEntry>`

`OutboxManager<S>:remove`

Outbox queue manager for pending commands.

Item
`OutboxManager<S> :: async fn remove_synced(& mut self, entry_id : Uuid) -> WasmResult <()>`

`OutboxManager<S>:retry`

Outbox queue manager for pending commands.

Item
`OutboxManager<S> :: async fn retry(& mut self, entry_id : Uuid) -> WasmResult <()>`

`OutboxManager<S>:stats`

Outbox queue manager for pending commands.

Item
`OutboxManager<S> :: fn stats(& self) -> OutboxStats`