zeebe-node
Version:
The Node.js client library for the Zeebe Workflow Automation Engine.
249 lines • 11.3 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ConfigurationHydrator = void 0;
const fs_1 = __importDefault(require("fs"));
const typed_duration_1 = require("typed-duration");
const url_1 = require("url");
const EnvFunction_1 = require("./EnvFunction");
const CamundaCloudDefaultRegion = 'bru-2';
class ConfigurationHydrator {
static configure(gatewayAddress, options) {
var _a;
// ConfigurationHydrator.warnOnAmbiguousConfig()
const configuration = {
hostname: 'localhost',
port: '26500',
...ConfigurationHydrator.readCustomSSLFromEnvironment(),
...ConfigurationHydrator.readBasicAuthFromEnvironment(),
...ConfigurationHydrator.readOAuthFromEnvironment(gatewayAddress),
...ConfigurationHydrator.getGatewayFromEnvironment(),
...ConfigurationHydrator.decodeConnectionString(gatewayAddress),
...ConfigurationHydrator.getCamundaCloudConfig(options),
...ConfigurationHydrator.readTLSFromEnvironment(options),
...ConfigurationHydrator.getEagerStatus(options),
...ConfigurationHydrator.getRetryConfiguration(options),
};
// inherit oAuth custom root certificates, unless
// others are explicitly provided
if ((configuration === null || configuration === void 0 ? void 0 : configuration.oAuth) &&
!configuration.oAuth.customRootCert &&
((_a = configuration.customSSL) === null || _a === void 0 ? void 0 : _a.rootCerts)) {
configuration.oAuth.customRootCert =
configuration.customSSL.rootCerts;
}
return configuration;
}
static readTLSFromEnvironment(options = {}) {
var _a;
const useTLS = (_a = options.useTLS) !== null && _a !== void 0 ? _a : ConfigurationHydrator.getTlsFromEnv();
return {
useTLS,
};
}
static readCustomSSLFromEnvironment() {
const rootCerts = ConfigurationHydrator.ENV()
.ZEEBE_CLIENT_SSL_ROOT_CERTS_PATH;
const certChain = ConfigurationHydrator.ENV()
.ZEEBE_CLIENT_SSL_CERT_CHAIN_PATH;
const privateKey = ConfigurationHydrator.ENV()
.ZEEBE_CLIENT_SSL_PRIVATE_KEY_PATH;
const customSSL = {
certChain: certChain ? fs_1.default.readFileSync(certChain) : undefined,
privateKey: privateKey ? fs_1.default.readFileSync(privateKey) : undefined,
rootCerts: rootCerts ? fs_1.default.readFileSync(rootCerts) : undefined,
};
return {
customSSL,
};
}
static readOAuthFromEnvironment(gatewayAddress) {
const clientId = ConfigurationHydrator.getClientIdFromEnv();
const clientSecret = ConfigurationHydrator.getClientSecretFromEnv();
const audience = ConfigurationHydrator.ENV().ZEEBE_TOKEN_AUDIENCE;
const authServerUrl = ConfigurationHydrator.ENV()
.ZEEBE_AUTHORIZATION_SERVER_URL;
const clusterId = ConfigurationHydrator.ENV()
.ZEEBE_CAMUNDA_CLOUD_CLUSTER_ID;
const isCamundaCloudShortcutConfig = clusterId || (clientId && clientSecret && !audience);
if (isCamundaCloudShortcutConfig) {
return ConfigurationHydrator.readCamundaClusterConfFromEnv(gatewayAddress);
}
return clientId && clientSecret && audience && authServerUrl
? {
oAuth: {
audience,
cacheOnDisk: true,
clientId: clientId,
clientSecret,
url: authServerUrl,
},
useTLS: true,
}
: {};
}
static readBasicAuthFromEnvironment() {
const password = ConfigurationHydrator.ENV().ZEEBE_BASIC_AUTH_PASSWORD;
const username = ConfigurationHydrator.ENV().ZEEBE_BASIC_AUTH_USERNAME;
return password && username
? {
basicAuth: {
password,
username,
},
}
: {};
}
static readCamundaClusterConfFromEnv(explicitGateway) {
if (explicitGateway) {
return {};
}
// We can either take a simple clusterId, or else the whole Zeebe Address
// This env var is Node-client specific
const clusterId = ConfigurationHydrator.ENV()
.ZEEBE_CAMUNDA_CLOUD_CLUSTER_ID;
// This env var is compatible with zbctl and the Java and Go clients
const zeebeAddress = ConfigurationHydrator.getZeebeAddressFromEnv();
const hostname = clusterId
? `${clusterId}.${CamundaCloudDefaultRegion}.zeebe.camunda.io`
: zeebeAddress.split(':443')[0];
const clientId = ConfigurationHydrator.getClientIdFromEnv();
const clientSecret = ConfigurationHydrator.getClientSecretFromEnv();
const url = ConfigurationHydrator.ENV().ZEEBE_AUTHORIZATION_SERVER_URL ||
ConfigurationHydrator.CAMUNDA_CLOUD_AUTH_SERVER;
return clientId
? {
hostname,
oAuth: {
audience: hostname,
cacheDir: undefined,
cacheOnDisk: true,
clientId,
clientSecret,
url,
},
port: '443',
useTLS: true,
}
: {};
}
static getGatewayFromEnvironment() {
// ZEEBE_GATEWAY_ADDRESS is for backward compatibility. ZEEBE_ADDRESS is for compatibility with
// the Java / Go clients (including zbctl)
const connectionString = ConfigurationHydrator.getZeebeAddressFromEnv();
return connectionString
? ConfigurationHydrator.decodeConnectionString(connectionString)
: {};
}
static decodeConnectionString(connectionString) {
if (!connectionString) {
connectionString = ConfigurationHydrator.getZeebeAddressFromEnv();
if (!connectionString) {
return {};
}
}
const includesProtocol = connectionString.includes('://');
const gatewayAddress = includesProtocol
? connectionString
: `zeebe://${connectionString}`;
const url = (0, url_1.parse)(gatewayAddress);
url.port = url.port || ConfigurationHydrator.DEFAULT_GATEWAY_PORT;
url.hostname = url.hostname || url.path;
return {
hostname: url.hostname,
port: url.port,
};
}
static getCamundaCloudConfig(options = {}) {
if (options.camundaCloud) {
const { camundaCloud } = options;
const clusterId = ConfigurationHydrator.justClusterId(camundaCloud.clusterId);
const clusterRegion = camundaCloud.clusterRegion || CamundaCloudDefaultRegion;
const configuration = {
...options,
hostname: `${clusterId}.${clusterRegion}.zeebe.camunda.io`,
oAuth: {
audience: `${clusterId}.${clusterRegion}.zeebe.camunda.io`,
cacheDir: camundaCloud.cacheDir,
cacheOnDisk: camundaCloud.cacheOnDisk !== false,
clientId: camundaCloud.clientId,
clientSecret: camundaCloud.clientSecret,
url: ConfigurationHydrator.CAMUNDA_CLOUD_AUTH_SERVER,
},
port: '443',
useTLS: true,
};
return configuration;
}
return options;
}
static justClusterId(maybeClusterId) {
// 'Be liberal in what you accept and conservative in what you emit'
// Here we account for users pasting in either the expected clusterId
// or the entire Zeebe ContactPoint from the Cloud Console.
return maybeClusterId
? maybeClusterId.split('.zeebe.camunda.io')[0]
: undefined;
}
static getEagerStatus(options) {
return {
eagerConnection: (ConfigurationHydrator.ENV().ZEEBE_NODE_EAGER_CONNECT ||
'false').toLocaleLowerCase() === 'true' ||
(options === null || options === void 0 ? void 0 : options.eagerConnection) === true,
};
}
static getRetryConfiguration(options) {
const maxRetries = parseInt(ConfigurationHydrator.ENV().ZEEBE_CLIENT_MAX_RETRIES, 10);
const maxRetryTimeout = parseInt(ConfigurationHydrator.ENV().ZEEBE_CLIENT_MAX_RETRY_TIMEOUT, 10);
const retryFromEnv = ConfigurationHydrator.ENV().ZEEBE_CLIENT_RETRY;
return {
retry: (retryFromEnv === null || retryFromEnv === void 0 ? void 0 : retryFromEnv.toLocaleLowerCase()) === 'false' ||
(options === null || options === void 0 ? void 0 : options.retry) === false
? false
: true,
maxRetries: isNaN(maxRetries)
? options === null || options === void 0 ? void 0 : options.maxRetries
: typed_duration_1.Duration.seconds.from(maxRetries),
maxRetryTimeout: isNaN(maxRetryTimeout)
? options === null || options === void 0 ? void 0 : options.maxRetryTimeout
: typed_duration_1.Duration.seconds.from(maxRetryTimeout),
};
}
}
exports.ConfigurationHydrator = ConfigurationHydrator;
// These are the environment variables that can be used to configure the client
ConfigurationHydrator.ENV = () => (0, EnvFunction_1.getEnv)([
'ZEEBE_NODE_LOG_LEVEL',
'ZEEBE_GATEWAY_ADDRESS',
'ZEEBE_ADDRESS',
'ZEEBE_CLIENT_ID',
'ZEEBE_CLIENT_SECRET',
'ZEEBE_SECURE_CONNECTION',
'ZEEBE_TOKEN_AUDIENCE',
'ZEEBE_AUTHORIZATION_SERVER_URL',
'ZEEBE_CAMUNDA_CLOUD_CLUSTER_ID',
'ZEEBE_BASIC_AUTH_PASSWORD',
'ZEEBE_BASIC_AUTH_USERNAME',
'ZEEBE_NODE_EAGER_CONNECT',
'ZEEBE_CLIENT_RETRY',
'ZEEBE_CLIENT_MAX_RETRIES',
'ZEEBE_CLIENT_MAX_RETRY_TIMEOUT',
'ZEEBE_CLIENT_SSL_ROOT_CERTS_PATH',
'ZEEBE_CLIENT_SSL_PRIVATE_KEY_PATH',
'ZEEBE_CLIENT_SSL_CERT_CHAIN_PATH',
]);
ConfigurationHydrator.getLogLevelFromEnv = () => ConfigurationHydrator.ENV().ZEEBE_NODE_LOG_LEVEL;
ConfigurationHydrator.DEFAULT_GATEWAY_PORT = '26500';
ConfigurationHydrator.CAMUNDA_CLOUD_AUTH_SERVER = 'https://login.cloud.camunda.io/oauth/token';
ConfigurationHydrator.getClientIdFromEnv = () => ConfigurationHydrator.ENV().ZEEBE_CLIENT_ID;
ConfigurationHydrator.getZeebeAddressFromEnv = () => ConfigurationHydrator.ENV().ZEEBE_ADDRESS ||
ConfigurationHydrator.ENV().ZEEBE_GATEWAY_ADDRESS;
ConfigurationHydrator.getClientSecretFromEnv = () => ConfigurationHydrator.ENV().ZEEBE_CLIENT_SECRET;
ConfigurationHydrator.getTlsFromEnv = () => (ConfigurationHydrator.ENV().ZEEBE_SECURE_CONNECTION || '').toLowerCase() === 'true'
? true
: (ConfigurationHydrator.ENV().ZEEBE_SECURE_CONNECTION || '').toLowerCase() === 'false'
? false
: undefined;
//# sourceMappingURL=ConfigurationHydrator.js.map