envalid

Variables

• bool
• email
• host
• json
• num
• port
• str
• url

Functions

• accessorMiddleware()
• applyDefaultMiddleware()
• cleanEnv()
• customCleanEnv()
• defaultReporter()
• envalidErrorFormatter()
• makeExactValidator()
• makeValidator()
• strictProxyMiddleware()
• testOnly()

Classes

• EnvError
• EnvMissingError

Interfaces

• BaseValidator
• CleanedEnvAccessors

  • isDev
  • isDevelopment
  • isProd
  • isProduction
  • isTest
• CleanOptions

  • reporter
• ExactValidator
• ReporterOptions

  • env
  • errors
• Spec

  • choices
  • default
  • desc
  • devDefault
  • docs
  • example
• StrictProxyMiddlewareOptions

  • extraInspectables
• StructuredValidator

Type Aliases

• CleanedEnv
• OptionalValidatorSpec
• RequiredValidatorSpec
• SpecsOutput
• ValidatorSpec

variable bool

const bool: ExactValidator<boolean>;

variable email

const email: BaseValidator<string>;

variable host

const host: BaseValidator<string>;

variable json

const json: StructuredValidator;

• Unless passing a default property, it's recommended that you provide an explicit type parameter for json validation if you're using TypeScript. Otherwise the output will be typed as any. For example:

  cleanEnv({
    MY_VAR: json<{ foo: number }>(),
  })

variable num

const num: BaseValidator<number>;

variable port

const port: BaseValidator<number>;

variable str

const str: BaseValidator<string>;

variable url

const url: BaseValidator<string>;

function accessorMiddleware

accessorMiddleware: <T>(envObj: T, rawEnv: unknown) => T & CleanedEnvAccessors;

function applyDefaultMiddleware

applyDefaultMiddleware: <T>(
    cleanedEnv: T,
    rawEnv: unknown
) => T & CleanedEnvAccessors;

function cleanEnv

cleanEnv: <S>(
    environment: unknown,
    specs: S,
    options?: CleanOptions<S>
) => CleanedEnv<S>;

• Returns a sanitized, immutable environment object. _Only_ the env vars specified in the validators parameter will be accessible on the returned object.

  Parameter environment

  An object containing your env vars (eg. process.env).

  Parameter specs

  An object that specifies the format of required vars.

  Parameter options

  An object that specifies options for cleanEnv.

function customCleanEnv

customCleanEnv: <S, MW>(
    environment: unknown,
    specs: S,
    applyMiddleware: (cleaned: CleanedEnv<S>, rawEnv: unknown) => MW,
    options?: CleanOptions<S>
) => Readonly<MW>;

• Returns a sanitized, immutable environment object, and passes it through a custom applyMiddleware function before being frozen. Most users won't need the flexibility of custom middleware; prefer cleanEnv() unless you're sure you need it

  Parameter environment

  An object containing your env vars (eg. process.env).

  Parameter specs

  An object that specifies the format of required vars.

  Parameter applyMiddleware

  A function that applies transformations to the cleaned env object

  Parameter options

  An object that specifies options for cleanEnv.

function defaultReporter

defaultReporter: <T = any>(
    { errors }: ReporterOptions<T>,
    { onError, logger }?: ExtraOptions<T>
) => void;

function envalidErrorFormatter

envalidErrorFormatter: <T = any>(
    errors: Partial<Record<keyof T, Error>>,
    logger?: Logger
) => void;

function makeExactValidator

makeExactValidator: <T>(parseFn: (input: string) => T) => ExactValidator<T>;

• Creates a validator which output type is exactly T:

  const int = makeExactValidator<number>((input: string) => {
    // Implementation details
  })
  const MAX_RETRIES = int({ choices: [1, 2, 3, 4] })
  // Output type 'number'

  Parameter parseFn

  A function to parse and validate input.

  Returns

  A validator which output type is exactly T

function makeValidator

makeValidator: <BaseT>(
    parseFn: (input: string) => BaseT
) => BaseValidator<BaseT>;

• Creates a validator which can output subtypes of BaseT. E.g.:

  const int = makeValidator<number>((input: string) => {
    // Implementation details
  })
  const MAX_RETRIES = int({ choices: [1, 2, 3, 4] })
  // Narrows down output type to 1 | 2 | 3 | 4

  Parameter parseFn

  A function to parse and validate input.

  Returns

  A validator which output type is narrowed-down to a subtype of BaseT

function strictProxyMiddleware

strictProxyMiddleware: <T extends object>(
    envObj: T,
    rawEnv: unknown,
    options?: StrictProxyMiddlewareOptions
) => T;

function testOnly

testOnly: <T>(defaultValueForTests: T) => T;

• Utility function for providing default values only when NODE_ENV=test

  For more context, see https://github.com/af/envalid/issues/32

type CleanedEnv

type CleanedEnv<S> = S extends Record<string, ValidatorSpec<unknown>>
    ? Readonly<
          {
              [K in keyof S]: S[K] extends OptionalValidatorSpec<infer U>
                  ? U | undefined
                  : S[K] extends RequiredValidatorSpec<infer U>
                  ? U
                  : never;
          } & CleanedEnvAccessors
      >
    : never;

type OptionalValidatorSpec

type OptionalValidatorSpec<T> = OptionalSpec<T> & WithParser<T>;

type RequiredValidatorSpec

type RequiredValidatorSpec<T> = RequiredSpec<T> & WithParser<T>;

type SpecsOutput

type SpecsOutput<S> = {
    [K in keyof S]: unknown;
};

type ValidatorSpec

type ValidatorSpec<T> = RequiredValidatorSpec<T> | OptionalValidatorSpec<T>;