io-ts Partial records

gistfile1.txt

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

export const StandardCodec = t.type({ fields: t.string });
export type Standard = t.TypeOf<typeof StandardCodec>;

// export const OriginalCodec = t.type({ original: t.string });
// export type Original = t.TypeOf<typeof OriginalCodec>;

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

const SupportedEnvCodec = t.keyof({ prod: null, qa: null, dev: null });
type SupportedEnv = t.TypeOf<typeof SupportedEnvCodec>;
type ProdEnv = Extract<SupportedEnv, 'prod'>;
const ProdEnvCodec: t.Type<ProdEnv> = t.literal('prod');
type OtherEnv = Exclude<SupportedEnv, 'prod'>;
const OtherEnvCodec: t.KeyofType<Record<OtherEnv, unknown>> = t.keyof({ qa: null, dev: null });


export const StrictExtendedCodec = t.intersection([
  t.record(ProdEnvCodec, StandardCodec),
  t.record(OtherEnvCodec, StandardCodec)]);
export type StrictExtended = t.TypeOf<typeof StrictExtendedCodec>;


const LooseExtendedCodec = partialRecord<OtherEnv, typeof StandardCodec>(
  OtherEnvCodec, StandardCodec,
);

export const ExtendedCodec = t.intersection([
  t.record(ProdEnvCodec, StandardCodec),
  LooseExtendedCodec]);
export type Extended = t.TypeOf<typeof ExtendedCodec>;


// Errors
const strict: StrictExtended = {
  prod: {fields: ''},
  dev: {fields: ''},
};

// Compiles
const loose: Extended = {
  prod: {
    fields: '',
  },
};