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

node-ts displays an error message stating, "Unable to locate the name 'DEV' (TS2304)."

Leveraging the ngFor local variable within nested elements

Using an Angular interface for an HTTP request: The statusText message reads as "Error: Unable to Determine."

Encountered an issue when attempting to include a model in sequelize-typescript

What is the best way to make one element's click event toggle the visibility of another element in Angular 4?

Type '{}' is lacking the subsequent attributes in type 'Record'

Next.js 14 useEffect firing twice upon page load

Why is it that Angular is unable to locate the component factory for my component, even though I have declared it in the entryComponents option of my Module?

Is there a way to modify the button exclusively within the div where it was pressed?

The absence of defined exports in TypeScript has presented a challenge, despite attempting various improvement methods

A Promise is automatically returned by async functions

Exploring the MVVM architecture in React and the common warning about a missing dependency in the useEffect hook

Tips for effectively generating a JSON object array in Typescript

Setting up TypeScript in Jest without the need for webpack

Transforming JavaScript code with Liquid inline(s) in Shopify to make it less readable and harder to understand

Access an external URL by logging in, then return back to the Angular application

Checking a sequence using a list of strings

What causes an interface to lose its characteristics when a property is defined using index signatures?

Struggling with importing aliases in TypeScript for shadcn-ui library

Guide to leveraging various build targets while executing the capacitor sync command within an Angular project

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

Answer №1

Similar questions

node-ts displays an error message stating, "Unable to locate the name '__DEV__' (TS2304)."

Leveraging the ngFor local variable within nested elements

Using an Angular interface for an HTTP request: The statusText message reads as "Error: Unable to Determine."

Encountered an issue when attempting to include a model in sequelize-typescript

What is the best way to make one element's click event toggle the visibility of another element in Angular 4?

Type '{}' is lacking the subsequent attributes in type 'Record'

Next.js 14 useEffect firing twice upon page load

Why is it that Angular is unable to locate the component factory for my component, even though I have declared it in the entryComponents option of my Module?

Is there a way to modify the button exclusively within the div where it was pressed?

The absence of defined exports in TypeScript has presented a challenge, despite attempting various improvement methods

A Promise is automatically returned by async functions

Exploring the MVVM architecture in React and the common warning about a missing dependency in the useEffect hook

Tips for effectively generating a JSON object array in Typescript

Setting up TypeScript in Jest without the need for webpack

Transforming JavaScript code with Liquid inline(s) in Shopify to make it less readable and harder to understand

Access an external URL by logging in, then return back to the Angular application

Checking a sequence using a list of strings

What causes an interface to lose its characteristics when a property is defined using index signatures?

Struggling with importing aliases in TypeScript for shadcn-ui library

Guide to leveraging various build targets while executing the capacitor sync command within an Angular project

node-ts displays an error message stating, "Unable to locate the name 'DEV' (TS2304)."