io-ts: Defining mandatory and optional keys within an object using a literal union

Question

io-ts: Defining mandatory and optional keys within an object using a literal union

I am currently in the process of defining a new codec using io-ts.

Once completed, I want the structure to resemble the following:

type General = unknown;
type SupportedEnv = 'required' | 'optional'

type Supported = {
  required: General;
  optional?: General;
}

(Please note that at this time, the specific form of General is not crucial)

The main objective is to generate the type based on both General and SupportedEnv.

My current implementation looks something like this:


const GeneralCodec = iots.unknown;

const SupportedEnvCodec = iots.union([
  iots.literal('required'),
  iots.literal('optional'),
]);

const SupportedCodec = iots.record(SupportedEnvCodec, GeneralCodec)

type Supported = iots.TypeOf<typeof SupportedCodec>;

The type Supported requires keys for both mandatory and optional fields:

type Supported = {
  required: General;
  optional: General;
}

Is there a way to actually make the optional field truly optional?

I have experimented with intersections and partial types...however, I am struggling with the syntax when incorporating them into iots.record.

Could this be accomplished? Should I approach this situation from a different angle?

typescript io-ts-library

Answer 1

Answer №1

Enhanced Solution

By implementing a mapping function called partialRecord (using the dependency of io-ts on fp-ts), we can achieve the desired outcome.

import { map } from 'fp-ts/Record';
import * as iots from 'io-ts';

export const partialRecord = <K extends string, T extends iots.Any>(
  k: iots.KeyofType<Record<string, unknown>>,
  type: T,
): iots.PartialC<Record<K, T>> => iots.partial(map(() => type)(k.keys));
  
const GeneralCodec = iots.unknown;

const SupportedEnvCodec = iots.keyof({
  required:null,
  optional:null,
});

type SupportedEnv = iots.TypeOf<typeof SupportedEnvCodec>;
type RequiredEnv = Extract<SupportedEnv, 'required'>;

const RequiredEnvCodec: iots.Type<RequiredEnv> = iots.literal('required');

type OtherEnvs = Exclude<SupportedEnv, RequiredEnv>;
const OtherEnvsCodec: iots.KeyofType<Record<OtherEnvs, unknown>> = iots.keyof({optional:null});

const OtherEnvsRecordCodec = partialRecord<
  OtherEnvs,
  typeof GeneralCodec
>(OtherEnvsCodec, GeneralCodec);

const SupportedCodec = iots.intersection([
  iots.record(RequiredEnvCodec, GeneralCodec),
  OtherEnvsRecordCodec,

]);

type Supported = iots.TypeOf<typeof SupportedCodec>;

The resulting type is as follows:

type Supported = {
    required: unknown;
} & {
    optional?: unknown;
}

Previously Proposed Solution

I have found that by introducing an additional layer of abstraction, I can approach the desired result, although it is not ideal.

For instance:

const GeneralCodec = iots.unknown;

const SupportedEnvCodec = iots.union([
  iots.literal('required'),
  iots.literal('optional'),
]);

type SupportedEnv = iots.TypeOf<typeof SupportedEnvCodec>;
type RequiredEnv = Extract<SupportedEnv, 'required'>;

const RequiredEnvCodec: iots.Type<RequiredEnv> = iots.literal('required');

type OtherEnvs = Exclude<SupportedEnv, RequiredEnv>;

const OtherEnvsCodec: iots.Type<OtherEnvs> = iots.union([
  iots.literal('optional'),
]);

const SupportedCodec = iots.intersection([
iots.record(RequiredEnvCodec, GeneralCodec),
iots.partial({
  env: iots.record(OtherEnvsCodec, GeneralCodec),
}),
]);

type Supported = iots.TypeOf<typeof SupportedCodec>;

This results in the type:

type Supported = {
    required: unknown;
  } & {
    env?: {
        optional: unknown;
    } | undefined;
}

Although this solution involves an extra layer, it effectively addresses the original question in a roundabout manner.

Answer 2

Enhanced Solution

By implementing a mapping function called partialRecord (using the dependency of io-ts on fp-ts), we can achieve the desired outcome.

import { map } from 'fp-ts/Record';
import * as iots from 'io-ts';

export const partialRecord = <K extends string, T extends iots.Any>(
  k: iots.KeyofType<Record<string, unknown>>,
  type: T,
): iots.PartialC<Record<K, T>> => iots.partial(map(() => type)(k.keys));
  
const GeneralCodec = iots.unknown;

const SupportedEnvCodec = iots.keyof({
  required:null,
  optional:null,
});

type SupportedEnv = iots.TypeOf<typeof SupportedEnvCodec>;
type RequiredEnv = Extract<SupportedEnv, 'required'>;

const RequiredEnvCodec: iots.Type<RequiredEnv> = iots.literal('required');

type OtherEnvs = Exclude<SupportedEnv, RequiredEnv>;
const OtherEnvsCodec: iots.KeyofType<Record<OtherEnvs, unknown>> = iots.keyof({optional:null});

const OtherEnvsRecordCodec = partialRecord<
  OtherEnvs,
  typeof GeneralCodec
>(OtherEnvsCodec, GeneralCodec);

const SupportedCodec = iots.intersection([
  iots.record(RequiredEnvCodec, GeneralCodec),
  OtherEnvsRecordCodec,

]);

type Supported = iots.TypeOf<typeof SupportedCodec>;

The resulting type is as follows:

type Supported = {
    required: unknown;
} & {
    optional?: unknown;
}

Previously Proposed Solution

I have found that by introducing an additional layer of abstraction, I can approach the desired result, although it is not ideal.

For instance:

const GeneralCodec = iots.unknown;

const SupportedEnvCodec = iots.union([
  iots.literal('required'),
  iots.literal('optional'),
]);

type SupportedEnv = iots.TypeOf<typeof SupportedEnvCodec>;
type RequiredEnv = Extract<SupportedEnv, 'required'>;

const RequiredEnvCodec: iots.Type<RequiredEnv> = iots.literal('required');

type OtherEnvs = Exclude<SupportedEnv, RequiredEnv>;

const OtherEnvsCodec: iots.Type<OtherEnvs> = iots.union([
  iots.literal('optional'),
]);

const SupportedCodec = iots.intersection([
iots.record(RequiredEnvCodec, GeneralCodec),
iots.partial({
  env: iots.record(OtherEnvsCodec, GeneralCodec),
}),
]);

type Supported = iots.TypeOf<typeof SupportedCodec>;

This results in the type:

type Supported = {
    required: unknown;
  } & {
    env?: {
        optional: unknown;
    } | undefined;
}

Although this solution involves an extra layer, it effectively addresses the original question in a roundabout manner.

io-ts: Defining mandatory and optional keys within an object using a literal union

Answer №1

Similar questions

Looking to execute a service method within an authguard service?

What is the method for referencing a subtype within an established type?

Creating a completely dynamic button in Angular 6: A step-by-step guide

The correct way to assign a value within an Angular Observable subscribe function

Tips for relocating the indicators of a react-material-ui-carousel

What are some methods for utilizing the "name" attribute within React components?

Would you like to learn how to display the value of a different component in this specific Angular 2 code and beyond

Moving SVG Module

Minimize the quantity of data points displayed along the X-axis in a highcharts graph

What causes Node.js to crash with the Headers already sent Error while managing errors in Express?

The static side of the class `typeof _Readable` is erroneously extending the static side of the base class `typeof Readable`

Upon hovering, icons for each project name are displayed when `mouseenter` event is triggered

Customize the element of the root node of a MUI component using the styled()

What is the best way to dynamically implement text ellipsis using CSS in conjunction with Angular 7?

Experimenting with TypeScript code using namespaces through jest (ts-jest) testing framework

Unraveling the Mystery of @Input and @Output Aliases in Angular 2

The react-bootstrap module does not have any members available for export

Encountered Runtime Issue of TypeError: undefined cannot be iterated (unable to access property Symbol(Symbol.iterator))

Creating an enum in TypeScript can be accomplished by using the enum

Developing a Universal Type in Typescript