Normalize Dioxus signal API and improve SQL migration parsing

Author: isala404

crates/forge-codegen/src/dioxus/mod.rs

@@ -45,10 +45,10 @@ pub use api::*;
 pub use forge_dioxus::{
     ConnectionState, ForgeAuth, ForgeAuthProvider, ForgeClient, ForgeClientConfig,
     ForgeClientError, ForgeError, ForgeProvider, ForgeUpload, JobExecutionState, Mutation,
-    QueryState, SubscriptionHandle, SubscriptionState, TokenPair, WorkflowExecutionState,
+    QueryState, SignalError, SubscriptionHandle, SubscriptionState, TokenPair, WorkflowExecutionState,
     use_auth_key, use_connection_state, use_forge_auth, use_forge_client, use_forge_job,
     use_forge_mutation, use_forge_query, use_forge_subscription, use_forge_workflow,
-    use_require_auth, use_viewer,
+    use_viewer,
 };
 pub use types::*;
 "#

crates/forge-codegen/src/emit.rs

@@ -69,6 +69,15 @@ fn ts_custom(name: &str, pos: Position) -> String {
             Position::Arg => "Uint8Array".into(),
         },
 
+        "Uuid" | "uuid::Uuid" | "DateTime<Utc>" | "NaiveDate" | "NaiveDateTime" | "Instant"
+        | "LocalDate" | "LocalTime" | "Timestamp" => "string".into(),
+
+        "i32" | "i64" | "u32" | "u64" | "f32" | "f64" | "usize" | "isize" => "number".into(),
+
+        "bool" => "boolean".into(),
+
+        "Value" | "serde_json::Value" => "unknown".into(),
+
         // Unparsed generic types that leaked through as Custom.
         _ if name.starts_with("Vec<") => {
             let inner = name
@@ -90,7 +99,7 @@ fn ts_custom(name: &str, pos: Position) -> String {
                 .and_then(|s| s.strip_suffix('>'))
                 .unwrap_or("unknown");
             format!(
-                "{{ items: {}[], page_info: PageInfo }}",
+                "Page<{}>",
                 ts_type(&RustType::Custom(inner.to_string()), pos)
             )
         }
@@ -152,6 +161,11 @@ fn dioxus_custom(name: &str) -> String {
         "Uuid" | "uuid::Uuid" => "String".into(),
         "DateTime<Utc>" | "NaiveDate" | "NaiveDateTime" | "Instant" | "LocalDate" | "LocalTime"
         | "Timestamp" => "String".into(),
+        "i32" | "u32" | "usize" | "isize" => "i64".into(),
+        "i64" | "u64" => "i64".into(),
+        "f32" => "f32".into(),
+        "f64" => "f64".into(),
+        "bool" => "bool".into(),
         "Value" | "serde_json::Value" => "JsonValue".into(),
         "Bytes" => "Vec<u8>".into(),
         "Upload" => "ForgeUpload".into(),
@@ -376,7 +390,7 @@ mod tests {
         );
         assert_eq!(
             ts_type(&RustType::Custom("Page<User>".into()), Position::Arg),
-            "{ items: User[], page_info: PageInfo }"
+            "Page<User>"
         );
         assert_eq!(dioxus_type(&RustType::Custom("Cursor".into())), "String");
         assert_eq!(

crates/forge-codegen/src/typescript/mod.rs

@@ -72,8 +72,8 @@ export function toReactiveMutation<TArgs, TResult>(
       } catch (e) {
         const err =
           e instanceof ForgeClientError
-            ? { code: e.code, message: e.message, details: e.details }
-            : { code: "UNKNOWN", message: String(e) };
+            ? e
+            : new ForgeClientError("UNKNOWN", String(e));
         state.error = err;
         throw e;
       } finally {

crates/forge-codegen/src/typescript/types.rs

@@ -56,6 +56,10 @@ pub fn generate(registry: &SchemaRegistry, referenced_types: &[String]) -> Resul
         output.push_str("}\n\n");
     }
 
+    output.push_str(
+        "export type Cursor = string;\n\nexport interface PageInfo {\n  has_next_page: boolean;\n  end_cursor?: Cursor;\n  total_count?: number;\n}\n\nexport interface Page<T> {\n  items: T[];\n  page_info: PageInfo;\n}\n\n",
+    );
+
     // Emit built-in types that are referenced by API bindings but not in the registry.
     for (name, definition) in BUILTIN_TYPES {
         if !defined_names.contains(*name) && referenced_types.iter().any(|t| t.as_str() == *name) {

crates/forge-macros/src/utils.rs

@@ -410,6 +410,7 @@ pub fn is_primitive_arg_type(ty: &syn::Type) -> bool {
             | "BTreeMap"
             | "HashSet"
             | "BTreeSet"
+            | "Uuid"
     )
 }
 

crates/forge-runtime/src/migrations/runner.rs

@@ -476,48 +476,108 @@ fn split_sql_statements(sql: &str) -> Vec<String> {
     let mut current = String::new();
     let mut in_dollar_quote = false;
     let mut dollar_tag = String::new();
+    let mut in_line_comment = false;
+    let mut in_block_comment = false;
+    let mut in_string_literal = false;
     let mut chars = sql.chars().peekable();
 
     while let Some(c) = chars.next() {
         current.push(c);
 
-        // Check for dollar-quoting start/end
+        if in_line_comment {
+            if c == '\n' {
+                in_line_comment = false;
+            }
+            continue;
+        }
+
+        if in_block_comment {
+            if c == '*' && chars.peek() == Some(&'/') {
+                current.push(chars.next().expect("peeked char"));
+                in_block_comment = false;
+            }
+            continue;
+        }
+
+        if in_string_literal {
+            if c == '\'' {
+                if chars.peek() == Some(&'\'') {
+                    current.push(chars.next().expect("peeked char"));
+                } else {
+                    in_string_literal = false;
+                }
+            }
+            continue;
+        }
+
+        if in_dollar_quote {
+            if c == '$' {
+                let mut potential_tag = String::from("$");
+                while let Some(&next_c) = chars.peek() {
+                    if next_c == '$' {
+                        potential_tag.push(chars.next().expect("peeked char"));
+                        current.push('$');
+                        break;
+                    } else if next_c.is_alphanumeric() || next_c == '_' {
+                        let ch = chars.next().expect("peeked char");
+                        potential_tag.push(ch);
+                        current.push(ch);
+                    } else {
+                        break;
+                    }
+                }
+                if potential_tag.len() >= 2
+                    && potential_tag.ends_with('$')
+                    && potential_tag == dollar_tag
+                {
+                    in_dollar_quote = false;
+                    dollar_tag.clear();
+                }
+            }
+            continue;
+        }
+
+        // Outside all quoted/comment contexts
+        if c == '-' && chars.peek() == Some(&'-') {
+            current.push(chars.next().expect("peeked char"));
+            in_line_comment = true;
+            continue;
+        }
+
+        if c == '/' && chars.peek() == Some(&'*') {
+            current.push(chars.next().expect("peeked char"));
+            in_block_comment = true;
+            continue;
+        }
+
+        if c == '\'' {
+            in_string_literal = true;
+            continue;
+        }
+
         if c == '$' {
-            // Look for a dollar-quote tag like $$ or $tag$
             let mut potential_tag = String::from("$");
-
-            // Collect characters until we hit another $ or non-identifier char
             while let Some(&next_c) = chars.peek() {
                 if next_c == '$' {
-                    // Safe: peek confirmed the char exists
                     potential_tag.push(chars.next().expect("peeked char"));
                     current.push('$');
                     break;
                 } else if next_c.is_alphanumeric() || next_c == '_' {
-                    let c = chars.next().expect("peeked char");
-                    potential_tag.push(c);
-                    current.push(c);
+                    let ch = chars.next().expect("peeked char");
+                    potential_tag.push(ch);
+                    current.push(ch);
                 } else {
                     break;
                 }
             }
-
-            // Check if this is a valid dollar-quote delimiter (ends with $)
             if potential_tag.len() >= 2 && potential_tag.ends_with('$') {
-                if in_dollar_quote && potential_tag == dollar_tag {
-                    // End of dollar-quoted string
-                    in_dollar_quote = false;
-                    dollar_tag.clear();
-                } else if !in_dollar_quote {
-                    // Start of dollar-quoted string
-                    in_dollar_quote = true;
-                    dollar_tag = potential_tag;
-                }
+                in_dollar_quote = true;
+                dollar_tag = potential_tag;
             }
+            continue;
         }
 
-        // Split on semicolon only if not inside a dollar-quoted string
-        if c == ';' && !in_dollar_quote {
+        if c == ';' {
             let stmt = current.trim().trim_end_matches(';').trim().to_string();
             if !stmt.is_empty() {
                 statements.push(stmt);
@@ -526,7 +586,6 @@ fn split_sql_statements(sql: &str) -> Vec<String> {
         }
     }
 
-    // Don't forget the last statement (might not end with ;)
     let stmt = current.trim().trim_end_matches(';').trim().to_string();
     if !stmt.is_empty() {
         statements.push(stmt);

crates/forge/src/cli/frontend_codegen.rs

@@ -85,6 +85,19 @@ fn generate_types(output_dir: &Path, force: bool) -> Result<()> {
 
 // Common types (re-exported from @forge-rs/svelte for convenience)
 export type { ForgeError, QueryResult, SubscriptionResult } from "@forge-rs/svelte";
+
+export type Cursor = string;
+
+export interface PageInfo {
+  has_next_page: boolean;
+  end_cursor?: Cursor;
+  total_count?: number;
+}
+
+export interface Page<T> {
+  items: T[];
+  page_info: PageInfo;
+}
 "#;
 
     fs::write(file_path, content)?;

docs/docs/connect/generated-client.mdx

@@ -140,6 +140,8 @@ Inside the provider tree, use these hooks:
 | `Vec<T>`                   | `T[]`               |
 | `HashMap<K, V>`            | `Record<string, V>` |
 | `Value` (JSON)             | `unknown`           |
+| `Page<T>`                  | `Page<T>`           |
+| `Cursor`                   | `string`            |
 | `Upload`                   | `File \| Blob`      |
 | `Bytes` (return)           | `Blob`              |
 | `Bytes` (arg)              | `Uint8Array`        |
@@ -155,6 +157,7 @@ Inside the provider tree, use these hooks:
 | `bool`                     | `bool`                  |
 | `Option<T>`                | `Option<T>`             |
 | `Vec<T>`                   | `Vec<T>`                |
+| `Page<T>`                  | `forge_core::Page<T>`   |
 | `Upload`                   | `ForgeUpload`           |
 | `serde_json::Value`        | `JsonValue`             |
 | `Bytes`                    | `Vec<u8>`               |

docs/docs/reference/errors.mdx

@@ -46,7 +46,7 @@ Err(ForgeError::NotFound("User not found".to_string()))
 | `limit` | `u32` | Configured request limit |
 | `remaining` | `u32` | Tokens remaining (0 when exceeded) |
 
-The HTTP response serializes only `retry_after_secs` in the `details` object. The `limit` and `remaining` fields are available in Rust but not included in the JSON response.
+The HTTP response serializes only top-level `retry_after_secs`. The Svelte client exposes it as `retryAfterSecs`; Dioxus keeps the Rust field name `retry_after_secs`. The `limit` and `remaining` fields are available in Rust but not included in the JSON response.
 
 ## HTTP Response Format
 
@@ -86,7 +86,11 @@ Generated client includes error types:
 export interface ForgeError {
   code: string;
   message: string;
+  retryAfterSecs?: number;
   details?: unknown;
+  isRateLimited(): boolean;
+  isUnauthorized(): boolean;
+  isValidation(): boolean;
 }
 ```
 
@@ -309,8 +313,8 @@ Handle on the frontend:
 try {
   await expensiveQuery();
 } catch (e) {
-  if (e instanceof ForgeClientError && e.code === 'RATE_LIMITED') {
-    const retryAfter = e.details?.retry_after_secs ?? 60;
+  if (e instanceof ForgeClientError && e.isRateLimited()) {
+    const retryAfter = e.retryAfterSecs ?? 60;
     showMessage(`Rate limited. Try again in ${retryAfter} seconds`);
   }
 }
@@ -412,7 +416,7 @@ onAuthError: (error) => {
 
 ```typescript
 if (error.code === 'RATE_LIMITED') {
-  await sleep(error.details.retry_after_secs * 1000);
+  await sleep((error.retryAfterSecs ?? 1) * 1000);
   return retry();
 }
 ```

docs/docs/ship/signals.mdx

@@ -22,10 +22,10 @@ signals.captureError(new Error('Something broke'), { component: 'Cart' });
 // Dioxus — accessed anywhere inside ForgeProvider
 let signals = use_signals();
 
-signals.track("button_clicked", json!({"button_id": "signup"}));
+signals.track_with_properties("button_clicked", json!({"button_id": "signup"}));
 signals.identify("user-uuid", json!({"plan": "pro"})).await;
 signals.breadcrumb("Added item to cart", Some(json!({"item_id": "123"})));
-signals.capture_error("Something broke", json!({"component": "Cart"})).await;
+signals.capture_error("Something broke", Some(json!({"component": "Cart"})));
 ```
 
 ## What Happens
@@ -34,7 +34,7 @@ Forge captures analytics at two levels that get correlated automatically.
 
 **Server-side auto-capture**: The function executor records every RPC call with its name, kind (query/mutation), duration, success/failure status, and the caller's identity. Jobs, crons, workflows, webhooks, and daemon runs emit `server_execution` events with the same shape. Auth failures and rate-limit rejections emit `track` events (`auth.failed`, `rate_limit.exceeded`) so dashboards surface attack patterns. All of this happens inside the framework, so your handler code stays clean.
 
-**Client-side tracking**: The `ForgeSignals` class (Svelte) or `use_signals()` hook (Dioxus) runs in the browser and captures page views on SPA navigation, frontend errors (window.onerror, unhandled rejections), Web Vitals (LCP, CLS, INP, FCP, TTFB, navigation timing, long tasks), network online/offline transitions, and any custom events you send with `track()`. Events are batched locally, persisted to `localStorage` so they survive page reloads, and flushed to the server periodically, when the batch fills up, on `visibilitychange`/`pagehide`, or when the network returns after being offline.
+**Client-side tracking**: The `ForgeSignals` class (Svelte) runs in the browser. The `use_signals()` hook (Dioxus) works across web, desktop, and mobile; browser-only auto-capture such as Web Vitals and `window.onerror` is enabled only on `wasm32`. Custom events and error reports work on every Dioxus target. Events are batched locally, persisted where platform storage is available, and flushed to the server periodically or when the batch fills up.
 
 **Correlation**: Every client-initiated RPC call includes an `x-correlation-id` header. This ID links the frontend event (user clicked a button) to the backend execution (the mutation that ran). Error reports include the last correlation ID and a trail of breadcrumbs for reproduction.
 
@@ -130,6 +130,11 @@ Record a custom event with arbitrary properties.
 signals.track('subscription_upgraded', { from: 'free', to: 'pro' });
 ```
 
+```rust
+signals.track("subscription_upgraded");
+signals.track_with_properties("subscription_upgraded", json!({"from": "free", "to": "pro"}));
+```
+
 ### identify(userId, traits)
 
 Link the current anonymous session to a known user. Call this after login. Traits are stored as JSONB in the `forge_signals_users` table.
@@ -154,6 +159,10 @@ Report a frontend error with optional context. Auto-captured errors go through t
 signals.captureError(new Error('Payment failed'), { orderId: '123' });
 ```
 
+```rust
+signals.capture_error("Payment failed", Some(json!({"order_id": "123"})));
+```
+
 ### page()
 
 Manually record a page view. Usually not needed since auto page views track SPA navigation.