@types/convict

  • Version 6.1.1
  • Published
  • 11.2 kB
  • 1 dependency
  • MIT license

Install

npm i @types/convict
yarn add @types/convict
pnpm add @types/convict

Overview

TypeScript definitions for convict

Index

Variables

variable convict

var convict: convict;

    Interfaces

    interface Config

    interface Config<T> {}

      method default

      default: <K extends Path<T> = undefined>(
      name?: K
      ) => K extends null | undefined
      ? T
      : K extends Path<T>
      ? PathValue<T, K>
      : never;
      • Returns

        the default value of the name property. name can use dot notation to reference nested values

      method get

      get: <K extends Path<T> = undefined>(
      name?: K
      ) => K extends null | undefined
      ? T
      : K extends Path<T>
      ? PathValue<T, K>
      : never;
      • Returns

        the current value of the name property. name can use dot notation to reference nested values

      method getArgs

      getArgs: () => string[];
      • Gets the array of process arguments, using the override passed to the convict function or process.argv if no override was passed.

      method getEnv

      getEnv: () => string[];
      • Gets the environment variable map, using the override passed to the convict function or process.env if no override was passed.

      method getProperties

      getProperties: () => T;
      • Exports all the properties (that is the keys and their current values) as a {JSON} {Object}

        Returns

        A {JSON} compliant {Object}

      method getSchema

      getSchema: () => InternalSchema<T>;
      • Exports the schema as a {JSON} {Object}

        Returns

        A {JSON} compliant {Object}

      method getSchemaString

      getSchemaString: () => string;
      • Exports the schema as a JSON string.

        Returns

        A string representing the schema of this {Config}

      method has

      has: <K extends Path<T>>(name: K) => boolean;
      • Returns

        true if the property name is defined, or false otherwise

      method load

      load: <U>(conf: U) => Config<Overwrite<T, U>>;
      • Loads and merges a JavaScript object into config

      method loadFile

      loadFile: <U>(files: string | string[]) => Config<Overwrite<T, U>>;
      • Loads and merges JSON configuration file(s) into config

      method set

      set: <K extends string | Path<T>>(
      name: K,
      value: K extends Path<T> ? PathValue<T, K> : any
      ) => Config<T>;
      • Sets the value of name to value. name can use dot notation to reference nested values, e.g. "database.port". If objects in the chain don't yet exist, they will be initialized to empty objects

      method toString

      toString: () => string;
      • Exports all the properties (that is the keys and their current values) as a JSON string.

        Returns

        A string representing this object

      method validate

      validate: (options?: ValidateOptions) => Config<T>;
      • Validates config against the schema used to initialize it

      interface convict

      interface convict {}

        method addFormat

        addFormat: (format: convict.Format) => void;

          method addFormats

          addFormats: (formats: { [name: string]: convict.Format }) => void;

            method addParser

            addParser: (parsers: convict.Parser | convict.Parser[]) => void;

              call signature

              <T>(
              config: convict.Schema<T> | string,
              opts?: convict.Options
              ): convict.Config<T>;

                interface Format

                interface Format {}

                  property name

                  name?: string | undefined;

                    method coerce

                    coerce: (val: any) => any;

                      method validate

                      validate: (val: any, schema: SchemaObj) => void;

                        interface InternalSchema

                        interface InternalSchema<T> {}

                          property properties

                          properties: {
                          [K in keyof T]: T[K] extends object
                          ? InternalSchema<T[K]>
                          : { default: T[K] };
                          };

                            interface Options

                            interface Options {}

                              property args

                              args?: string[] | undefined;

                                property env

                                env?: NodeJS.ProcessEnv | undefined;

                                  interface Parser

                                  interface Parser {}

                                    property extension

                                    extension: string | string[];

                                      property parse

                                      parse: (content: string) => any;

                                        interface SchemaObj

                                        interface SchemaObj<T = any> {}

                                          property arg

                                          arg?: string | undefined;

                                            property default

                                            default: T | null;
                                            • You can define a configuration property as "required" without providing a default value. Set its default to null and if your format doesn't accept null it will throw an error.

                                            property doc

                                            doc?: string | undefined;

                                              property env

                                              env?: string | undefined;

                                                property format

                                                format?:
                                                | PredefinedFormat
                                                | any[]
                                                | ((val: any) => asserts val is T)
                                                | ((val: any) => void)
                                                | undefined;
                                                • From the implementation:

                                                  format can be a: - predefined type, as seen below - an array of enumerated values, e.g. ["production", "development", "testing"] - built-in JavaScript type, i.e. Object, Array, String, Number, Boolean - function that performs validation and throws an Error on failure

                                                  If omitted, format will be set to the value of Object.prototype.toString.call for the default value

                                                property nullable

                                                nullable?: boolean | undefined;

                                                  property sensitive

                                                  sensitive?: boolean | undefined;

                                                    index signature

                                                    [key: string]: any;

                                                      interface ValidateOptions

                                                      interface ValidateOptions {}

                                                        property allowed

                                                        allowed?: ValidationMethod | undefined;
                                                        • If set to warn, any properties specified in config files that are not declared in the schema will print a warning. This is the default behavior. If set to strict, any properties specified in config files that are not declared in the schema will throw errors. This is to ensure that the schema and the config files are in sync.

                                                        property output

                                                        output?: ((message: string) => void) | undefined;
                                                        • If specified, possible warnings will be passed to this function instead of being outputted to console.log, which would be the default behaviour.

                                                        property strict

                                                        strict?: boolean | undefined;
                                                        • Deprecated

                                                          use allowed instead

                                                        Type Aliases

                                                        type Overwrite

                                                        type Overwrite<T, U> = { [P in Exclude<keyof T, keyof U>]: T[P] } & U;

                                                          type Path

                                                          type Path<T> = PathImpl<T, keyof T> | keyof T;

                                                            type PathImpl

                                                            type PathImpl<T, K extends keyof T> = K extends string
                                                            ? T[K] extends Record<string, any>
                                                            ? T[K] extends ArrayLike<any>
                                                            ? K | `${K}.${PathImpl<T[K], Exclude<keyof T[K], keyof any[]>>}`
                                                            : K | `${K}.${PathImpl<T[K], keyof T[K]>}`
                                                            : K
                                                            : never;

                                                              type PathValue

                                                              type PathValue<T, P extends Path<T>> = P extends `${infer K}.${infer Rest}`
                                                              ? K extends keyof T
                                                              ? Rest extends Path<T[K]>
                                                              ? PathValue<T[K], Rest>
                                                              : never
                                                              : never
                                                              : P extends keyof T
                                                              ? T[P]
                                                              : never;

                                                                type PredefinedFormat

                                                                type PredefinedFormat =
                                                                | '*'
                                                                | 'int'
                                                                | 'port'
                                                                | 'windows_named_pipe'
                                                                | 'port_or_windows_named_pipe'
                                                                | 'url'
                                                                | 'email'
                                                                | 'ipaddress'
                                                                | 'duration'
                                                                | 'timestamp'
                                                                | 'nat'
                                                                | String
                                                                | Object
                                                                | Number
                                                                | RegExp
                                                                | Boolean;

                                                                  type Schema

                                                                  type Schema<T> = {
                                                                  [P in keyof T]: Schema<T[P]> | SchemaObj<T[P]>;
                                                                  };

                                                                    type ValidationMethod

                                                                    type ValidationMethod = 'strict' | 'warn';

                                                                      Package Files (1)

                                                                      Dependencies (1)

                                                                      Dev Dependencies (0)

                                                                      No dev dependencies.

                                                                      Peer Dependencies (0)

                                                                      No peer dependencies.

                                                                      Badge

                                                                      To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                      You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/convict.

                                                                      • Markdown
                                                                        [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/convict)
                                                                      • HTML
                                                                        <a href="https://www.jsdocs.io/package/@types/convict"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>