Lokka HTTP Transport

1.6.1 · abandoned · verified Wed Apr 22

Lokka-transport-http provides an isomorphic HTTP transport layer designed for the Lokka GraphQL client. It facilitates sending GraphQL queries over HTTP to `graphql-express` compatible endpoints. The package's current stable version is 1.6.1, with its last release approximately 9 years ago. It supports sending custom HTTP headers and integrates with existing cookie-based authentication mechanisms, or allows for explicit `Authorization` header configuration. A key differentiator is its minimalist approach as a transport layer, allowing Lokka (a simple GraphQL client itself) to focus on query construction. The package, and the broader Lokka ecosystem, appears to be unmaintained, with no recent updates or active development. This means no new features, bug fixes, or security patches are likely. By default, it throws an error on the first GraphQL error returned by the server, but this behavior can be customized.

Common errors

```
TypeError: lokka_transport_http_1.default is not a constructor
```
cause This error often occurs when attempting to import `HttpTransport` using CommonJS `require()` in a way that expects a direct default export, but the transpiled output puts the default export under a `.default` property.

fix If using CommonJS, adjust the import to `const HttpTransport = require('lokka-transport-http').default;` or ensure your build system is configured for proper interoperability between ESM and CJS.
```
Error: GraphQL Error: [message from server]
```
cause The default error handling strategy of `lokka-transport-http` is to throw an `Error` object containing the message of the first GraphQL error returned by the server. This indicates that the GraphQL query itself resulted in server-side errors.

fix Catch the error in your `.catch()` block and inspect the error object. For more granular control or to handle multiple GraphQL errors, provide a custom `handleErrors` function in the `HttpTransport` constructor options.

Warnings

breaking The `lokka-transport-http` package, along with its parent `lokka` client, has been abandoned. There have been no code updates or maintenance activity for approximately 9 years, indicating a high risk of unpatched bugs, security vulnerabilities, and incompatibility with modern JavaScript environments or GraphQL server versions.
Fix: Migrate to a currently maintained GraphQL client (e.g., Apollo Client, Relay, Urql) and its respective transport layers.
gotcha This package does not handle authentication logic itself. Users are responsible for managing and providing authentication credentials, typically via custom HTTP headers (e.g., `Authorization`) or relying on existing cookie-based authentication mechanisms.
Fix: Manually add an `Authorization` header to the `HttpTransport` options object (e.g., `{ headers: { 'Authorization': 'Bearer YOUR_TOKEN' } }`) or ensure your client environment provides appropriate cookies for CORS requests.
gotcha By default, `lokka-transport-http` will throw a new `Error` object using only the *first* GraphQL error encountered in the response. This may hide other errors present in the GraphQL response array.
Fix: Implement a custom `handleErrors` function in the `HttpTransport` options to process the full array of GraphQL errors according to your application's needs. Refer to `lib/index.js` in the package source for the default implementation example.

Install

npm install lokka-transport-http npm
yarn add lokka-transport-http yarn
pnpm add lokka-transport-http pnpm

Imports

HttpTransport
wrong:
```
const HttpTransport = require('lokka-transport-http');
```
correct:
```
import HttpTransport from 'lokka-transport-http';
```
The package's examples use ESM syntax with a default import. For CommonJS, you would typically use `require('lokka-transport-http').default;` if using Babel or TypeScript compilation that exports a default, or simply `require('lokka-transport-http')` if it's a direct `module.exports` of the class. The incorrect `require` without `.default` is a common mistake for ESM default exports in CJS environments.

Quickstart

This quickstart demonstrates how to set up `lokka-transport-http` with Lokka to query a GraphQL endpoint, including an example of sending custom headers for authentication.

import HttpTransport from 'lokka-transport-http';
import Lokka from 'lokka';

// Initialize Lokka with the HTTP transport
const client = new Lokka({
  transport: new HttpTransport('http://graphql-swapi.parseapp.com/')
});

// Send a simple GraphQL query
client.query(`
    {
      allFilms {
        films {
          title
        }
      }
    }
`).then(response => {
    console.log('Query successful:', JSON.stringify(response, null, 2));
}).catch(error => {
    console.error('Query failed:', error);
});

// Example with custom headers (e.g., for authentication)
const headers = {
    'Authorization': `Bearer ${process.env.AUTH_TOKEN ?? ''}`,
    'x-custom-header': 'some-value'
};
const authenticatedClient = new Lokka({
    transport: new HttpTransport('http://your-authenticated-graphql-endpoint.com/graphql', { headers })
});

authenticatedClient.query(`{ viewer { id } }`)
  .then(response => console.log('Authenticated query:', response))
  .catch(error => console.error('Authenticated query failed:', error));

view raw JSON →