Remote functions with generic type parameters

[hgiesel]

Let's say I have users, which have different roles, like a free user, or a premium user.

enum RoleCode {
  Free = "free",
  Premium = "premium",
}

In my system, User is indexed by its role, which allows for better type safety:

export type User<R extends RoleCode> = {
    email: string;
    name: string;
    role: R;
}

Now, I want a remote function to create such a user.

import z from "zod";

const RoleCodeSchema = z.enum(Object.values(RoleCode) as [RoleCode, ...RoleCode[]])

const CreateUserSchema = z.object({
  email: z.email(),
  name: z.string(),
  role: RoleCodeSchema,
}) satisfies z.ZodType<CreateUser>;

export const createUser = command(CreateUserSchema, /* ... */);

I have a function that uses some endpoint to add the user to some database.

const add = async <R extends RoleCode>(data: CreateUser<R>): User<R> => {  
  const user = await db.addUser(
    data.email,
    data.name,
    data.role,
  );
  return user;
}

What's great about this function is: If I add a user with a specific role, the type system allows me to guarantee that the resulting User still has that role associated.

However, when I use command, this guarantee goes out the window:

export const createUser = command(CreateUserSchema, add);
// const createUser: RemoteCommand<{
//    email: string;
//    name: string;
//    role: RoleCode;
// }, User<RoleCode>>

Is there any way to preserve this type parameter R through the remote function? Is there an open issue for it?

[vynazevedo]

The current command signature fixes one input type and one output type when the command is created. It doesn't carry the callback's generic call signature through to each invocation. In your case those become CreateUser<RoleCode> and User<RoleCode>.

I reproduced that inference with SvelteKit 2.70.3 and TypeScript 6.0.3. The relevant signature is in the command reference: the schema determines the input, and Output is inferred once from the callback.

If you want one remote endpoint, a small wrapper in an ordinary .ts module can restore the relationship for callers, with a runtime check instead of a blind cast:

// users.ts — ordinary module, not users.remote.ts
import { createUser as createUserRemote } from './users.remote';
import type { CreateUser, User, RoleCode } from './types';

export async function createUser<R extends RoleCode>(
  input: CreateUser<R>
): Promise<User<R>> {
  const user = await createUserRemote(input);
  if (user.role !== input.role) {
    throw new Error('Unexpected role in createUser response');
  }
  return { ...user, role: input.role };
}

That return expression works for the User<R> shape in your example, where role is the only field dependent on R. It wouldn't be sufficient for a richer type with additional role-specific fields; those would need validation/narrowing too. Server-side authorization must still decide which roles the caller may create.

The trade-off is that this wrapper returns a plain promise: it doesn't expose the remote command's .pending property or the returned promise's .updates(...). Keep using the underlying command for those features, or define separate commands with literal-role schemas if that better fits your API.

I type-checked both the broad result from command(schema, add) and the narrowed result from this wrapper. This was a type-level reproduction, not an end-to-end remote call. Also, the async add example should declare Promise<User<R>>, rather than User<R>, as its return type.

I searched the open issues for remote-function generics and didn't find an exact match; that isn't a guarantee none exists.