@celerispay/hazelcast-client 3.12.5-1

package/lib/nearcache/RepairingTask.js

@@ -0,0 +1,117 @@
+"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 assert = require("assert");
+var Long = require("long");
+var MetadataFetcher_1 = require("./MetadataFetcher");
+var RepairingHandler_1 = require("./RepairingHandler");
+var Promise = require("bluebird");
+var PROPERTY_MAX_RECONCILIATION_INTERVAL_SECONDS = 'hazelcast.invalidation.reconciliation.interval.seconds';
+var PROPERTY_MIN_RECONCILIATION_INTERVAL_SECONDS = 'hazelcast.invalidation.min.reconciliation.interval.seconds';
+var PROPERTY_MAX_TOLERATED_MISS_COUNT = 'hazelcast.invalidation.max.tolerated.miss.count';
+var RepairingTask = /** @class */ (function () {
+    function RepairingTask(client) {
+        this.client = client;
+        this.logger = this.client.getLoggingService().getLogger();
+        var config = this.client.getConfig();
+        this.minAllowedReconciliationSeconds = config.properties[PROPERTY_MIN_RECONCILIATION_INTERVAL_SECONDS];
+        var requestedReconciliationSeconds = config.properties[PROPERTY_MAX_RECONCILIATION_INTERVAL_SECONDS];
+        this.reconcilliationInterval = this.getReconciliationIntervalMillis(requestedReconciliationSeconds);
+        this.handlers = new Map();
+        this.localUuid = this.client.getLocalEndpoint().uuid;
+        this.maxToleratedMissCount = config.properties[PROPERTY_MAX_TOLERATED_MISS_COUNT];
+        this.metadataFetcher = new MetadataFetcher_1.MetadataFetcher(client);
+        this.partitionCount = this.client.getPartitionService().getPartitionCount();
+    }
+    RepairingTask.prototype.registerAndGetHandler = function (objectName, nearCache) {
+        var _this = this;
+        var handler = this.handlers.get(objectName);
+        if (handler !== undefined) {
+            return Promise.resolve(handler);
+        }
+        handler = new RepairingHandler_1.RepairingHandler(objectName, this.client.getPartitionService(), nearCache, this.localUuid);
+        return this.metadataFetcher.initHandler(handler).then(function () {
+            _this.handlers.set(objectName, handler);
+            if (_this.antientropyTaskHandle === undefined) {
+                _this.start();
+            }
+            return handler;
+        });
+    };
+    RepairingTask.prototype.deregisterHandler = function (objectName) {
+        this.handlers.delete(objectName);
+    };
+    RepairingTask.prototype.start = function () {
+        assert(this.reconcilliationInterval > 0);
+        this.antientropyTaskHandle = setInterval(this.antiEntropyTask.bind(this), this.reconcilliationInterval);
+    };
+    RepairingTask.prototype.shutdown = function () {
+        if (this.antientropyTaskHandle != null) {
+            clearInterval(this.antientropyTaskHandle);
+        }
+    };
+    RepairingTask.prototype.antiEntropyTask = function () {
+        var _this = this;
+        if (this.client.getLifecycleService().isRunning()) {
+            this.handlers.forEach(function (handler) {
+                if (_this.isAboveMaxToleratedMissCount(handler)) {
+                    _this.updateLastKnownStaleSequences(handler);
+                }
+            });
+            this.metadataFetcher.fetchMetadata(this.handlers);
+        }
+        else {
+            this.shutdown();
+            this.logger.debug('RepairingTask', 'Anti entropy task was on although client was not running.' +
+                'Anti entropy task was shutdown forcibly.');
+        }
+    };
+    RepairingTask.prototype.isAboveMaxToleratedMissCount = function (handler) {
+        var totalMissCount = Long.fromNumber(0);
+        for (var i = 0; i < this.partitionCount; i++) {
+            var added = handler.getMetadataContainer(i).getMissedSequenceCount();
+            totalMissCount = totalMissCount.add(added);
+            if (totalMissCount.greaterThanOrEqual(this.maxToleratedMissCount)) {
+                return true;
+            }
+        }
+        return false;
+    };
+    RepairingTask.prototype.updateLastKnownStaleSequences = function (handler) {
+        for (var i = 0; i < this.partitionCount; i++) {
+            var container = handler.getMetadataContainer(i);
+            var missedCount = container.getMissedSequenceCount();
+            if (missedCount.notEquals(0)) {
+                container.increaseMissedSequenceCount(missedCount.negate());
+                handler.updateLastKnownStaleSequence(container);
+            }
+        }
+    };
+    RepairingTask.prototype.getReconciliationIntervalMillis = function (seconds) {
+        if (seconds === 0 || seconds >= this.minAllowedReconciliationSeconds) {
+            return seconds * 1000;
+        }
+        else {
+            var message = 'Reconciliation interval can be at least ' + this.minAllowedReconciliationSeconds + ' seconds ' +
+                'if not 0. Configured interval is ' + seconds + ' seconds. ' +
+                'Note: configuring a value of 0 seconds disables the reconciliation task.';
+            throw new RangeError(message);
+        }
+    };
+    return RepairingTask;
+}());
+exports.RepairingTask = RepairingTask;

package/lib/nearcache/StaleReadDetector.d.ts

@@ -0,0 +1,7 @@
+import { DataRecord } from './DataRecord';
+import { MetadataContainer } from './MetadataContainer';
+export interface StaleReadDetector {
+    isStaleRead(key: any, record: DataRecord): boolean;
+    getPartitionId(key: any): number;
+    getMetadataContainer(partitionId: number): MetadataContainer;
+}

package/lib/nearcache/StaleReadDetector.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/nearcache/StaleReadDetectorImpl.d.ts

@@ -0,0 +1,13 @@
+import { PartitionService } from '../PartitionService';
+import { DataRecord } from './DataRecord';
+import { MetadataContainer } from './MetadataContainer';
+import { RepairingHandler } from './RepairingHandler';
+import { StaleReadDetector } from './StaleReadDetector';
+export declare class StaleReadDetectorImpl implements StaleReadDetector {
+    private readonly repairingHandler;
+    private readonly partitionService;
+    constructor(handler: RepairingHandler, partitionService: PartitionService);
+    isStaleRead(key: any, record: DataRecord): boolean;
+    getMetadataContainer(partitionId: number): MetadataContainer;
+    getPartitionId(key: any): number;
+}

package/lib/nearcache/StaleReadDetectorImpl.js

@@ -0,0 +1,62 @@
+"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 StaleReadDetectorImpl = /** @class */ (function () {
+    function StaleReadDetectorImpl(handler, partitionService) {
+        this.repairingHandler = handler;
+        this.partitionService = partitionService;
+    }
+    StaleReadDetectorImpl.prototype.isStaleRead = function (key, record) {
+        try {
+            var metadata = this.getMetadataContainer(this.getPartitionId(record.key));
+            // Add null checks to prevent errors during failover
+            if (!metadata || !metadata.getUuid()) {
+                // If metadata is not available, consider the read as potentially stale
+                // This can happen during failover when partition information is being updated
+                return true;
+            }
+            return !record.hasSameUuid(metadata.getUuid()) || record.getInvalidationSequence().lessThan(metadata.getStaleSequence());
+        }
+        catch (error) {
+            // During failover, partition service might not be fully initialized
+            // Consider the read as stale to be safe
+            return true;
+        }
+    };
+    StaleReadDetectorImpl.prototype.getMetadataContainer = function (partitionId) {
+        try {
+            return this.repairingHandler.getMetadataContainer(partitionId);
+        }
+        catch (error) {
+            // Return null if metadata container is not available
+            // This can happen during failover scenarios
+            return null;
+        }
+    };
+    StaleReadDetectorImpl.prototype.getPartitionId = function (key) {
+        try {
+            return this.partitionService.getPartitionId(key);
+        }
+        catch (error) {
+            // Return -1 if partition service is not available
+            // This can happen during failover scenarios
+            return -1;
+        }
+    };
+    return StaleReadDetectorImpl;
+}());
+exports.StaleReadDetectorImpl = StaleReadDetectorImpl;

package/lib/protocol/ClientProtocolErrorCodes.d.ts

@@ -0,0 +1,91 @@
+export declare class ClientProtocolErrorCodes {
+    static readonly UNDEFINED: number;
+    static readonly ARRAY_INDEX_OUT_OF_BOUNDS: number;
+    static readonly ARRAY_STORE: number;
+    static readonly AUTHENTICATION: number;
+    static readonly CACHE: number;
+    static readonly CACHE_LOADER: number;
+    static readonly CACHE_NOT_EXISTS: number;
+    static readonly CACHE_WRITER: number;
+    static readonly CALLER_NOT_MEMBER: number;
+    static readonly CANCELLATION: number;
+    static readonly CLASS_CAST: number;
+    static readonly CLASS_NOT_FOUND: number;
+    static readonly CONCURRENT_MODIFICATION: number;
+    static readonly CONFIG_MISMATCH: number;
+    static readonly CONFIGURATION: number;
+    static readonly DISTRIBUTED_OBJECT_DESTROYED: number;
+    static readonly DUPLICATE_INSTANCE_NAME: number;
+    static readonly EOF: number;
+    static readonly ENTRY_PROCESSOR: number;
+    static readonly EXECUTION: number;
+    static readonly HAZELCAST: number;
+    static readonly HAZELCAST_INSTANCE_NOT_ACTIVE: number;
+    static readonly HAZELCAST_OVERLOAD: number;
+    static readonly HAZELCAST_SERIALIZATION: number;
+    static readonly IO: number;
+    static readonly ILLEGAL_ARGUMENT: number;
+    static readonly ILLEGAL_ACCESS_EXCEPTION: number;
+    static readonly ILLEGAL_ACCESS_ERROR: number;
+    static readonly ILLEGAL_MONITOR_STATE: number;
+    static readonly ILLEGAL_STATE: number;
+    static readonly ILLEGAL_THREAD_STATE: number;
+    static readonly INDEX_OUT_OF_BOUNDS: number;
+    static readonly INTERRUPTED: number;
+    static readonly INVALID_ADDRESS: number;
+    static readonly INVALID_CONFIGURATION: number;
+    static readonly MEMBER_LEFT: number;
+    static readonly NEGATIVE_ARRAY_SIZE: number;
+    static readonly NO_SUCH_ELEMENT: number;
+    static readonly NOT_SERIALIZABLE: number;
+    static readonly NULL_POINTER: number;
+    static readonly OPERATION_TIMEOUT: number;
+    static readonly PARTITION_MIGRATING: number;
+    static readonly QUERY: number;
+    static readonly QUERY_RESULT_SIZE_EXCEEDED: number;
+    static readonly QUORUM: number;
+    static readonly REACHED_MAX_SIZE: number;
+    static readonly REJECTED_EXECUTION: number;
+    static readonly REMOTE_MAP_REDUCE: number;
+    static readonly RESPONSE_ALREADY_SENT: number;
+    static readonly RETRYABLE_HAZELCAST: number;
+    static readonly RETRYABLE_IO: number;
+    static readonly RUNTIME: number;
+    static readonly SECURITY: number;
+    static readonly SOCKET: number;
+    static readonly STALE_SEQUENCE: number;
+    static readonly TARGET_DISCONNECTED: number;
+    static readonly TARGET_NOT_MEMBER: number;
+    static readonly TIMEOUT: number;
+    static readonly TOPIC_OVERLOAD: number;
+    static readonly TOPOLOGY_CHANGED: number;
+    static readonly TRANSACTION: number;
+    static readonly TRANSACTION_NOT_ACTIVE: number;
+    static readonly TRANSACTION_TIMED_OUT: number;
+    static readonly URI_SYNTAX: number;
+    static readonly UTF_DATA_FORMAT: number;
+    static readonly UNSUPPORTED_OPERATION: number;
+    static readonly WRONG_TARGET: number;
+    static readonly XA: number;
+    static readonly ACCESS_CONTROL: number;
+    static readonly LOGIN: number;
+    static readonly UNSUPPORTED_CALLBACK: number;
+    static readonly NO_DATA_MEMBER: number;
+    static readonly REPLICATED_MAP_CANT_BE_CREATED: number;
+    static readonly MAX_MESSAGE_SIZE_EXCEEDED: number;
+    static readonly WAN_REPLICATION_QUEUE_FULL: number;
+    static readonly ASSERTION_ERROR: number;
+    static readonly OUT_OF_MEMORY_ERROR: number;
+    static readonly STACK_OVERFLOW_ERROR: number;
+    static readonly NATIVE_OUT_OF_MEMORY_ERROR: number;
+    static readonly SERVICE_NOT_FOUND: number;
+    static readonly STALE_TASK_ID: number;
+    static readonly DUPLICATE_TASK: number;
+    static readonly STALE_TASK: number;
+    static readonly LOCAL_MEMBER_RESET: number;
+    static readonly INDETERMINATE_OPERATION_STATE: number;
+    static readonly FLAKE_ID_NODE_ID_OUT_OF_RANGE_EXCEPTION: number;
+    static readonly TARGET_NOT_REPLICA_EXCEPTION: number;
+    static readonly MUTATION_DISALLOWED_EXCEPTION: number;
+    static readonly CONSISTENCY_LOST_EXCEPTION: number;
+}

package/lib/protocol/ClientProtocolErrorCodes.js

@@ -0,0 +1,112 @@
+"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 ClientProtocolErrorCodes = /** @class */ (function () {
+    function ClientProtocolErrorCodes() {
+    }
+    ClientProtocolErrorCodes.UNDEFINED = 0;
+    ClientProtocolErrorCodes.ARRAY_INDEX_OUT_OF_BOUNDS = 1;
+    ClientProtocolErrorCodes.ARRAY_STORE = 2;
+    ClientProtocolErrorCodes.AUTHENTICATION = 3;
+    ClientProtocolErrorCodes.CACHE = 4;
+    ClientProtocolErrorCodes.CACHE_LOADER = 5;
+    ClientProtocolErrorCodes.CACHE_NOT_EXISTS = 6;
+    ClientProtocolErrorCodes.CACHE_WRITER = 7;
+    ClientProtocolErrorCodes.CALLER_NOT_MEMBER = 8;
+    ClientProtocolErrorCodes.CANCELLATION = 9;
+    ClientProtocolErrorCodes.CLASS_CAST = 10;
+    ClientProtocolErrorCodes.CLASS_NOT_FOUND = 11;
+    ClientProtocolErrorCodes.CONCURRENT_MODIFICATION = 12;
+    ClientProtocolErrorCodes.CONFIG_MISMATCH = 13;
+    ClientProtocolErrorCodes.CONFIGURATION = 14;
+    ClientProtocolErrorCodes.DISTRIBUTED_OBJECT_DESTROYED = 15;
+    ClientProtocolErrorCodes.DUPLICATE_INSTANCE_NAME = 16;
+    ClientProtocolErrorCodes.EOF = 17;
+    ClientProtocolErrorCodes.ENTRY_PROCESSOR = 18;
+    ClientProtocolErrorCodes.EXECUTION = 19;
+    ClientProtocolErrorCodes.HAZELCAST = 20;
+    ClientProtocolErrorCodes.HAZELCAST_INSTANCE_NOT_ACTIVE = 21;
+    ClientProtocolErrorCodes.HAZELCAST_OVERLOAD = 22;
+    ClientProtocolErrorCodes.HAZELCAST_SERIALIZATION = 23;
+    ClientProtocolErrorCodes.IO = 24;
+    ClientProtocolErrorCodes.ILLEGAL_ARGUMENT = 25;
+    ClientProtocolErrorCodes.ILLEGAL_ACCESS_EXCEPTION = 26;
+    ClientProtocolErrorCodes.ILLEGAL_ACCESS_ERROR = 27;
+    ClientProtocolErrorCodes.ILLEGAL_MONITOR_STATE = 28;
+    ClientProtocolErrorCodes.ILLEGAL_STATE = 29;
+    ClientProtocolErrorCodes.ILLEGAL_THREAD_STATE = 30;
+    ClientProtocolErrorCodes.INDEX_OUT_OF_BOUNDS = 31;
+    ClientProtocolErrorCodes.INTERRUPTED = 32;
+    ClientProtocolErrorCodes.INVALID_ADDRESS = 33;
+    ClientProtocolErrorCodes.INVALID_CONFIGURATION = 34;
+    ClientProtocolErrorCodes.MEMBER_LEFT = 35;
+    ClientProtocolErrorCodes.NEGATIVE_ARRAY_SIZE = 36;
+    ClientProtocolErrorCodes.NO_SUCH_ELEMENT = 37;
+    ClientProtocolErrorCodes.NOT_SERIALIZABLE = 38;
+    ClientProtocolErrorCodes.NULL_POINTER = 39;
+    ClientProtocolErrorCodes.OPERATION_TIMEOUT = 40;
+    ClientProtocolErrorCodes.PARTITION_MIGRATING = 41;
+    ClientProtocolErrorCodes.QUERY = 42;
+    ClientProtocolErrorCodes.QUERY_RESULT_SIZE_EXCEEDED = 43;
+    ClientProtocolErrorCodes.QUORUM = 44;
+    ClientProtocolErrorCodes.REACHED_MAX_SIZE = 45;
+    ClientProtocolErrorCodes.REJECTED_EXECUTION = 46;
+    ClientProtocolErrorCodes.REMOTE_MAP_REDUCE = 47;
+    ClientProtocolErrorCodes.RESPONSE_ALREADY_SENT = 48;
+    ClientProtocolErrorCodes.RETRYABLE_HAZELCAST = 49;
+    ClientProtocolErrorCodes.RETRYABLE_IO = 50;
+    ClientProtocolErrorCodes.RUNTIME = 51;
+    ClientProtocolErrorCodes.SECURITY = 52;
+    ClientProtocolErrorCodes.SOCKET = 53;
+    ClientProtocolErrorCodes.STALE_SEQUENCE = 54;
+    ClientProtocolErrorCodes.TARGET_DISCONNECTED = 55;
+    ClientProtocolErrorCodes.TARGET_NOT_MEMBER = 56;
+    ClientProtocolErrorCodes.TIMEOUT = 57;
+    ClientProtocolErrorCodes.TOPIC_OVERLOAD = 58;
+    ClientProtocolErrorCodes.TOPOLOGY_CHANGED = 59;
+    ClientProtocolErrorCodes.TRANSACTION = 60;
+    ClientProtocolErrorCodes.TRANSACTION_NOT_ACTIVE = 61;
+    ClientProtocolErrorCodes.TRANSACTION_TIMED_OUT = 62;
+    ClientProtocolErrorCodes.URI_SYNTAX = 63;
+    ClientProtocolErrorCodes.UTF_DATA_FORMAT = 64;
+    ClientProtocolErrorCodes.UNSUPPORTED_OPERATION = 65;
+    ClientProtocolErrorCodes.WRONG_TARGET = 66;
+    ClientProtocolErrorCodes.XA = 67;
+    ClientProtocolErrorCodes.ACCESS_CONTROL = 68;
+    ClientProtocolErrorCodes.LOGIN = 69;
+    ClientProtocolErrorCodes.UNSUPPORTED_CALLBACK = 70;
+    ClientProtocolErrorCodes.NO_DATA_MEMBER = 71;
+    ClientProtocolErrorCodes.REPLICATED_MAP_CANT_BE_CREATED = 72;
+    ClientProtocolErrorCodes.MAX_MESSAGE_SIZE_EXCEEDED = 73;
+    ClientProtocolErrorCodes.WAN_REPLICATION_QUEUE_FULL = 74;
+    ClientProtocolErrorCodes.ASSERTION_ERROR = 75;
+    ClientProtocolErrorCodes.OUT_OF_MEMORY_ERROR = 76;
+    ClientProtocolErrorCodes.STACK_OVERFLOW_ERROR = 77;
+    ClientProtocolErrorCodes.NATIVE_OUT_OF_MEMORY_ERROR = 78;
+    ClientProtocolErrorCodes.SERVICE_NOT_FOUND = 79;
+    ClientProtocolErrorCodes.STALE_TASK_ID = 80;
+    ClientProtocolErrorCodes.DUPLICATE_TASK = 81;
+    ClientProtocolErrorCodes.STALE_TASK = 82;
+    ClientProtocolErrorCodes.LOCAL_MEMBER_RESET = 83;
+    ClientProtocolErrorCodes.INDETERMINATE_OPERATION_STATE = 84;
+    ClientProtocolErrorCodes.FLAKE_ID_NODE_ID_OUT_OF_RANGE_EXCEPTION = 85;
+    ClientProtocolErrorCodes.TARGET_NOT_REPLICA_EXCEPTION = 86;
+    ClientProtocolErrorCodes.MUTATION_DISALLOWED_EXCEPTION = 87;
+    ClientProtocolErrorCodes.CONSISTENCY_LOST_EXCEPTION = 88;
+    return ClientProtocolErrorCodes;
+}());
+exports.ClientProtocolErrorCodes = ClientProtocolErrorCodes;

package/lib/protocol/ErrorCodec.d.ts

@@ -0,0 +1,11 @@
+import ClientMessage = require('../ClientMessage');
+import { StackTraceElementCodec } from './StackTraceElementCodec';
+export declare class ErrorCodec {
+    errorCode: number;
+    className: string;
+    message: string;
+    stackTrace: StackTraceElementCodec[];
+    causeErrorCode: number;
+    causeClassName: string;
+    static decode(clientMessage: ClientMessage): ErrorCodec;
+}

package/lib/protocol/ErrorCodec.js

@@ -0,0 +1,50 @@
+"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 StackTraceElementCodec_1 = require("./StackTraceElementCodec");
+var ErrorCodec = /** @class */ (function () {
+    function ErrorCodec() {
+        this.errorCode = null;
+        this.className = null;
+        this.message = null;
+        this.stackTrace = [];
+        this.causeErrorCode = null;
+        this.causeClassName = null;
+    }
+    ErrorCodec.decode = function (clientMessage) {
+        var exception = new ErrorCodec();
+        exception.errorCode = clientMessage.readInt32();
+        exception.className = clientMessage.readString();
+        var isMessageNull = clientMessage.readBoolean();
+        if (!isMessageNull) {
+            exception.message = clientMessage.readString();
+        }
+        var stackTraceDepth = clientMessage.readInt32();
+        exception.stackTrace = [];
+        for (var i = 0; i < stackTraceDepth; i++) {
+            exception.stackTrace.push(StackTraceElementCodec_1.StackTraceElementCodec.decode(clientMessage));
+        }
+        exception.causeErrorCode = clientMessage.readInt32();
+        var causeClassNameNull = clientMessage.readBoolean();
+        if (!causeClassNameNull) {
+            exception.causeClassName = clientMessage.readString();
+        }
+        return exception;
+    };
+    return ErrorCodec;
+}());
+exports.ErrorCodec = ErrorCodec;

package/lib/protocol/ErrorFactory.d.ts

@@ -0,0 +1,8 @@
+import ClientMessage = require('../ClientMessage');
+export declare class ClientErrorFactory {
+    private codeToErrorConstructor;
+    constructor();
+    createErrorFromClientMessage(clientMessage: ClientMessage): Error;
+    createError(errorCode: number, className: string, message: string, cause: Error): Error;
+    private register(code, errorFactory);
+}

package/lib/protocol/ErrorFactory.js

@@ -0,0 +1,92 @@
+"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 ClientProtocolErrorCodes_1 = require("./ClientProtocolErrorCodes");
+var ErrorCodec_1 = require("./ErrorCodec");
+var ClientErrorFactory = /** @class */ (function () {
+    function ClientErrorFactory() {
+        this.codeToErrorConstructor = new Map();
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.ARRAY_INDEX_OUT_OF_BOUNDS, function (m, c) { return new RangeError(m); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.ARRAY_STORE, function (m, c) { return new TypeError(m); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.AUTHENTICATION, function (m, c) { return new HazelcastError_1.AuthenticationError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.CALLER_NOT_MEMBER, function (m, c) { return new HazelcastError_1.CallerNotMemberError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.CANCELLATION, function (m, c) { return new HazelcastError_1.CancellationError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.CLASS_CAST, function (m, c) { return new HazelcastError_1.ClassCastError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.CLASS_NOT_FOUND, function (m, c) { return new HazelcastError_1.ClassNotFoundError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.CONCURRENT_MODIFICATION, function (m, c) { return new HazelcastError_1.ConcurrentModificationError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.CONFIG_MISMATCH, function (m, c) { return new HazelcastError_1.ConfigMismatchError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.CONFIGURATION, function (m, c) { return new HazelcastError_1.ConfigurationError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.DISTRIBUTED_OBJECT_DESTROYED, function (m, c) { return new HazelcastError_1.DistributedObjectDestroyedError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.DUPLICATE_INSTANCE_NAME, function (m, c) { return new HazelcastError_1.DuplicateInstanceNameError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.EOF, function (m, c) { return new HazelcastError_1.IOError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.HAZELCAST, function (m, c) { return new HazelcastError_1.HazelcastError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.HAZELCAST_INSTANCE_NOT_ACTIVE, function (m, c) { return new HazelcastError_1.HazelcastInstanceNotActiveError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.HAZELCAST_OVERLOAD, function (m, c) { return new HazelcastError_1.HazelcastError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.HAZELCAST_SERIALIZATION, function (m, c) { return new HazelcastError_1.HazelcastSerializationError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.IO, function (m, c) { return new HazelcastError_1.IOError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.ILLEGAL_ARGUMENT, function (m, c) { return new TypeError(m); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.ILLEGAL_STATE, function (m, c) { return new HazelcastError_1.IllegalStateError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.INDEX_OUT_OF_BOUNDS, function (m, c) { return new RangeError(m); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.INTERRUPTED, function (m, c) { return new Error(m); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.INVALID_ADDRESS, function (m, c) { return new TypeError(m); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.INVALID_CONFIGURATION, function (m, c) { return new TypeError(m); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.MEMBER_LEFT, function (m, c) { return new HazelcastError_1.MemberLeftError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.NEGATIVE_ARRAY_SIZE, function (m, c) { return new RangeError(m); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.NO_SUCH_ELEMENT, function (m, c) { return new ReferenceError(m); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.NOT_SERIALIZABLE, function (m, c) { return new HazelcastError_1.IOError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.NULL_POINTER, function (m, c) { return new ReferenceError(m); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.OPERATION_TIMEOUT, function (m, c) { return new HazelcastError_1.InvocationTimeoutError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.PARTITION_MIGRATING, function (m, c) { return new HazelcastError_1.PartitionMigratingError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.QUERY, function (m, c) { return new HazelcastError_1.QueryError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.QUERY_RESULT_SIZE_EXCEEDED, function (m, c) { return new HazelcastError_1.QueryError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.QUORUM, function (m, c) { return new HazelcastError_1.QuorumError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.RETRYABLE_HAZELCAST, function (m, c) { return new HazelcastError_1.RetryableHazelcastError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.RETRYABLE_IO, function (m, c) { return new HazelcastError_1.RetryableIOError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.SOCKET, function (m, c) { return new HazelcastError_1.IOError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.STALE_SEQUENCE, function (m, c) { return new HazelcastError_1.StaleSequenceError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.TARGET_DISCONNECTED, function (m, c) { return new HazelcastError_1.TargetDisconnectedError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.TARGET_NOT_MEMBER, function (m, c) { return new HazelcastError_1.TargetNotMemberError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.TOPIC_OVERLOAD, function (m, c) { return new HazelcastError_1.TopicOverloadError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.TRANSACTION, function (m, c) { return new HazelcastError_1.TransactionError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.TRANSACTION_NOT_ACTIVE, function (m, c) { return new HazelcastError_1.TransactionNotActiveError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.TRANSACTION_TIMED_OUT, function (m, c) { return new HazelcastError_1.TransactionTimedOutError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.UNSUPPORTED_OPERATION, function (m, c) { return new HazelcastError_1.UnsupportedOperationError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.NO_DATA_MEMBER, function (m, c) { return new HazelcastError_1.NoDataMemberInClusterError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.STALE_TASK_ID, function (m, c) { return new HazelcastError_1.StaleTaskIdError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.FLAKE_ID_NODE_ID_OUT_OF_RANGE_EXCEPTION, function (m, c) { return new HazelcastError_1.NodeIdOutOfRangeError(m, c); });
+        this.register(ClientProtocolErrorCodes_1.ClientProtocolErrorCodes.CONSISTENCY_LOST_EXCEPTION, function (m, c) { return new HazelcastError_1.ConsistencyLostError(m, c); });
+    }
+    ClientErrorFactory.prototype.createErrorFromClientMessage = function (clientMessage) {
+        var errorCodec = ErrorCodec_1.ErrorCodec.decode(clientMessage);
+        return this.createError(errorCodec.errorCode, errorCodec.className, errorCodec.message, null);
+    };
+    ClientErrorFactory.prototype.createError = function (errorCode, className, message, cause) {
+        var factoryFunc = this.codeToErrorConstructor.get(errorCode);
+        if (factoryFunc != null) {
+            return factoryFunc(message, cause);
+        }
+        else {
+            return new HazelcastError_1.UndefinedErrorCodeError(message, className);
+        }
+    };
+    ClientErrorFactory.prototype.register = function (code, errorFactory) {
+        this.codeToErrorConstructor.set(code, errorFactory);
+    };
+    return ClientErrorFactory;
+}());
+exports.ClientErrorFactory = ClientErrorFactory;

package/lib/protocol/StackTraceElementCodec.d.ts

@@ -0,0 +1,8 @@
+import ClientMessage = require('../ClientMessage');
+export declare class StackTraceElementCodec {
+    declaringClass: string;
+    methodName: string;
+    fileName: string;
+    lineNumber: number;
+    static decode(payload: ClientMessage): StackTraceElementCodec;
+}

package/lib/protocol/StackTraceElementCodec.js

@@ -0,0 +1,38 @@
+"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 StackTraceElementCodec = /** @class */ (function () {
+    function StackTraceElementCodec() {
+        this.declaringClass = null;
+        this.methodName = null;
+        this.fileName = null;
+        this.lineNumber = null;
+    }
+    StackTraceElementCodec.decode = function (payload) {
+        var stackTraceElement = new StackTraceElementCodec();
+        stackTraceElement.declaringClass = payload.readString();
+        stackTraceElement.methodName = payload.readString();
+        var fileNameNull = payload.readBoolean();
+        if (!fileNameNull) {
+            stackTraceElement.fileName = payload.readString();
+        }
+        stackTraceElement.lineNumber = payload.readInt32();
+        return stackTraceElement;
+    };
+    return StackTraceElementCodec;
+}());
+exports.StackTraceElementCodec = StackTraceElementCodec;

package/lib/proxy/AtomicLongProxy.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="long" />
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+import * as Long from 'long';
+import { IAtomicLong } from './IAtomicLong';
+import { PartitionSpecificProxy } from './PartitionSpecificProxy';
+export declare class AtomicLongProxy extends PartitionSpecificProxy implements IAtomicLong {
+    addAndGet(delta: Long | number): Promise<Long>;
+    compareAndSet(expect: Long | number, update: Long | number): Promise<boolean>;
+    decrementAndGet(): Promise<Long>;
+    get(): Promise<Long>;
+    getAndAdd(delta: Long | number): Promise<Long>;
+    getAndSet(newValue: Long | number): Promise<Long>;
+    incrementAndGet(): Promise<Long>;
+    getAndIncrement(): Promise<Long>;
+    set(newValue: Long | number): Promise<void>;
+}