You are browsing documentation for an older version. See the latest documentation here.

Write plugins in JavaScript

Kong Gateway support for the JavaScript language is provided by the JavaScript PDK. The library provides a plugin server that provides a runtime for JavaScript bindings for Kong Gateway.

TypeScript is also supported in the following ways:

• The PDK includes type definitions for PDK functions that allow type checking when developing plugins in TypeScript.
• Plugins written in TypeScript can be loaded directly to Kong Gateway and transpiled.

Install

JavaScript PDK can be installed using npm. To install the plugin server binary globally:

npm install kong-pdk -g

Development

A valid JavaScript plugin implementation should export the following object:

module.exports = {
  Plugin: KongPlugin,
  Schema: [
    { message: { type: "string" } },
  ],
  Version: '0.1.0',
  Priority: 0,
}

• The Plugin attribute defines the class that implements this plugin.
• The Schema defines the configuration schema of the plugin.
• Version and Priority variables set to the version number and priority of execution.

Note: This repository contains examples of plugins built with JavaScript.

Phase handlers

You can implement custom logic to be executed at various points in the request processing lifecycle. To execute custom JavaScript code in the access phase, define a function named access:

class KongPlugin {
  constructor(config) {
    this.config = config
  }
  async access(kong) {
    // ...
  }
}

You can implement custom logic during the following phases using the same function signature:

• certificate
• rewrite
• access
• response
• preread
• log

The presence of the response handler automatically enables the buffered proxy mode.

PDK functions

Kong interacts with the PDK through network-based inter-rocess communication. Each function returns a promise instance. You can use async/await keywords in the phase handlers for better readability.

class KongPlugin {
  constructor(config) {
    this.config = config
  }
  async access(kong) {
    let host = await kong.request.getHeader("host")
    // do something to host
  }
}

Alternatively, use the then method to resolve a promise:

class KongPlugin {
  constructor(config) {
    this.config = config
  }
  async access(kong) {
    kong.request.getHeader("host")
      .then((host) => {
        // do something to host
      })
  }
}

Plugin dependencies

When using the plugin server, plugins are allowed to have extra dependencies, as long as the directory that holds plugin source code also includes a node_modules directory.

Assuming plugins are stored under /usr/local/kong/js-plugins, the extra dependencies are then defined in /usr/local/kong/js-plugins/package.json.

Developers also need to run npm install under /usr/local/kong/js-plugins to install those dependencies locally into /usr/local/kong/js-plugins/node_modules.

The Node.js version and architecture that runs the plugin server and the one that runs npm install under plugins directory must match.

When running TypeScript plugins, kong-pdk needs to be defined as a dependency in package.json:

{
  "name": "ts_hello",
  "version": "0.1.0",
  "description": "hello TS plugin from kong",
  "main": "ts_hello.ts",
  "dependencies": {
    "kong-pdk": "^0.5.5"
  }
}

Then, import kong-pdk in your TypeScript file:

import kong from "kong-pdk/kong";

Testing

The JavaScript PDK provides a mock framework to test plugin code using jest.

Install jest as a development dependency, then add the test script in package.json:

npm install jest --save-dev

The package.json contains information like this:

{
  "scripts": {
    "test": "jest"
  },
  "devDependencies": {
    "jest": "^26.6.3",
    "kong-pdk": "^0.3.2"
  }
}

Run the test through npm with:

npm test

This repository contains examples of writing tests with jest.

Example configuration

Prepare the system by installing the required dependencies. In Debian/Ubuntu based systems:

apt update
apt install -y nodejs npm
npm install -g kong-pdk

Copy the plugin code and the package.json file in /usr/local/kong/js-plugins, then run:

cd /usr/local/kong/js-plugins/ 
npm install

To load plugins using the kong.conf configuration file, you have to map existing Kong Gateway properties to aspects of your plugin. Here is an example of loading a plugin within kong.conf:

pluginserver_names = js

pluginserver_js_start_cmd = /usr/local/bin/kong-js-pluginserver -v --plugins-directory /usr/local/kong/js-plugins
pluginserver_js_query_cmd = /usr/local/bin/kong-js-pluginserver --plugins-directory /usr/local/kong/js-plugins --dump-all-plugins

pluginserver_js_socket = /usr/local/kong/js_pluginserver.sock

More Information

• PDK Reference
• Plugins with Containers
• Develop plugins with Python
• Develop plugins with Go