Writing plugins in JavaScript

Kong Gateway supports JavaScript plugin development through the JavaScript PDK. The kong-js-pdk 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.

You can install the JavaScript PDK using npm. To install the plugin server binary globally, run the following command:

npm install kong-pdk -g

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.

See the JavaScript PDK repository for examples of plugins built with JavaScript.

Configuration reference for the JavaScript PDK.

Phase handlers

You can implement custom logic to be executed at various phases in the request processing lifecycle. For example, 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 and await keywords in the phase handlers for better readability. For example:

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

See the JavaScript PDK repo for examples of writing tests with jest.

Prepare the system by installing the required dependencies.

For example, 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