@celerispay/hazelcast-client 3.12.5

package/lib/config/Config.d.ts

@@ -0,0 +1,61 @@
+import { TopicOverloadPolicy } from '../proxy/topic/TopicOverloadPolicy';
+import { ClientNetworkConfig } from './ClientNetworkConfig';
+import { EvictionPolicy } from './EvictionPolicy';
+import { FlakeIdGeneratorConfig } from './FlakeIdGeneratorConfig';
+import { GroupConfig } from './GroupConfig';
+import { ImportConfig } from './ImportConfig';
+import { InMemoryFormat } from './InMemoryFormat';
+import { ListenerConfig } from './ListenerConfig';
+import { NearCacheConfig } from './NearCacheConfig';
+import { SSLConfig } from './SSLConfig';
+import { Properties } from './Properties';
+import { ReliableTopicConfig } from './ReliableTopicConfig';
+import { SerializationConfig } from './SerializationConfig';
+import { ILogger } from '../logging/ILogger';
+import { JsonStringDeserializationPolicy } from './JsonStringDeserializationPolicy';
+import { StringSerializationPolicy } from './StringSerializationPolicy';
+/**
+ * Top level configuration object of Hazelcast client. Other configurations items are properties of this object.
+ */
+export declare class ClientConfig {
+    properties: Properties;
+    /**
+     * Name of this client instance.
+     */
+    instanceName: string;
+    groupConfig: GroupConfig;
+    networkConfig: ClientNetworkConfig;
+    customLogger: ILogger;
+    customCredentials: any;
+    listeners: ListenerConfig;
+    listenerConfigs: ImportConfig[];
+    serializationConfig: SerializationConfig;
+    reliableTopicConfigs: {
+        [name: string]: ReliableTopicConfig;
+    };
+    nearCacheConfigs: {
+        [name: string]: NearCacheConfig;
+    };
+    flakeIdGeneratorConfigs: {
+        [name: string]: FlakeIdGeneratorConfig;
+    };
+    private configPatternMatcher;
+    getInstanceName(): string;
+    getReliableTopicConfig(name: string): ReliableTopicConfig;
+    getNearCacheConfig(name: string): NearCacheConfig;
+    getFlakeIdGeneratorConfig(name: string): FlakeIdGeneratorConfig;
+    private lookupByPattern<T>(config, name);
+}
+export { ClientNetworkConfig };
+export { TopicOverloadPolicy };
+export { SerializationConfig };
+export { GroupConfig };
+export { ReliableTopicConfig };
+export { EvictionPolicy };
+export { InMemoryFormat };
+export { NearCacheConfig };
+export { ImportConfig };
+export { FlakeIdGeneratorConfig };
+export { SSLConfig };
+export { JsonStringDeserializationPolicy };
+export { StringSerializationPolicy };

package/lib/config/Config.js

@@ -0,0 +1,138 @@
+"use strict";
+/*
+ * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var TopicOverloadPolicy_1 = require("../proxy/topic/TopicOverloadPolicy");
+exports.TopicOverloadPolicy = TopicOverloadPolicy_1.TopicOverloadPolicy;
+var ClientNetworkConfig_1 = require("./ClientNetworkConfig");
+exports.ClientNetworkConfig = ClientNetworkConfig_1.ClientNetworkConfig;
+var ConfigPatternMatcher_1 = require("./ConfigPatternMatcher");
+var EvictionPolicy_1 = require("./EvictionPolicy");
+exports.EvictionPolicy = EvictionPolicy_1.EvictionPolicy;
+var FlakeIdGeneratorConfig_1 = require("./FlakeIdGeneratorConfig");
+exports.FlakeIdGeneratorConfig = FlakeIdGeneratorConfig_1.FlakeIdGeneratorConfig;
+var GroupConfig_1 = require("./GroupConfig");
+exports.GroupConfig = GroupConfig_1.GroupConfig;
+var InMemoryFormat_1 = require("./InMemoryFormat");
+exports.InMemoryFormat = InMemoryFormat_1.InMemoryFormat;
+var ListenerConfig_1 = require("./ListenerConfig");
+var NearCacheConfig_1 = require("./NearCacheConfig");
+exports.NearCacheConfig = NearCacheConfig_1.NearCacheConfig;
+var SSLConfig_1 = require("./SSLConfig");
+exports.SSLConfig = SSLConfig_1.SSLConfig;
+var ReliableTopicConfig_1 = require("./ReliableTopicConfig");
+exports.ReliableTopicConfig = ReliableTopicConfig_1.ReliableTopicConfig;
+var SerializationConfig_1 = require("./SerializationConfig");
+exports.SerializationConfig = SerializationConfig_1.SerializationConfig;
+var Statistics_1 = require("../statistics/Statistics");
+var __1 = require("..");
+var JsonStringDeserializationPolicy_1 = require("./JsonStringDeserializationPolicy");
+exports.JsonStringDeserializationPolicy = JsonStringDeserializationPolicy_1.JsonStringDeserializationPolicy;
+var StringSerializationPolicy_1 = require("./StringSerializationPolicy");
+exports.StringSerializationPolicy = StringSerializationPolicy_1.StringSerializationPolicy;
+/**
+ * Top level configuration object of Hazelcast client. Other configurations items are properties of this object.
+ */
+var ClientConfig = /** @class */ (function () {
+    function ClientConfig() {
+        this.properties = {
+            'hazelcast.client.heartbeat.interval': 5000,
+            'hazelcast.client.heartbeat.timeout': 60000,
+            'hazelcast.client.invocation.retry.pause.millis': 1000,
+            'hazelcast.client.invocation.timeout.millis': 120000,
+            'hazelcast.client.internal.clean.resources.millis': 100,
+            'hazelcast.client.cloud.url': 'https://coordinator.hazelcast.cloud',
+            'hazelcast.client.statistics.enabled': false,
+            'hazelcast.client.statistics.period.seconds': Statistics_1.Statistics.PERIOD_SECONDS_DEFAULT_VALUE,
+            'hazelcast.invalidation.reconciliation.interval.seconds': 60,
+            'hazelcast.invalidation.max.tolerated.miss.count': 10,
+            'hazelcast.invalidation.min.reconciliation.interval.seconds': 30,
+            'hazelcast.logging.level': __1.LogLevel.INFO,
+            'hazelcast.client.autopipelining.enabled': true,
+            'hazelcast.client.autopipelining.threshold.bytes': 8192,
+            'hazelcast.client.socket.no.delay': true,
+            // Enhanced connection management properties
+            'hazelcast.client.connection.health.check.interval': 5000,
+            'hazelcast.client.connection.max.retries': 3,
+            'hazelcast.client.connection.retry.delay': 1000,
+            'hazelcast.client.failover.cooldown': 5000,
+            'hazelcast.client.partition.refresh.min.interval': 2000,
+            'hazelcast.client.invocation.max.retries': 10,
+            'hazelcast.client.partition.failure.backoff': 2000,
+        };
+        this.groupConfig = new GroupConfig_1.GroupConfig();
+        this.networkConfig = new ClientNetworkConfig_1.ClientNetworkConfig();
+        this.customCredentials = null;
+        this.listeners = new ListenerConfig_1.ListenerConfig();
+        this.listenerConfigs = [];
+        this.serializationConfig = new SerializationConfig_1.SerializationConfig();
+        this.reliableTopicConfigs = {};
+        this.nearCacheConfigs = {};
+        this.flakeIdGeneratorConfigs = {};
+        this.configPatternMatcher = new ConfigPatternMatcher_1.ConfigPatternMatcher();
+    }
+    ClientConfig.prototype.getInstanceName = function () {
+        return this.instanceName;
+    };
+    ClientConfig.prototype.getReliableTopicConfig = function (name) {
+        var matching = this.lookupByPattern(this.reliableTopicConfigs, name);
+        var config;
+        if (matching != null) {
+            config = matching.clone();
+        }
+        else {
+            config = new ReliableTopicConfig_1.ReliableTopicConfig();
+        }
+        config.name = name;
+        return config;
+    };
+    ClientConfig.prototype.getNearCacheConfig = function (name) {
+        var matching = this.lookupByPattern(this.nearCacheConfigs, name);
+        if (matching == null) {
+            return null;
+        }
+        var config = matching.clone();
+        config.name = name;
+        return config;
+    };
+    ClientConfig.prototype.getFlakeIdGeneratorConfig = function (name) {
+        var matching = this.lookupByPattern(this.flakeIdGeneratorConfigs, name);
+        var config;
+        if (matching != null) {
+            config = matching.clone();
+        }
+        else {
+            config = new FlakeIdGeneratorConfig_1.FlakeIdGeneratorConfig();
+        }
+        config.name = name;
+        return config;
+    };
+    ClientConfig.prototype.lookupByPattern = function (config, name) {
+        if (config[name] != null) {
+            return config[name];
+        }
+        var matchingPattern = this.configPatternMatcher.matches(Object.keys(config), name);
+        if (matchingPattern != null) {
+            return config[matchingPattern];
+        }
+        if (config.default != null) {
+            return config.default;
+        }
+        return null;
+    };
+    return ClientConfig;
+}());
+exports.ClientConfig = ClientConfig;

package/lib/config/ConfigBuilder.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+import { ClientConfig } from './Config';
+export declare class ConfigBuilder {
+    private clientConfig;
+    private loadedJson;
+    private configLocator;
+    loadConfig(): Promise<void>;
+    build(): ClientConfig;
+    private replaceImportsWithContent(jsonObject);
+    private handleConfig(jsonObject);
+    private handleNetwork(jsonObject);
+    private handleHazelcastCloud(jsonObject);
+    private parseProperties(jsonObject);
+    private parseImportConfig(jsonObject);
+    private handleSSL(jsonObject);
+    private handleClusterMembers(jsonObject);
+    private handleGroup(jsonObject);
+    private handleProperties(jsonObject);
+    private handleListeners(jsonObject);
+    private handleSerialization(jsonObject);
+    private handleSerializers(jsonObject);
+    private handleNearCaches(jsonObject);
+    private handleReliableTopics(jsonObject);
+    private handleFlakeIds(jsonObject);
+}

package/lib/config/ConfigBuilder.js

@@ -0,0 +1,322 @@
+"use strict";
+/*
+ * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var Promise = require("bluebird");
+var BasicSSLOptionsFactory_1 = require("../connection/BasicSSLOptionsFactory");
+var HazelcastError_1 = require("../HazelcastError");
+var TopicOverloadPolicy_1 = require("../proxy/topic/TopicOverloadPolicy");
+var Util_1 = require("../Util");
+var Config_1 = require("./Config");
+var EvictionPolicy_1 = require("./EvictionPolicy");
+var FlakeIdGeneratorConfig_1 = require("./FlakeIdGeneratorConfig");
+var InMemoryFormat_1 = require("./InMemoryFormat");
+var JsonConfigLocator_1 = require("./JsonConfigLocator");
+var NearCacheConfig_1 = require("./NearCacheConfig");
+var ReliableTopicConfig_1 = require("./ReliableTopicConfig");
+var JsonStringDeserializationPolicy_1 = require("./JsonStringDeserializationPolicy");
+var StringSerializationPolicy_1 = require("./StringSerializationPolicy");
+var ConfigBuilder = /** @class */ (function () {
+    function ConfigBuilder() {
+        this.clientConfig = new Config_1.ClientConfig();
+        this.configLocator = new JsonConfigLocator_1.JsonConfigLocator();
+    }
+    ConfigBuilder.prototype.loadConfig = function () {
+        var _this = this;
+        return this.configLocator.load().then(function () {
+            var loadedBuffer = _this.configLocator.getBuffer();
+            if (loadedBuffer) {
+                _this.loadedJson = JSON.parse(loadedBuffer.toString());
+                return _this.replaceImportsWithContent(_this.loadedJson);
+            }
+        });
+    };
+    ConfigBuilder.prototype.build = function () {
+        try {
+            this.handleConfig(this.loadedJson);
+            return this.clientConfig;
+        }
+        catch (e) {
+            throw new HazelcastError_1.HazelcastError('Error parsing config: ' + e.message, e);
+        }
+    };
+    ConfigBuilder.prototype.replaceImportsWithContent = function (jsonObject) {
+        var _this = this;
+        if (jsonObject.import) {
+            var includes = Util_1.tryGetArray(jsonObject.import);
+            return Promise.map(includes, function (path) {
+                return _this.configLocator.loadImported(path);
+            }).map(function (buffer) {
+                Util_1.mergeJson(jsonObject, JSON.parse(buffer.toString()));
+            }).return();
+        }
+    };
+    ConfigBuilder.prototype.handleConfig = function (jsonObject) {
+        for (var key in jsonObject) {
+            if (key === 'network') {
+                this.handleNetwork(jsonObject[key]);
+            }
+            else if (key === 'group') {
+                this.handleGroup(jsonObject[key]);
+            }
+            else if (key === 'properties') {
+                this.handleProperties(jsonObject[key]);
+            }
+            else if (key === 'listeners') {
+                this.handleListeners(jsonObject[key]);
+            }
+            else if (key === 'serialization') {
+                this.handleSerialization(jsonObject[key]);
+            }
+            else if (key === 'nearCaches') {
+                this.handleNearCaches(jsonObject[key]);
+            }
+            else if (key === 'reliableTopics') {
+                this.handleReliableTopics(jsonObject[key]);
+            }
+            else if (key === 'flakeIdGeneratorConfigs') {
+                this.handleFlakeIds(jsonObject[key]);
+            }
+        }
+    };
+    ConfigBuilder.prototype.handleNetwork = function (jsonObject) {
+        for (var key in jsonObject) {
+            if (key === 'clusterMembers') {
+                this.handleClusterMembers(jsonObject[key]);
+            }
+            else if (key === 'smartRouting') {
+                this.clientConfig.networkConfig.smartRouting = Util_1.tryGetBoolean(jsonObject[key]);
+            }
+            else if (key === 'connectionTimeout') {
+                this.clientConfig.networkConfig.connectionTimeout = Util_1.tryGetNumber(jsonObject[key]);
+            }
+            else if (key === 'connectionAttemptPeriod') {
+                this.clientConfig.networkConfig.connectionAttemptPeriod = Util_1.tryGetNumber(jsonObject[key]);
+            }
+            else if (key === 'connectionAttemptLimit') {
+                this.clientConfig.networkConfig.connectionAttemptLimit = Util_1.tryGetNumber(jsonObject[key]);
+            }
+            else if (key === 'ssl') {
+                this.handleSSL(jsonObject[key]);
+            }
+            else if (key === 'hazelcastCloud') {
+                this.handleHazelcastCloud(jsonObject[key]);
+            }
+        }
+    };
+    ConfigBuilder.prototype.handleHazelcastCloud = function (jsonObject) {
+        var cloudConfigEnabled = Util_1.tryGetBoolean(jsonObject.enabled);
+        if (cloudConfigEnabled) {
+            this.clientConfig.networkConfig.cloudConfig.enabled = cloudConfigEnabled;
+        }
+        for (var key in jsonObject) {
+            if (key === 'discoveryToken') {
+                this.clientConfig.networkConfig.cloudConfig.discoveryToken = Util_1.tryGetString(jsonObject[key]);
+            }
+        }
+    };
+    ConfigBuilder.prototype.parseProperties = function (jsonObject) {
+        var props = {};
+        for (var key in jsonObject) {
+            props[key] = jsonObject[key];
+        }
+        return props;
+    };
+    ConfigBuilder.prototype.parseImportConfig = function (jsonObject) {
+        var importConfig = {};
+        importConfig.path = jsonObject.path;
+        importConfig.exportedName = jsonObject.exportedName;
+        return importConfig;
+    };
+    ConfigBuilder.prototype.handleSSL = function (jsonObject) {
+        var sslEnabled = Util_1.tryGetBoolean(jsonObject.enabled);
+        this.clientConfig.networkConfig.sslConfig.enabled = sslEnabled;
+        if (jsonObject.sslOptions) {
+            if (jsonObject.factory) {
+                throw new RangeError('Invalid configuration. Either SSL options should be set manually or SSL factory' +
+                    ' should be used.');
+            }
+            this.clientConfig.networkConfig.sslConfig.sslOptions = jsonObject.sslOptions;
+        }
+        else if (jsonObject.factory) {
+            var factory = jsonObject.factory;
+            var importConfig = this.parseImportConfig(factory);
+            if (importConfig.path == null && importConfig.exportedName !== BasicSSLOptionsFactory_1.BasicSSLOptionsFactory.name) {
+                throw new RangeError('Invalid configuration. Either SSL factory path should be set or exportedName' +
+                    ' should be ' + BasicSSLOptionsFactory_1.BasicSSLOptionsFactory.name + '.');
+            }
+            else {
+                this.clientConfig.networkConfig.sslConfig.sslOptionsFactoryConfig = this.parseImportConfig(factory);
+                this.clientConfig.networkConfig.sslConfig.sslOptionsFactoryProperties = this.parseProperties(factory.properties);
+            }
+        }
+    };
+    ConfigBuilder.prototype.handleClusterMembers = function (jsonObject) {
+        var addressArray = Util_1.tryGetArray(jsonObject);
+        for (var index in addressArray) {
+            var address = addressArray[index];
+            this.clientConfig.networkConfig.addresses.push(Util_1.tryGetString(address));
+        }
+    };
+    ConfigBuilder.prototype.handleGroup = function (jsonObject) {
+        for (var key in jsonObject) {
+            if (key === 'name') {
+                this.clientConfig.groupConfig.name = Util_1.tryGetString(jsonObject[key]);
+            }
+            else if (key === 'password') {
+                this.clientConfig.groupConfig.password = Util_1.tryGetString(jsonObject[key]);
+            }
+        }
+    };
+    ConfigBuilder.prototype.handleProperties = function (jsonObject) {
+        for (var key in jsonObject) {
+            this.clientConfig.properties[key] = jsonObject[key];
+        }
+    };
+    ConfigBuilder.prototype.handleListeners = function (jsonObject) {
+        var listenersArray = Util_1.tryGetArray(jsonObject);
+        for (var index in listenersArray) {
+            var listenerConfig = listenersArray[index];
+            this.clientConfig.listenerConfigs.push(this.parseImportConfig(listenerConfig));
+        }
+    };
+    ConfigBuilder.prototype.handleSerialization = function (jsonObject) {
+        for (var key in jsonObject) {
+            if (key === 'defaultNumberType') {
+                this.clientConfig.serializationConfig.defaultNumberType = Util_1.tryGetString(jsonObject[key]);
+            }
+            else if (key === 'isBigEndian') {
+                this.clientConfig.serializationConfig.isBigEndian = Util_1.tryGetBoolean(jsonObject[key]);
+            }
+            else if (key === 'portableVersion') {
+                this.clientConfig.serializationConfig.portableVersion = Util_1.tryGetNumber(jsonObject[key]);
+            }
+            else if (key === 'dataSerializableFactories') {
+                for (var index in jsonObject[key]) {
+                    var factory = jsonObject[key][index];
+                    this.clientConfig.serializationConfig
+                        .dataSerializableFactoryConfigs[factory.factoryId] = this.parseImportConfig(factory);
+                }
+            }
+            else if (key === 'portableFactories') {
+                for (var index in jsonObject[key]) {
+                    var factory = jsonObject[key][index];
+                    this.clientConfig.serializationConfig
+                        .portableFactoryConfigs[factory.factoryId] = this.parseImportConfig(factory);
+                }
+            }
+            else if (key === 'globalSerializer') {
+                var globalSerializer = jsonObject[key];
+                this.clientConfig.serializationConfig.globalSerializerConfig = this.parseImportConfig(globalSerializer);
+            }
+            else if (key === 'serializers') {
+                this.handleSerializers(jsonObject[key]);
+            }
+            else if (key === 'jsonStringDeserializationPolicy') {
+                this.clientConfig.serializationConfig
+                    .jsonStringDeserializationPolicy = Util_1.tryGetEnum(JsonStringDeserializationPolicy_1.JsonStringDeserializationPolicy, jsonObject[key]);
+            }
+            else if (key === 'stringSerializationPolicy') {
+                this.clientConfig.serializationConfig
+                    .stringSerializationPolicy = Util_1.tryGetEnum(StringSerializationPolicy_1.StringSerializationPolicy, jsonObject[key]);
+            }
+        }
+    };
+    ConfigBuilder.prototype.handleSerializers = function (jsonObject) {
+        var serializersArray = Util_1.tryGetArray(jsonObject);
+        for (var index in serializersArray) {
+            var serializer = serializersArray[index];
+            this.clientConfig.serializationConfig.customSerializerConfigs[serializer.typeId] = this.parseImportConfig(serializer);
+        }
+    };
+    ConfigBuilder.prototype.handleNearCaches = function (jsonObject) {
+        var nearCachesArray = Util_1.tryGetArray(jsonObject);
+        for (var index in nearCachesArray) {
+            var ncConfig = nearCachesArray[index];
+            var nearCacheConfig = new NearCacheConfig_1.NearCacheConfig();
+            for (var name in ncConfig) {
+                if (name === 'name') {
+                    nearCacheConfig.name = Util_1.tryGetString(ncConfig[name]);
+                }
+                else if (name === 'invalidateOnChange') {
+                    nearCacheConfig.invalidateOnChange = Util_1.tryGetBoolean(ncConfig[name]);
+                }
+                else if (name === 'maxIdleSeconds') {
+                    nearCacheConfig.maxIdleSeconds = Util_1.tryGetNumber(ncConfig[name]);
+                }
+                else if (name === 'inMemoryFormat') {
+                    nearCacheConfig.inMemoryFormat = Util_1.tryGetEnum(InMemoryFormat_1.InMemoryFormat, ncConfig[name]);
+                }
+                else if (name === 'timeToLiveSeconds') {
+                    nearCacheConfig.timeToLiveSeconds = Util_1.tryGetNumber(ncConfig[name]);
+                }
+                else if (name === 'evictionPolicy') {
+                    nearCacheConfig.evictionPolicy = Util_1.tryGetEnum(EvictionPolicy_1.EvictionPolicy, ncConfig[name]);
+                }
+                else if (name === 'evictionMaxSize') {
+                    nearCacheConfig.evictionMaxSize = Util_1.tryGetNumber(ncConfig[name]);
+                }
+                else if (name === 'evictionSamplingCount') {
+                    nearCacheConfig.evictionSamplingCount = Util_1.tryGetNumber(ncConfig[name]);
+                }
+                else if (name === 'evictionSamplingPoolSize') {
+                    nearCacheConfig.evictionSamplingPoolSize = Util_1.tryGetNumber(ncConfig[name]);
+                }
+            }
+            this.clientConfig.nearCacheConfigs[nearCacheConfig.name] = nearCacheConfig;
+        }
+    };
+    ConfigBuilder.prototype.handleReliableTopics = function (jsonObject) {
+        var rtConfigsArray = Util_1.tryGetArray(jsonObject);
+        for (var index in rtConfigsArray) {
+            var jsonRtCfg = rtConfigsArray[index];
+            var reliableTopicConfig = new ReliableTopicConfig_1.ReliableTopicConfig();
+            for (var name in jsonRtCfg) {
+                if (name === 'name') {
+                    reliableTopicConfig.name = jsonRtCfg[name];
+                }
+                else if (name === 'readBatchSize') {
+                    reliableTopicConfig.readBatchSize = jsonRtCfg[name];
+                }
+                else if (name === 'overloadPolicy') {
+                    reliableTopicConfig.overloadPolicy = Util_1.tryGetEnum(TopicOverloadPolicy_1.TopicOverloadPolicy, jsonRtCfg[name]);
+                }
+            }
+            this.clientConfig.reliableTopicConfigs[reliableTopicConfig.name] = reliableTopicConfig;
+        }
+    };
+    ConfigBuilder.prototype.handleFlakeIds = function (jsonObject) {
+        var flakeIdsArray = Util_1.tryGetArray(jsonObject);
+        for (var index in flakeIdsArray) {
+            var fidConfig = flakeIdsArray[index];
+            var flakeIdConfig = new FlakeIdGeneratorConfig_1.FlakeIdGeneratorConfig();
+            for (var name in fidConfig) {
+                if (name === 'name') {
+                    flakeIdConfig.name = Util_1.tryGetString(fidConfig[name]);
+                }
+                else if (name === 'prefetchCount') {
+                    flakeIdConfig.prefetchCount = Util_1.tryGetNumber(fidConfig[name]);
+                }
+                else if (name === 'prefetchValidityMillis') {
+                    flakeIdConfig.prefetchValidityMillis = Util_1.tryGetNumber(fidConfig[name]);
+                }
+            }
+            this.clientConfig.flakeIdGeneratorConfigs[flakeIdConfig.name] = flakeIdConfig;
+        }
+    };
+    return ConfigBuilder;
+}());
+exports.ConfigBuilder = ConfigBuilder;

package/lib/config/ConfigPatternMatcher.d.ts

@@ -0,0 +1,12 @@
+export declare class ConfigPatternMatcher {
+    /**
+     *
+     * @param configPatterns
+     * @param itemName
+     * @throws
+     * @returns `null` if there is no matching pattern
+     *          the best matching pattern otherwis
+     */
+    matches(configPatterns: string[], itemName: string): string;
+    getMatchingPoint(pattern: string, itemName: string): number;
+}

package/lib/config/ConfigPatternMatcher.js

@@ -0,0 +1,70 @@
+"use strict";
+/*
+ * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var HazelcastError_1 = require("../HazelcastError");
+var ConfigPatternMatcher = /** @class */ (function () {
+    function ConfigPatternMatcher() {
+    }
+    /**
+     *
+     * @param configPatterns
+     * @param itemName
+     * @throws
+     * @returns `null` if there is no matching pattern
+     *          the best matching pattern otherwis
+     */
+    ConfigPatternMatcher.prototype.matches = function (configPatterns, itemName) {
+        var _this = this;
+        var bestMatchingPoint = -1;
+        var matchingPattern = null;
+        var duplicatePattern = null;
+        configPatterns.forEach(function (pattern) {
+            var currentPoint = _this.getMatchingPoint(pattern, itemName);
+            if (currentPoint > bestMatchingPoint) {
+                bestMatchingPoint = currentPoint;
+                matchingPattern = pattern;
+                duplicatePattern = null;
+            }
+            else if (currentPoint === bestMatchingPoint && matchingPattern != null) {
+                duplicatePattern = matchingPattern;
+                matchingPattern = pattern;
+            }
+        });
+        if (duplicatePattern != null) {
+            throw new HazelcastError_1.ConfigurationError('Found ambiguous configurations for item ' + itemName + ': "' + matchingPattern +
+                '" vs "' + duplicatePattern + '". Please specify your configuration.');
+        }
+        return matchingPattern;
+    };
+    ConfigPatternMatcher.prototype.getMatchingPoint = function (pattern, itemName) {
+        var index = pattern.indexOf('*');
+        if (index === -1) {
+            return -1;
+        }
+        var firstPart = pattern.substring(0, index);
+        if (!itemName.startsWith(firstPart)) {
+            return -1;
+        }
+        var secondPart = pattern.substring(index + 1);
+        if (!itemName.endsWith(secondPart)) {
+            return -1;
+        }
+        return firstPart.length + secondPart.length;
+    };
+    return ConfigPatternMatcher;
+}());
+exports.ConfigPatternMatcher = ConfigPatternMatcher;

package/lib/config/EvictionPolicy.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Represents the format that objects are kept in this client's memory.
+ */
+export declare enum EvictionPolicy {
+    NONE = 0,
+    LRU = 1,
+    LFU = 2,
+    RANDOM = 3,
+}

package/lib/config/EvictionPolicy.js

@@ -0,0 +1,27 @@
+"use strict";
+/*
+ * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Represents the format that objects are kept in this client's memory.
+ */
+var EvictionPolicy;
+(function (EvictionPolicy) {
+    EvictionPolicy[EvictionPolicy["NONE"] = 0] = "NONE";
+    EvictionPolicy[EvictionPolicy["LRU"] = 1] = "LRU";
+    EvictionPolicy[EvictionPolicy["LFU"] = 2] = "LFU";
+    EvictionPolicy[EvictionPolicy["RANDOM"] = 3] = "RANDOM";
+})(EvictionPolicy = exports.EvictionPolicy || (exports.EvictionPolicy = {}));