Welcome to Software Development on Codidact!

Will you help us build our independent community of developers helping developers? We're small and trying to grow. We welcome questions about all aspects of software development, from design to code to QA and more. Got questions? Got answers? Got code you'd like someone to review? Please join us.

Post History

66%

+2 −0

Q&A How do I share a type between a client and server, but make a specific field optional for one and required for the other?

The existing answer is fine, but you can achieve similar results in many ways using some of TypeScript's utility types. Required<T> While you cannot use (only) Partial to do this, TypeScrip...

posted 7mo ago by Jacob Raihle‭ · edited 7mo ago by Jacob Raihle‭

Answer

#2: Post edited by

Jacob Raihle‭ · 2024-05-09T14:15:16Z (7 months ago)

Copy Link

Raw

Markdown

The existing answer is fine, but you can achieve similar results in many ways using some of [TypeScript's utility types](https://www.typescriptlang.org/docs/handbook/utility-types.html).
### `Required<T>`
While you cannot use (only) `Partial` to do this, TypeScript provides the opposite `Required` as well - so if one of your types requires all properties, you can start by defining the one with some optional ones:
```typescript
type UserForClients = {
name: string;
superSecretGovernmentIdNumber?: string;
};
type UserForServers = Required<UserForClients>;
```
### `Partial<T>` and (`Omit<T, K>` or `Pick<T, K>`)
Going in the other direction, starting with a "base" type and making some properties optional. `Partial` makes everything optional, but by combining it with parts of the base type that still require some properties, we can "cancel" the optionality:
```typescript
type UserForServers = {
name: string;
superSecretGovernmentIdNumber: string;
};
type UserForClients = Partial<UserForServers> & Omit<UserForServers, "superSecretGovernmentIdNumber">;
// Or, equivalently
type UserForClients = Partial<UserForServers> & Pick<UserForServers, "name">;
```
### Custom Utility types
We can create some utility types of our own to handle these cases if they are frequent:
```typescript
type WithOptional<T, K extends keyof T> = Partial<T> & Omit<T, K>;
type UserForServer = {
name: string;
superSecretGovernmentIdNumber: string;
};
type UserForClient = WithOptional<UserForServer, "superSecretGovermentIdNumber">;
// Or, equivalently
type WithRequired<T, K extends keyof T> = T & Required<Pick<T, K>>;
type UserForClient = {
name: string;
superSecretGovernmentIdNumber?: string;
};
type UserForServer = WithRequired<UserForClient, "superSecretGovernmentIdNumber">;
```

The existing answer is fine, but you can achieve similar results in many ways using some of [TypeScript's utility types](https://www.typescriptlang.org/docs/handbook/utility-types.html).
### `Required<T>`
While you cannot use (only) `Partial` to do this, TypeScript provides the opposite `Required` as well - so if one of your types requires all properties, you can start by defining the one with some optional ones:
```typescript
type UserForClients = {
name: string;
superSecretGovernmentIdNumber?: string;
};
type UserForServers = Required<UserForClients>;
```
### `Partial<T>` and (`Omit<T, K>` or `Pick<T, K>`)
Going in the other direction, starting with a "base" type and making some properties optional. `Partial` makes everything optional, but by combining it with parts of the base type that still require some properties, we can "cancel" the optionality:
```typescript
type UserForServers = {
name: string;
superSecretGovernmentIdNumber: string;
};
type UserForClients = Partial<UserForServers> & Omit<UserForServers, "superSecretGovernmentIdNumber">;
// Or, equivalently
type UserForClients = Partial<UserForServers> & Pick<UserForServers, "name">;
```
### Custom Utility types
We can create some utility types of our own to handle these cases if they are frequent:
```typescript
type WithOptional<T, K extends keyof T> = Partial<T> & Omit<T, K>;
type UserForServer = {
name: string;
superSecretGovernmentIdNumber: string;
};
type UserForClient = WithOptional<UserForServer, "superSecretGovermentIdNumber">;
// Or, equivalently
type RequireOnly<T, K extends keyof T> = Partial<T> & Required<Pick<T, K>>;
type UserForServer = {
name: string;
superSecretGovernmentIdNumber: string;
};
type UserForClient = RequireOnly<UserForServer, "name">;
// Or, equivalently
type WithRequired<T, K extends keyof T> = T & Required<Pick<T, K>>;
type UserForClient = {
name: string;
superSecretGovernmentIdNumber?: string;
};
type UserForServer = WithRequired<UserForClient, "superSecretGovernmentIdNumber">;
```

#1: Initial revision by

Jacob Raihle‭ · 2024-05-09T14:10:26Z (7 months ago)

Copy Link

Raw

Markdown

The existing answer is fine, but you can achieve similar results in many ways using some of [TypeScript's utility types](https://www.typescriptlang.org/docs/handbook/utility-types.html).

### `Required<T>`

While you cannot use (only) `Partial` to do this, TypeScript provides the opposite `Required` as well - so if one of your types requires all properties, you can start by defining the one with some optional ones:

```typescript
type UserForClients = {
   name: string;
   superSecretGovernmentIdNumber?: string;
};

type UserForServers = Required<UserForClients>;
```

### `Partial<T>` and (`Omit<T, K>` or `Pick<T, K>`)
Going in the other direction, starting with a "base" type and making some properties optional. `Partial` makes everything optional, but by combining it with parts of the base type that still require some properties, we can "cancel" the optionality:

```typescript
type UserForServers = {
    name: string;
    superSecretGovernmentIdNumber: string;
};

type UserForClients = Partial<UserForServers> & Omit<UserForServers, "superSecretGovernmentIdNumber">;

// Or, equivalently

type UserForClients = Partial<UserForServers> & Pick<UserForServers, "name">;
```

### Custom Utility types

We can create some utility types of our own to handle these cases if they are frequent:

```typescript
type WithOptional<T, K extends keyof T> = Partial<T> & Omit<T, K>;

type UserForServer = {
   name: string;
   superSecretGovernmentIdNumber: string;
};

type UserForClient = WithOptional<UserForServer, "superSecretGovermentIdNumber">;

// Or, equivalently

type WithRequired<T, K extends keyof T> = T & Required<Pick<T, K>>;

type UserForClient = {
    name: string;
    superSecretGovernmentIdNumber?: string;
};

type UserForServer = WithRequired<UserForClient, "superSecretGovernmentIdNumber">;
```

Communities

Post History