I've been testing RSPC in a Next.js project and thought I could add an example based on it. Also did some extra changes I thought made sense. Let me know if you want any of them reverted.

Summary:

• Made Axum example file into an actual project that can be run by Cargo (bindings output to /examples/bindings.ts)
• Moved Astro (packages/example) into /examples/astro
• Added Next.js example to /examples/nextjs

I'm not fully sure if the changes made to Cargo.toml in root are correct, so please check that.

Fixes issue https://github.com/oscartbeaumont/rspc/issues/43

I was using sqlx with MySQL through RSPC. The database is connected successfully, however there are some types that are not currently supported for example chrono::NaiveDate, bigdecimal::BigDecimal. A list of what sqlx maps SQL types into rust types can be found here.

As a workaround, I could get it working by creating another struct and manually mapping the values into the values I need, see following:

// this struct contains the results fetched from db
#[derive(Debug, Serialize)]
struct ExpenseQueryResult {
    id: i32,
    name: String,
    amount: BigDecimal,
    date: chrono::NaiveDate,
    category: String,
    comment: Option<String>,
    tags: Option<String>,
}

// this is an additional struct for mapping unsupported values into supported values
#[derive(Debug)]
struct ListExpensesResponse {
    id: i32,
    name: String,
    amount: f64,
    date: String,
    category: String,
    comment: Option<String>,
    tags: Option<String>,
}

// my router definition
let router = rspc::Router::<Ctx>::new()
    .config(Config::new().export_ts_bindings("../generated/bindings.ts"))
    .query("listExpenses", |ctx: Ctx, _: ()| async move {
        let expenses: Vec<ExpenseQueryResult> = sqlx::query_as!(
            ExpenseQueryResult,
            r#"
select
    e. `id`,
    e. `name`,
    e. `amount`,
    e. `date`,
    ec. `name` as `category`,
    e. `comment`,
    group_concat(t. `name` separator ', ') as `tags`
from
    `expenses` e
    inner join `expenses_categories` ec on e. `expenses_categories_id` = ec. `id`
    left join `tags_expenses` te on e. `id` = te. `expenses_id`
    left join `tags` t on t. `id` = te. `tags_id`
group by
    e. `id`,
    e. `name`,
    e. `amount`,
    e. `date`,
    ec. `name`,
    e. `comment`
order by
    e. `date` desc;
        "#,
        )
        .fetch_all(&ctx.pool)
        .await
        .unwrap();

        selection!(
            expenses
                .into_iter()
                .map(|e| {
                    ListExpensesResponse {
                        id: e.id,
                        name: e.name,
                        amount: e.amount.to_f64().unwrap_or(-1.0),
                        date: e.date.to_string(),
                        category: e.category,
                        comment: e.comment,
                        tags: e.tags,
                    }
                })
                .collect::<Vec<ListExpensesResponse>>(),
            [{ id, name, amount, date, category, comment, tags }]
        )
    })
    .build()
    .arced();

So this code above is working well and fine and produce the following JSON response:

[
	{
		"type": "response",
		"id": null,
		"result": [
			{
				"amount": 118.00,
				"category": "Tithe",
				"comment": "Any comments",
				"date": "2022-08-06",
				"id": 4,
				"name": "August Tithe",
				"tags": "Touch n' Go"
			}
		]
	}
]

However, since I'm learning Rust and wanted to try making chrono::NaiveDate and bigdecimal::BigDecimal works by implementing the rspc::internal::specta::Type trait for it.

The following shows my implementation

#[derive(Debug, Serialize)]
struct SpectaCompatibleNaiveDate(chrono::NaiveDate);

impl From<chrono::NaiveDate> for SpectaCompatibleNaiveDate {
    fn from(date: chrono::NaiveDate) -> Self {
        Self(date)
    }
}

impl rspc::internal::specta::Type for SpectaCompatibleNaiveDate {
    const NAME: &'static str = "NaiveDate";

    fn inline(
        _: rspc::internal::specta::DefOpts,
        _: &[rspc::internal::specta::DataType],
    ) -> rspc::internal::specta::DataType {
        rspc::internal::specta::DataType::Primitive(rspc::internal::specta::PrimitiveType::String)
    }

    fn reference(
        _: rspc::internal::specta::DefOpts,
        _: &[rspc::internal::specta::DataType],
    ) -> rspc::internal::specta::DataType {
        rspc::internal::specta::DataType::Primitive(rspc::internal::specta::PrimitiveType::String)
    }

    fn definition(_: rspc::internal::specta::DefOpts) -> rspc::internal::specta::DataType {
        panic!()
    }
}

#[derive(Debug, Serialize)]
struct SpectaCompatibleBigDecimal(bigdecimal::BigDecimal);

impl From<bigdecimal::BigDecimal> for SpectaCompatibleBigDecimal {
    fn from(decimal: bigdecimal::BigDecimal) -> Self {
        Self(decimal)
    }
}

impl rspc::internal::specta::Type for SpectaCompatibleBigDecimal {
    const NAME: &'static str = "BigDecimal";

    fn inline(
        _: rspc::internal::specta::DefOpts,
        _: &[rspc::internal::specta::DataType],
    ) -> rspc::internal::specta::DataType {
        rspc::internal::specta::DataType::Primitive(rspc::internal::specta::PrimitiveType::f64)
    }

    fn reference(
        _: rspc::internal::specta::DefOpts,
        _: &[rspc::internal::specta::DataType],
    ) -> rspc::internal::specta::DataType {
        rspc::internal::specta::DataType::Primitive(rspc::internal::specta::PrimitiveType::f64)
    }

    fn definition(_: rspc::internal::specta::DefOpts) -> rspc::internal::specta::DataType {
        panic!()
    }
}

For SpectaCompatibleNaiveDate, it's working flawlessly. However for SpectaCompatibleBigDecimal, it returned String to the client instead of a number value. Here's the JSON response being returned.

[
	{
		"type": "response",
		"id": null,
		"result": [
			{
				"amount": "118.00",
				"category": "Tithe",
				"comment": "Any comments",
				"date": "2022-08-06",
				"id": 4,
				"name": "August Tithe",
				"tags": "Touch n' Go"
			}
		]
	}
]

"Per Request Context" seems to create a new context "per request", which is not what i need. In actix-web i can just create a "AppState(WebData)", and that state is shared between all requests.

A simple example with a global "request hit counter" would be appreciated.

feat: client create helper and enable editing generated file

In my project, I've create a new file to hold my client connection, but felt it was redundant, and I figured it might be simpler and consistent if everything can be in rspc's generated file. Therefore, this PR:

• Enables rspc users to edit the generated rspsc file to add thier own code (either after/before generated setion).
• Introduce createClient function and TransportKind type to simplify rspc setup.

Before

import { createClient, FetchTransport } from '@rspc/client'
import { Operations } from 'rspc'
const client = createClient<Operations>({
  transport: new FetchTransport('http://localhost:4000/rspc'),
})

After

import { createClient } from 'rspc'
export const client = createClient('fetch', 'http://localhost:4000/rspc')

We were looking into using specta in our project, but ran into the issue of needing an escape hatch for certain types that can't (easily) implement Type. This solution is similar to ts_rs's #[ts(type = "..")] attribute.

#[specta(type_as = <Ident>)] on a field overrides its type in the generated type definition with the type of the identifier.

Example:

use specta::{ts::ts_export, Type};

pub enum MyEnum {
    A,
    B,
    C,
}

#[derive(Type)]
pub struct MyCustomType {
    #[specta(type_as=String)]
    pub nested: MyEnum,
}

fn main() {
    println!("{}", ts_export::<MyCustomType>().unwrap(),);
}

Any feedback is super appreciated!

https://github.com/tauri-apps/tauri/pull/5492 which was recently merged into the dev branch has broken the tauri integration. All RPC calls fail with the following error message:

2022-10-30T11:37:47.115378Z ERROR rspc::integrations::tauri: failed to parse JSON-RPC request: invalid type: string "{\"id\":\"b8h6sjydy9l\",\"method\":\"query\",\"params\":{\"path\":\"version\"}}", expected struct Request at line 1 column 83

I tried some hacks to fix the issue on the rust and typescript sides of rspc but wasn't successful. Happy to help PR a fix with a nudge in the right direction.

Versions: tauri: dev branch rspc: v1.0.2 (also fails with main)

Hey @oscartbeaumont, so I've started experimenting with rspc.

I had odd issue, that I spent quite sometimes to try to fix it myself, but it seems most likely a bug.

server

    let config = rspc::Config::new().export_ts_bindings("../client/src/rspc");
    let router = rspc::Router::<()>::new()
        .config(config)
        .query("ping", |_, name: String| {
            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
            format!("pong {name}")
        })
        .build()
        .pipe(Arc::new);
    let addr = "[::]:4000".parse::<std::net::SocketAddr>().unwrap();
    println!("listening on http://{addr}/rspc/version?batch=1&input=%7B%7D",);

    axum::Server::bind(&addr)
        .serve(
            axum::Router::new()
                .route("/rspc/:id", router.clone().axum_handler(|| ()))
                .layer(
                    CorsLayer::new()
                        .allow_methods(Any)
                        .allow_headers(Any)
                        .allow_origin(Any),
                )
                .into_make_service(),
        )
        .await
        .unwrap();

client

const transport = new FetchTransport('http://localhost:4000/rspc')
export const client = createClient<Operations>({ transport })
const message = await client.query('ping', `${id}`)
console.log(message)
message

The above seems to send http://localhost:4000/rspc/ping?batch=1&input=32323.

the console log shows:

Unhandled Promise Rejection: TypeError: null is not an object (evaluating '(await resp.json())[0].result')

With curl I get the following error:

│Failed to deserialize query string. Expected something of type `rspc::integrations::axum::GetParams`. Error: missing field `input`[1]

When I used a number u32 type instead of string, it passes. Any ideas

If you refer to a type directly on the router (Eg. as an argument or result) it will be automatically exported when you export the router bindings however if the type your return depends on another type the dependant type will not be exported.

As a temporary workaround, you can use the ts_rs derive macros export functionality.

I can't fix this without changes to ts_rs or moving off of ts_rs due to ts_rs not storing enough information to export the dependencies of each dependency.

Hey @oscartbeaumont, I'm super excited about this library.

I believe it would be cleaner and simpler if .build() would generate the typescript definitions as side effect instead of having to call router.export("..").unwrap();

Additionally, it may be a good idea to have a default name for the exported file or dir {ts_root}/rspc/index.ts/{ts_src_root}/rspc.ts;

For that to be configurable, a method like set_export_ts_root. I'm adding ts here because maybe in the future another languages can be supported, for example I'm hoping to add lua support somehow

Normalised cache using global IDs + schema build time validate ID's are defined on all types

Problems:

• Single item
• Array of items
• Realtionships -> Eg. User with list of Pets

Identifying types and validating the keys exists on types returned from Rust

Hey just just want to let you know, I tried to install the extension, unfortunately I receive the following error.

Can't install 'oscartbeaumont.rspc-vscode' extension because it is not compatible with the current version of Visual Studio Code (version 1.67.2).

Come up with a better solution around this. Gonna be annoying because most things are multithreaded. Using the workaround in the example below is dangerous because of the unsafe traits.

#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]

use std::{ops::Deref, sync::Arc};

use rspc::Router as RspcRouter;
use worker::*;

mod utils {
    use super::*;
    use cfg_if::cfg_if;

    cfg_if! {
        // https://github.com/rustwasm/console_error_panic_hook#readme
        if #[cfg(feature = "console_error_panic_hook")] {
            extern crate console_error_panic_hook;
            pub use self::console_error_panic_hook::set_once as set_panic_hook;
        } else {
            #[inline]
            pub fn set_panic_hook() {}
        }
    }

    pub fn log_request(req: &Request) {
        console_log!(
            "{} - [{}], located at: {:?}, within: {}",
            Date::now().to_string(),
            req.path(),
            req.cf().coordinates().unwrap_or_default(),
            req.cf().region().unwrap_or_else(|| "unknown region".into())
        );
    }
}

type App = RspcRouter<UnsafeEnv, ()>;

#[derive(Clone)]
pub struct UnsafeEnv(Arc<Env>);

// TODO: Here we are just lying to Rust. I don't know if this is a safe assumption to make but it seems to be working in my quick tests.
unsafe impl Send for UnsafeEnv {}
unsafe impl Sync for UnsafeEnv {}

impl Deref for UnsafeEnv {
    type Target = Env;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

#[event(fetch)]
pub async fn main(req: Request, env: Env, _ctx: worker::Context) -> Result<Response> {
    utils::set_panic_hook();
    utils::log_request(&req);
    let env = UnsafeEnv(Arc::new(env));

    App::new()
        .query("version", |t| {
            t(move |env, _: ()| {
                env.var("WORKERS_RS_VERSION")
                    .map(|v| v.to_string())
                    .unwrap() // TODO: Remove this?
            })
        })
        .build()
        .arced()
        .endpoint(move || env)
        .workers(req)
        .await
}

got this issue when using rspc with Axum 0.6.0

mismatched types
expected struct `MethodRouter<(), _>`
   found struct `axum::routing::method_routing::MethodRouter`
perhaps two different versions of crate `axum` are being used?

Added all remaining http codes While some are not necessarily relevant for this crate i believe they don't hurt. If there is some reason why not to add some of them i am open to discussion and changes.