apollo-server-env

  • Version 4.0.3
  • Published
  • 17.4 kB
  • 1 dependency
  • MIT license

Install

npm i apollo-server-env
yarn add apollo-server-env
pnpm add apollo-server-env

Overview

This package is used internally by Apollo Server and not meant to be consumed directly.

Index

Functions

function fetch

fetch: (input: RequestInfo, init?: RequestInit) => Promise<Response>;

    Classes

    class Body

    class Body {}

      property bodyUsed

      readonly bodyUsed: boolean;

        method arrayBuffer

        arrayBuffer: () => Promise<ArrayBuffer>;

          method json

          json: () => Promise<any>;

            method text

            text: () => Promise<string>;

              class Headers

              class Headers implements Iterable<[string, string]> {}

                constructor

                constructor(init?: HeadersInit);

                  method [Symbol.iterator]

                  [Symbol.iterator]: () => Iterator<[string, string]>;

                    method append

                    append: (name: string, value: string) => void;

                      method delete

                      delete: (name: string) => void;

                        method entries

                        entries: () => Iterator<[string, string]>;

                          method get

                          get: (name: string) => string | null;

                            method has

                            has: (name: string) => boolean;

                              method keys

                              keys: () => Iterator<string>;

                                method set

                                set: (name: string, value: string) => void;

                                  method values

                                  values: () => Iterator<string>;

                                    class Request

                                    class Request extends Body {}

                                      constructor

                                      constructor(input: string | Request, init?: RequestInit);

                                        property headers

                                        readonly headers: Headers;

                                          property method

                                          readonly method: string;

                                            property url

                                            readonly url: string;

                                              method clone

                                              clone: () => Request;

                                                class Response

                                                class Response extends Body {}

                                                  constructor

                                                  constructor(body?: BodyInit, init?: ResponseInit);

                                                    property headers

                                                    readonly headers: Headers;

                                                      property ok

                                                      readonly ok: boolean;

                                                        property redirected

                                                        readonly redirected: boolean;

                                                          property status

                                                          readonly status: number;

                                                            property statusText

                                                            readonly statusText: string;

                                                              property url

                                                              readonly url: string;

                                                                method clone

                                                                clone: () => Response;

                                                                  method error

                                                                  static error: () => Response;

                                                                    method redirect

                                                                    static redirect: (url: string, status?: number) => Response;

                                                                      class URL

                                                                      class URL {}

                                                                        constructor

                                                                        constructor(input: string, base?: string | URL);

                                                                          property hash

                                                                          hash: string;

                                                                            property host

                                                                            host: string;

                                                                              property hostname

                                                                              hostname: string;

                                                                                property href

                                                                                href: string;

                                                                                  property origin

                                                                                  readonly origin: string;

                                                                                    property password

                                                                                    password: string;

                                                                                      property pathname

                                                                                      pathname: string;

                                                                                        property port

                                                                                        port: string;

                                                                                          property protocol

                                                                                          protocol: string;

                                                                                            property search

                                                                                            search: string;

                                                                                              property searchParams

                                                                                              readonly searchParams: URLSearchParams;

                                                                                                property username

                                                                                                username: string;

                                                                                                  method toJSON

                                                                                                  toJSON: () => string;

                                                                                                    method toString

                                                                                                    toString: () => string;

                                                                                                      class URLSearchParams

                                                                                                      class URLSearchParams implements Iterable<[string, string]> {}

                                                                                                        constructor

                                                                                                        constructor(init?: URLSearchParamsInit);

                                                                                                          method [Symbol.iterator]

                                                                                                          [Symbol.iterator]: () => IterableIterator<[string, string]>;

                                                                                                            method append

                                                                                                            append: (name: string, value: string) => void;

                                                                                                              method delete

                                                                                                              delete: (name: string) => void;

                                                                                                                method entries

                                                                                                                entries: () => IterableIterator<[string, string]>;

                                                                                                                  method forEach

                                                                                                                  forEach: (callback: (value: string, name: string) => void) => void;

                                                                                                                    method get

                                                                                                                    get: (name: string) => string | null;

                                                                                                                      method getAll

                                                                                                                      getAll: (name: string) => string[];

                                                                                                                        method has

                                                                                                                        has: (name: string) => boolean;

                                                                                                                          method keys

                                                                                                                          keys: () => IterableIterator<string>;

                                                                                                                            method set

                                                                                                                            set: (name: string, value: string) => void;

                                                                                                                              method sort

                                                                                                                              sort: () => void;

                                                                                                                                method toString

                                                                                                                                toString: () => string;

                                                                                                                                  method values

                                                                                                                                  values: () => IterableIterator<string>;

                                                                                                                                    Interfaces

                                                                                                                                    interface RequestInit

                                                                                                                                    interface RequestInit {}

                                                                                                                                      property agent

                                                                                                                                      agent?: RequestAgent | false;

                                                                                                                                        property body

                                                                                                                                        body?: BodyInit;

                                                                                                                                          property cache

                                                                                                                                          cache?: RequestCache;

                                                                                                                                            property cf

                                                                                                                                            cf?: {
                                                                                                                                            [key: string]: any;
                                                                                                                                            };

                                                                                                                                              property compress

                                                                                                                                              compress?: boolean;

                                                                                                                                                property credentials

                                                                                                                                                credentials?: RequestCredentials;

                                                                                                                                                  property follow

                                                                                                                                                  follow?: number;

                                                                                                                                                    property headers

                                                                                                                                                    headers?: HeadersInit;

                                                                                                                                                      property integrity

                                                                                                                                                      integrity?: string;

                                                                                                                                                        property method

                                                                                                                                                        method?: string;

                                                                                                                                                          property mode

                                                                                                                                                          mode?: RequestMode;

                                                                                                                                                            property redirect

                                                                                                                                                            redirect?: RequestRedirect;

                                                                                                                                                              property referrer

                                                                                                                                                              referrer?: string;

                                                                                                                                                                property referrerPolicy

                                                                                                                                                                referrerPolicy?: ReferrerPolicy;

                                                                                                                                                                  property size

                                                                                                                                                                  size?: number;

                                                                                                                                                                    property timeout

                                                                                                                                                                    timeout?: number;

                                                                                                                                                                      interface ResponseInit

                                                                                                                                                                      interface ResponseInit {}

                                                                                                                                                                        property headers

                                                                                                                                                                        headers?: HeadersInit;

                                                                                                                                                                          property status

                                                                                                                                                                          status?: number;

                                                                                                                                                                            property statusText

                                                                                                                                                                            statusText?: string;

                                                                                                                                                                              property url

                                                                                                                                                                              url?: string;

                                                                                                                                                                                Type Aliases

                                                                                                                                                                                type BodyInit

                                                                                                                                                                                type BodyInit = ArrayBuffer | ArrayBufferView | string;

                                                                                                                                                                                  type HeadersInit

                                                                                                                                                                                  type HeadersInit = Headers | string[][] | { [name: string]: string };

                                                                                                                                                                                    type ReferrerPolicy

                                                                                                                                                                                    type ReferrerPolicy =
                                                                                                                                                                                    | ''
                                                                                                                                                                                    | 'no-referrer'
                                                                                                                                                                                    | 'no-referrer-when-downgrade'
                                                                                                                                                                                    | 'same-origin'
                                                                                                                                                                                    | 'origin'
                                                                                                                                                                                    | 'strict-origin'
                                                                                                                                                                                    | 'origin-when-cross-origin'
                                                                                                                                                                                    | 'strict-origin-when-cross-origin'
                                                                                                                                                                                    | 'unsafe-url';

                                                                                                                                                                                      type RequestAgent

                                                                                                                                                                                      type RequestAgent = HttpAgent | HttpsAgent;

                                                                                                                                                                                        type RequestCache

                                                                                                                                                                                        type RequestCache =
                                                                                                                                                                                        | 'default'
                                                                                                                                                                                        | 'no-store'
                                                                                                                                                                                        | 'reload'
                                                                                                                                                                                        | 'no-cache'
                                                                                                                                                                                        | 'force-cache'
                                                                                                                                                                                        | 'only-if-cached';

                                                                                                                                                                                          type RequestCredentials

                                                                                                                                                                                          type RequestCredentials = 'omit' | 'same-origin' | 'include';

                                                                                                                                                                                            type RequestInfo

                                                                                                                                                                                            type RequestInfo = Request | string;

                                                                                                                                                                                              type RequestMode

                                                                                                                                                                                              type RequestMode = 'navigate' | 'same-origin' | 'no-cors' | 'cors';

                                                                                                                                                                                                type RequestRedirect

                                                                                                                                                                                                type RequestRedirect = 'follow' | 'error' | 'manual';

                                                                                                                                                                                                  type URLSearchParamsInit

                                                                                                                                                                                                  type URLSearchParamsInit =
                                                                                                                                                                                                  | URLSearchParams
                                                                                                                                                                                                  | string
                                                                                                                                                                                                  | { [key: string]: Object | Object[] | undefined }
                                                                                                                                                                                                  | Iterable<[string, Object]>
                                                                                                                                                                                                  | Array<[string, Object]>;

                                                                                                                                                                                                    Package Files (3)

                                                                                                                                                                                                    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/apollo-server-env.

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