@celerispay/hazelcast-client 3.12.5

package/lib/proxy/BaseProxy.js

@@ -0,0 +1,191 @@
+"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 BuildInfo_1 = require("../BuildInfo");
+/**
+ * Common super class for any proxy.
+ */
+var BaseProxy = /** @class */ (function () {
+    function BaseProxy(client, serviceName, name) {
+        this.client = client;
+        this.name = name;
+        this.serviceName = serviceName;
+    }
+    BaseProxy.prototype.getPartitionKey = function () {
+        return this.name;
+    };
+    /**
+     * Returns name of the proxy.
+     * @returns
+     */
+    BaseProxy.prototype.getName = function () {
+        return this.name;
+    };
+    /**
+     * Returns name of the service which this proxy belongs to.
+     * Refer to service field of {@link ProxyManager} for service names.
+     * @returns
+     */
+    BaseProxy.prototype.getServiceName = function () {
+        return this.serviceName;
+    };
+    /**
+     * Deletes the proxy object and frees allocated resources on cluster.
+     * @returns
+     */
+    BaseProxy.prototype.destroy = function () {
+        var _this = this;
+        return this.client.getProxyManager().destroyProxy(this.name, this.serviceName).then(function () {
+            return _this.postDestroy();
+        });
+    };
+    BaseProxy.prototype.postDestroy = function () {
+        return Promise.resolve();
+    };
+    /**
+     * Encodes a request from a codec and invokes it on owner node of given key.
+     * @param codec
+     * @param partitionKey
+     * @param codecArguments
+     * @returns
+     */
+    BaseProxy.prototype.encodeInvokeOnKey = function (codec, partitionKey) {
+        var codecArguments = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            codecArguments[_i - 2] = arguments[_i];
+        }
+        var partitionId = this.client.getPartitionService().getPartitionId(partitionKey);
+        return this.encodeInvokeOnPartition.apply(this, [codec, partitionId].concat(codecArguments));
+    };
+    /**
+     * Encodes a request from a codec and invokes it on owner node of given key.
+     * This method also overrides invocation timeout.
+     * @param timeoutMillis
+     * @param codec
+     * @param partitionKey
+     * @param codecArguments
+     * @returns
+     */
+    BaseProxy.prototype.encodeInvokeOnKeyWithTimeout = function (timeoutMillis, codec, partitionKey) {
+        var codecArguments = [];
+        for (var _i = 3; _i < arguments.length; _i++) {
+            codecArguments[_i - 3] = arguments[_i];
+        }
+        var partitionId = this.client.getPartitionService().getPartitionId(partitionKey);
+        return this.encodeInvokeOnPartitionWithTimeout.apply(this, [timeoutMillis, codec, partitionId].concat(codecArguments));
+    };
+    /**
+     * Encodes a request from a codec and invokes it on any node.
+     * @param codec
+     * @param codecArguments
+     * @returns
+     */
+    BaseProxy.prototype.encodeInvokeOnRandomTarget = function (codec) {
+        var codecArguments = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            codecArguments[_i - 1] = arguments[_i];
+        }
+        var clientMessage = codec.encodeRequest.apply(codec, [this.name].concat(codecArguments));
+        var invocationResponse = this.client.getInvocationService().invokeOnRandomTarget(clientMessage);
+        return this.createPromise(codec, invocationResponse);
+    };
+    BaseProxy.prototype.encodeInvokeOnAddress = function (codec, address) {
+        var codecArguments = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            codecArguments[_i - 2] = arguments[_i];
+        }
+        var clientMessage = codec.encodeRequest.apply(codec, [this.name].concat(codecArguments));
+        var invocation = this.client.getInvocationService().invokeOnTarget(clientMessage, address);
+        return this.createPromise(codec, invocation);
+    };
+    /**
+     * Encodes a request from a codec and invokes it on owner node of given partition.
+     * @param codec
+     * @param partitionId
+     * @param codecArguments
+     * @returns
+     */
+    BaseProxy.prototype.encodeInvokeOnPartition = function (codec, partitionId) {
+        var codecArguments = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            codecArguments[_i - 2] = arguments[_i];
+        }
+        var clientMessage = codec.encodeRequest.apply(codec, [this.name].concat(codecArguments));
+        var invocationResponse = this.client.getInvocationService()
+            .invokeOnPartition(clientMessage, partitionId);
+        return this.createPromise(codec, invocationResponse);
+    };
+    /**
+     * Encodes a request from a codec and invokes it on owner node of given partition.
+     * This method also overrides invocation timeout.
+     * @param codec
+     * @param partitionId
+     * @param codecArguments
+     * @returns
+     */
+    BaseProxy.prototype.encodeInvokeOnPartitionWithTimeout = function (timeoutMillis, codec, partitionId) {
+        var codecArguments = [];
+        for (var _i = 3; _i < arguments.length; _i++) {
+            codecArguments[_i - 3] = arguments[_i];
+        }
+        var clientMessage = codec.encodeRequest.apply(codec, [this.name].concat(codecArguments));
+        var invocationResponse = this.client.getInvocationService()
+            .invokeOnPartition(clientMessage, partitionId, timeoutMillis);
+        return this.createPromise(codec, invocationResponse);
+    };
+    /**
+     * Serializes an object according to serialization settings of the client.
+     * @param object
+     * @returns
+     */
+    BaseProxy.prototype.toData = function (object) {
+        return this.client.getSerializationService().toData(object);
+    };
+    /**
+     * De-serializes an object from binary form according to serialization settings of the client.
+     * @param data
+     * @returns {any}
+     */
+    BaseProxy.prototype.toObject = function (data) {
+        return this.client.getSerializationService().toObject(data);
+    };
+    BaseProxy.prototype.getConnectedServerVersion = function () {
+        var activeConnections = this.client.getConnectionManager().getActiveConnections();
+        for (var address in activeConnections) {
+            return activeConnections[address].getConnectedServerVersion();
+        }
+        return BuildInfo_1.BuildInfo.UNKNOWN_VERSION_ID;
+    };
+    BaseProxy.prototype.createPromise = function (codec, promise) {
+        var toObject = this.toObject.bind(this);
+        return promise.then(function (clientMessage) {
+            if (codec.decodeResponse) {
+                var raw = codec.decodeResponse(clientMessage, toObject);
+                var response = raw.response;
+                if (typeof response === 'undefined') {
+                    return raw;
+                }
+                else {
+                    return response;
+                }
+            }
+        });
+    };
+    return BaseProxy;
+}());
+exports.BaseProxy = BaseProxy;

package/lib/proxy/FlakeIdGenerator.d.ts

@@ -0,0 +1,47 @@
+/// <reference types="bluebird" />
+/// <reference types="long" />
+/**
+ * A cluster-wide unique ID generator. Generated IDs are `Long` primitive values
+ * and are k-ordered (roughly ordered). IDs are in the range from `0` to `Long.MAX_VALUE`.
+ * <p>
+ * The IDs contain timestamp component and a node ID component, which is assigned when the member
+ * joins the cluster. This allows the IDs to be ordered and unique without any coordination between
+ * members, which makes the generator safe even in split-brain scenario.
+ * <p>
+ * Timestamp component is in milliseconds since 1.1.2018, 0:00 UTC and has 41 bits. This caps
+ * the useful lifespan of the generator to little less than 70 years (until ~2088). The sequence component
+ * is 6 bits. If more than 64 IDs are requested in single millisecond, IDs will gracefully overflow to the next
+ * millisecond and uniqueness is guaranteed in this case. The implementation does not allow overflowing
+ * by more than 15 seconds, if IDs are requested at higher rate, the call will block. Note, however, that
+ * clients are able to generate even faster because each call goes to a different (random) member and
+ * the 64 IDs/ms limit is for single member.
+ *
+ * <em>Node ID overflow</em>
+ * It is possible to generate IDs on any member or client as long as there is at least one
+ * member with join version smaller than 2^16 in the cluster. The remedy is to restart the cluster:
+ * nodeId will be assigned from zero again. Uniqueness after the restart will be preserved thanks to
+ * the timestamp component.
+ *
+ * @requires Hazelcast 3.10
+ */
+import * as Promise from 'bluebird';
+import * as Long from 'long';
+import { DistributedObject } from '../DistributedObject';
+export interface FlakeIdGenerator extends DistributedObject {
+    /**
+     * Generates and returns a cluster-wide unique ID.
+     * <p>
+     * This method goes to a random member and gets a batch of IDs, which will then be returned
+     * locally for limited time. The pre-fetch size and the validity time can be configured, see
+     * {@link FlakeIdGeneratorConfig}.
+     * <p>
+     * <b>Note:</b> Values returned from this method may not be strictly ordered.
+     *
+     * @return new cluster-wide unique ID
+     *
+     * @throws HazelcastError if node ID for all members in the cluster is out of valid range.
+     *      See "Node ID overflow" note above
+     * @throws UnsupportedOperationError if the cluster version is below 3.10
+     */
+    newId(): Promise<Long>;
+}

package/lib/proxy/FlakeIdGenerator.js

@@ -0,0 +1,17 @@
+"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 });

package/lib/proxy/FlakeIdGeneratorProxy.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="bluebird" />
+/// <reference types="long" />
+import * as Promise from 'bluebird';
+import * as Long from 'long';
+import HazelcastClient from '../HazelcastClient';
+import { BaseProxy } from './BaseProxy';
+import { FlakeIdGenerator } from './FlakeIdGenerator';
+export declare class FlakeIdGeneratorProxy extends BaseProxy implements FlakeIdGenerator {
+    private autoBatcher;
+    private config;
+    constructor(client: HazelcastClient, serviceName: string, name: string);
+    newId(): Promise<Long>;
+}

package/lib/proxy/FlakeIdGeneratorProxy.js

@@ -0,0 +1,48 @@
+"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.
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var FlakeIdGeneratorNewIdBatchCodec_1 = require("../codec/FlakeIdGeneratorNewIdBatchCodec");
+var BaseProxy_1 = require("./BaseProxy");
+var AutoBatcher_1 = require("./flakeid/AutoBatcher");
+var FlakeIdGeneratorProxy = /** @class */ (function (_super) {
+    __extends(FlakeIdGeneratorProxy, _super);
+    function FlakeIdGeneratorProxy(client, serviceName, name) {
+        var _this = _super.call(this, client, serviceName, name) || this;
+        _this.config = client.getConfig().getFlakeIdGeneratorConfig(name);
+        _this.autoBatcher = new AutoBatcher_1.AutoBatcher(function () {
+            return _this.encodeInvokeOnRandomTarget(FlakeIdGeneratorNewIdBatchCodec_1.FlakeIdGeneratorNewIdBatchCodec, _this.config.prefetchCount).then(function (re) {
+                return new AutoBatcher_1.Batch(_this.config.prefetchValidityMillis, re.base, re.increment, re.batchSize);
+            });
+        });
+        return _this;
+    }
+    FlakeIdGeneratorProxy.prototype.newId = function () {
+        return this.autoBatcher.nextId();
+    };
+    return FlakeIdGeneratorProxy;
+}(BaseProxy_1.BaseProxy));
+exports.FlakeIdGeneratorProxy = FlakeIdGeneratorProxy;

package/lib/proxy/IAtomicLong.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="long" />
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+import * as Long from 'long';
+import { DistributedObject } from '../DistributedObject';
+export interface IAtomicLong extends DistributedObject {
+    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>;
+}

package/lib/proxy/IAtomicLong.js

@@ -0,0 +1,17 @@
+"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 });

package/lib/proxy/IList.d.ts

@@ -0,0 +1,132 @@
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+import { ItemListener } from '../core/ItemListener';
+import { ReadOnlyLazyList } from '../core/ReadOnlyLazyList';
+import { DistributedObject } from '../DistributedObject';
+export interface IList<E> extends DistributedObject {
+    /**
+     * Appends the specified element to the end of the list.
+     * @param element - element to be added
+     * @return `true` if this list has changed as a result of this operation, `false` otherwise.
+     */
+    add(element: E): Promise<boolean>;
+    /**
+     * Inserts the specified element at the specified index.
+     * Shifts the subsequent elements to the right.
+     * @param index position at which the element should be inserted
+     * @param element element to be inserted
+     */
+    addAt(index: number, element: E): Promise<void>;
+    /**
+     * Appends all elements in the specified array to the end of this list,
+     * @param elements array to be appended
+     * @return `true` if this list has changed as a result of this operation, `false` otherwise.
+     */
+    addAll(elements: E[]): Promise<boolean>;
+    /**
+     * Inserts all elements in the specified array at specified index, keeping the order of the array.
+     * Shifts the subsequent elements to the right.
+     * @param index position at which the array's elements should be inserted
+     * @param elements array to be inserted
+     * @return `true` if this list has changed as a result of this operation, `false` otherwise.
+     */
+    addAllAt(index: number, elements: E[]): Promise<boolean>;
+    /**
+     * Adds an item listener for this list.
+     * Listener will be invoked whenever an item is added to or removed from this list.
+     * @param listener object with listener functions
+     * @param includeValue `true` if updated item should be included in the event.
+     * @return registration ID of the listener.
+     */
+    addItemListener(listener: ItemListener<E>, includeValue: boolean): Promise<string>;
+    /**
+     * Clears this list.
+     */
+    clear(): Promise<void>;
+    /**
+     * Checks if the list contains given element.
+     * @param element
+     * @return `true` if this list contains an element that is equal the to given element, `false` otherwise.
+     */
+    contains(element: E): Promise<boolean>;
+    /**
+     * Checks if the list contains all of the given elements.
+     * @param elements - elements to be checked for presence in this list.
+     * @return `true` if this list contains all of the given elements, `false` otherwise.
+     */
+    containsAll(elements: E[]): Promise<boolean>;
+    /**
+     * Retrieves the element at given location.
+     * @param index index of the element to return.
+     * @return the element at that position.
+     */
+    get(index: number): Promise<E>;
+    /**
+     * Returns the position of first occurrence of the given element in this list.
+     * @param element element to search for
+     * @return the index of first occurrence of given element or `-1` if the list does not contain given element.
+     */
+    indexOf(element: E): Promise<number>;
+    /**
+     * Checks if this list is empty.
+     * @return `true` if this list contains no elements, `false` otherwise.
+     */
+    isEmpty(): Promise<boolean>;
+    /**
+     * Returns position of the last occurrence of the given element in this list.
+     * @param element
+     */
+    lastIndexOf(element: E): Promise<number>;
+    /**
+     * Removes the given element from this list.
+     * @param element element to be removed
+     * @return `true` if this list has changed as a result of this operation, `false` otherwise.
+     */
+    remove(element: E): Promise<boolean>;
+    /**
+     * Removes the element at the given index.
+     * @param index index of the element to be removed.
+     * @return the removed element.
+     */
+    removeAt(index: number): Promise<E>;
+    /**
+     * Removes given elements from the list.
+     * @param elements elements to be removed
+     * @return `true` if this list has changed as a result of this operation, `false` otherwise.
+     */
+    removeAll(elements: E[]): Promise<boolean>;
+    /**
+     * Removes an ItemListener from this list.
+     * @param listenerId registration ID of the listener to be removed.
+     * @return `true` if the item listener was successfully removed, `false` otherwise.
+     */
+    removeItemListener(listenerId: string): Promise<boolean>;
+    /**
+     * Removes all elements from this list except the ones contained in the given array.
+     * @param elements elements to retain
+     * @return `true` if this list has changed as a result of this operation, `false` otherwise.
+     */
+    retainAll(elements: E[]): Promise<boolean>;
+    /**
+     * Replaces the element at the specified position in this list with the specified element.
+     * @param index position of the element to be replaced
+     * @param element replacement element
+     * @return previous element at the given index.
+     */
+    set(index: number, element: E): Promise<E>;
+    /**
+     * Returns the number of elements in this list.
+     */
+    size(): Promise<number>;
+    /**
+     * Return a view of this list that contains elements between index numbers from `start` (inclusive) to `end` (exclusive)
+     * @param start start of the view
+     * @param end end of the view
+     * @return a view of this list that contains elements between index numbers from `start` (inclusive) to `end` (exclusive)
+     */
+    subList(start: number, end: number): Promise<ReadOnlyLazyList<E>>;
+    /**
+     * Returns an array that contains all elements of this list in proper sequence.
+     */
+    toArray(): Promise<E[]>;
+}

package/lib/proxy/IList.js

@@ -0,0 +1,17 @@
+"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 });

package/lib/proxy/ILock.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+import { DistributedObject } from '../DistributedObject';
+export interface ILock extends DistributedObject {
+    /**
+     * Acquires this lock, waiting indefinitely for it to become available.
+     * The returned promise will be resolved as soon as this lock is acquired.
+     * If lease time is specified then this lock will be held for
+     * the specified amount of time and then released automatically.
+     * Otherwise it will be held indefinitely up until the user invokes `unlock`.
+     * @param leaseMillis period of time in milliseconds for which this lock should be held.
+     */
+    lock(leaseMillis?: number): Promise<void>;
+    /**
+     * Tries to acquire this lock within a specified timeout.
+     * The returned promise will be resolved either when this lock is acquired or when timeout is reached.
+     * Setting timeout to -1 will make this method wait for the lock availability indefinitely.
+     * If lease time is specified then this lock will be held for
+     * the specified amount of time and then released automatically.
+     * Otherwise it will be held indefinitely up until the user invokes `unlock`.
+     * @param timeoutMillis period of time in milliseconds to wait for this lock to become available.
+     * @param leaseMillis period of time in milliseconds for which this lock should be held.
+     * @returns `true` if this lock was obtained in the specified time period, `false` otherwise.
+     */
+    tryLock(timeoutMillis?: number, leaseMillis?: number): Promise<boolean>;
+    /**
+     * Unlocks the lock.
+     */
+    unlock(): Promise<void>;
+    /**
+     * Forcefully unlocks the lock.
+     * Usually, the same client has to call `unlock` the same amount of times
+     * as the amount of times it has called `lock`, otherwise the lock will remain in locked state.
+     * This method will disregard the acquire count and release this lock immediately.
+     */
+    forceUnlock(): Promise<void>;
+    /**
+     * @returns `true` if this lock is currently in the locked state, `false` otherwise.
+     */
+    isLocked(): Promise<boolean>;
+    /**
+     * @returns `true` if this lock is currently held by this client, `false` otherwise.
+     */
+    isLockedByThisClient(): Promise<boolean>;
+    /**
+     * @returns the number of times this lock was acquired by its owner,
+     * i.e. how many times the `unlock` method should be invoked for the lock to become free.
+     */
+    getLockCount(): Promise<number>;
+    /**
+     * @returns the number of milliseconds in which the lease for this lock will expire.
+     */
+    getRemainingLeaseTime(): Promise<number>;
+}

package/lib/proxy/ILock.js

@@ -0,0 +1,17 @@
+"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 });