Add additional API information to README

Signed-off-by: Matthew Peveler <matt.peveler@gmail.com>

Author: MasterOdin

README.md

@@ -3,15 +3,19 @@
 An [Apollo Link](https://www.apollographql.com/docs/link/) that aborts requests that aren't completed within a specified timeout period. Note that timeouts are enforced for query and mutation operations only (not subscriptions).
 
 ## Installation
-```
+
+```bash
 npm install apollo-link-timeout
 ```
+
 or
-```
+
+```bash
 yarn add apollo-link-timeout
 ```
 
 ## Usage
+
 ```javascript
 import ApolloLinkTimeout from 'apollo-link-timeout';
 import { createHttpLink } from 'apollo-link-http';
@@ -29,7 +33,7 @@ const apolloClient = new ApolloClient({ link: timeoutHttpLink });
 
 // use timeout-enabled Apollo client...
 
-// Override timeout from any query 
+// Override timeout from any query
 <Query
  query={SOME_QUERY}
  variables={{
@@ -41,4 +45,61 @@ const apolloClient = new ApolloClient({ link: timeoutHttpLink });
 // ...
 ```
 
+## API
+
+**`new ApolloLinkTimeout(timeout?, statusCode?)`**
+
+Creates a new TimeoutLink instance that aborts requests if the timeout expires before the response is received.
+
+**Parameters:**
+
+- `timeout` (optional): The timeout in milliseconds for the request. Defaults to 15000ms (15 seconds) if omitted.
+- `statusCode` (optional): The HTTP status code to return when a timeout occurs. Defaults to 408 (Request Timeout) if omitted.
+
+## Overriding Timeout Per Operation
+
+You can override the default timeout for individual operations by setting a `timeout` value in the operation context:
+
+```javascript
+// Override timeout in a query
+<Query
+  query={SOME_QUERY}
+  variables={{
+    someVar1: "foo",
+    someVar2: "bar",
+  }}
+  context={{ timeout: 3000 }} // 3 second timeout for this query
+>
+  // ...
+</Query>
+
+
+// Or when calling the client directly
+apolloClient.query({
+  query: SOME_QUERY,
+  context: { timeout: 5000 } // 5 second timeout
+});
+
+// Or via a prior link
+const link = new ApolloLink((operation, forward) => {
+  operation.setContext({ timeout: 5000 });
+});
+link.concat(timeoutLink);
+```
+
+The timeout resolution follows this priority: operation-level context timeout > link-level timeout > default (15000ms).
+
+## Disabling Timeout
+
+To disable the timeout for a specific operation, set the timeout to a negative value in the operation context:
+
+```javascript
+apolloClient.query({
+  query: SOME_QUERY,
+  context: { timeout: -1 } // Disable timeout for this query
+});
+```
+
+When a negative timeout is provided, the timeout link will be skipped and the operation will proceed without any timeout enforcement.
+
 See [Apollo documentation](https://www.apollographql.com/client) for information on using the Apollo client.

__tests__/timeoutLink.test.ts

@@ -100,6 +100,54 @@ test('configured short value through context time out', done => {
   });
 });
 
+test('configured value through prior link does not time out', done => {
+  delay = 200;
+  const configured = 500;
+
+  const configLink = new ApolloLink((operation, forward) => {
+    operation.setContext({ timeout: configured });
+    return forward(operation);
+  });
+
+  const testLink = configLink.concat(timeoutLink).concat(mockLink);
+
+  execute(testLink, { query }).subscribe({
+    next() {
+      expect(called).toBe(1);
+      done();
+    },
+    error() {
+      expect('error called').toBeFalsy();
+      done();
+    }
+  });
+});
+
+test('configured short value through prior link time out', done => {
+  delay = 200;
+  const configured = 100;
+
+  const configLink = new ApolloLink((operation, forward) => {
+    operation.setContext({ timeout: configured });
+    return forward(operation);
+  });
+
+  const testLink = configLink.concat(timeoutLink).concat(mockLink);
+
+  execute(testLink, { query }).subscribe({
+    next() {
+      expect('next called').toBeFalsy();
+      done();
+    },
+    error(error) {
+      expect(error.message).toEqual('Timeout exceeded');
+      expect(error.timeout).toEqual(configured);
+      expect(error.statusCode).toEqual(408);
+      done();
+    }
+  });
+});
+
 test('aborted request does not timeout', done => {
   delay = 200;
 
@@ -120,6 +168,38 @@ test('aborted request does not timeout', done => {
   });
 });
 
+test('negative timeout via constructor disables timeout', done => {
+  delay = 150;
+
+  const testLink = new TimeoutLink(-1).concat(mockLink);
+
+  execute(testLink, { query }).subscribe({
+    next() {
+      expect(called).toBe(1);
+      done();
+    },
+    error() {
+      expect('error called').toBeFalsy();
+      done();
+    }
+  });
+});
+
+test('negative timeout via context disables timeout', done => {
+  delay = 150;
+
+  execute(link, { query, context: { timeout: -1 } }).subscribe({
+    next() {
+      expect(called).toBe(1);
+      done();
+    },
+    error() {
+      expect('error called').toBeFalsy();
+      done();
+    }
+  });
+});
+
 if (nodeMajor >= 20) {
   test("HTTP multipart subscription stops when unsubscribed", (done) => {
     const subscription = gql`