@celerispay/hazelcast-client 3.12.5

package/lib/ClientMessage.d.ts

@@ -0,0 +1,52 @@
+/// <reference types="long" />
+import { Buffer } from 'safe-buffer';
+import * as Long from 'long';
+import { Data } from './serialization/Data';
+declare class ClientMessage {
+    private buffer;
+    private cursor;
+    private retryable;
+    constructor(buffer: Buffer);
+    static newClientMessage(payloadSize: number): ClientMessage;
+    clone(): ClientMessage;
+    getBuffer(): Buffer;
+    getCorrelationId(): number;
+    setCorrelationId(value: number): void;
+    getPartitionId(): number;
+    setPartitionId(value: number): void;
+    setVersion(value: number): void;
+    getMessageType(): number;
+    setMessageType(value: number): void;
+    getFlags(): number;
+    setFlags(value: number): void;
+    hasFlags(flags: number): number;
+    getFrameLength(): number;
+    setFrameLength(value: number): void;
+    getDataOffset(): number;
+    setDataOffset(value: number): void;
+    setRetryable(value: boolean): void;
+    isRetryable(): boolean;
+    appendByte(value: number): void;
+    appendBoolean(value: boolean): void;
+    appendInt32(value: number): void;
+    appendUint8(value: number): void;
+    appendLong(value: any): void;
+    appendString(value: string): void;
+    appendBuffer(buffer: Buffer): void;
+    appendData(data: Data): void;
+    addFlag(value: number): void;
+    updateFrameLength(): void;
+    readData(): Data;
+    readByte(): number;
+    readBoolean(): boolean;
+    readUInt8(): number;
+    readInt32(): number;
+    readLong(): Long;
+    readString(): string;
+    readBuffer(): Buffer;
+    isComplete(): boolean;
+    readMapEntry(): any;
+    private writeLongInternal(value, offset);
+    private readLongInternal(offset);
+}
+export = ClientMessage;

package/lib/ClientMessage.js

@@ -0,0 +1,217 @@
+"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.
+ */
+/* tslint:disable:no-bitwise */
+/*
+ Client Message is the carrier framed data as defined below.
+ Any request parameter, response or event data will be carried in the payload.
+ 0                   1                   2                   3
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ |R|                      Frame Length                           |
+ +-------------+---------------+---------------------------------+
+ |  Version    |B|E|  Flags    |               Type              |
+ +-------------+---------------+---------------------------------+
+ |                       CorrelationId                           |
+ |                                                               |
+ +---------------------------------------------------------------+
+ |                        PartitionId                            |
+ +-----------------------------+---------------------------------+
+ |        Data Offset          |                                 |
+ +-----------------------------+                                 |
+ |                      Message Payload Data                    ...
+ |                                                              ...
+ */
+var safe_buffer_1 = require("safe-buffer");
+var Long = require("long");
+var BitsUtil_1 = require("./BitsUtil");
+var HeapData_1 = require("./serialization/HeapData");
+var ClientMessage = /** @class */ (function () {
+    function ClientMessage(buffer) {
+        this.cursor = BitsUtil_1.BitsUtil.HEADER_SIZE;
+        this.buffer = buffer;
+    }
+    ClientMessage.newClientMessage = function (payloadSize) {
+        var totalSize = BitsUtil_1.BitsUtil.HEADER_SIZE + payloadSize;
+        var buffer = safe_buffer_1.Buffer.allocUnsafe(totalSize);
+        var message = new ClientMessage(buffer);
+        message.setDataOffset(BitsUtil_1.BitsUtil.HEADER_SIZE);
+        message.setVersion(BitsUtil_1.BitsUtil.VERSION);
+        message.setFrameLength(totalSize);
+        message.setFlags(0xc0);
+        message.setPartitionId(-1);
+        return message;
+    };
+    ClientMessage.prototype.clone = function () {
+        var message = new ClientMessage(safe_buffer_1.Buffer.from(this.buffer));
+        message.retryable = this.retryable;
+        return message;
+    };
+    ClientMessage.prototype.getBuffer = function () {
+        return this.buffer;
+    };
+    ClientMessage.prototype.getCorrelationId = function () {
+        var offset = BitsUtil_1.BitsUtil.CORRELATION_ID_FIELD_OFFSET;
+        return this.readLongInternal(offset).toNumber();
+    };
+    ClientMessage.prototype.setCorrelationId = function (value) {
+        this.writeLongInternal(value, BitsUtil_1.BitsUtil.CORRELATION_ID_FIELD_OFFSET);
+    };
+    ClientMessage.prototype.getPartitionId = function () {
+        return this.buffer.readInt32LE(BitsUtil_1.BitsUtil.PARTITION_ID_FIELD_OFFSET);
+    };
+    ClientMessage.prototype.setPartitionId = function (value) {
+        this.buffer.writeInt32LE(value, BitsUtil_1.BitsUtil.PARTITION_ID_FIELD_OFFSET);
+    };
+    ClientMessage.prototype.setVersion = function (value) {
+        this.buffer.writeUInt8(value, BitsUtil_1.BitsUtil.VERSION_FIELD_OFFSET);
+    };
+    ClientMessage.prototype.getMessageType = function () {
+        return this.buffer.readUInt16LE(BitsUtil_1.BitsUtil.TYPE_FIELD_OFFSET);
+    };
+    ClientMessage.prototype.setMessageType = function (value) {
+        this.buffer.writeUInt16LE(value, BitsUtil_1.BitsUtil.TYPE_FIELD_OFFSET);
+    };
+    ClientMessage.prototype.getFlags = function () {
+        return this.buffer.readUInt8(BitsUtil_1.BitsUtil.FLAGS_FIELD_OFFSET);
+    };
+    ClientMessage.prototype.setFlags = function (value) {
+        this.buffer.writeUInt8(value, BitsUtil_1.BitsUtil.FLAGS_FIELD_OFFSET);
+    };
+    ClientMessage.prototype.hasFlags = function (flags) {
+        return this.getFlags() & flags;
+    };
+    ClientMessage.prototype.getFrameLength = function () {
+        return this.buffer.readInt32LE(BitsUtil_1.BitsUtil.FRAME_LENGTH_FIELD_OFFSET);
+    };
+    ClientMessage.prototype.setFrameLength = function (value) {
+        this.buffer.writeInt32LE(value, BitsUtil_1.BitsUtil.FRAME_LENGTH_FIELD_OFFSET);
+    };
+    ClientMessage.prototype.getDataOffset = function () {
+        return this.buffer.readInt16LE(BitsUtil_1.BitsUtil.DATA_OFFSET_FIELD_OFFSET);
+    };
+    ClientMessage.prototype.setDataOffset = function (value) {
+        this.buffer.writeInt16LE(value, BitsUtil_1.BitsUtil.DATA_OFFSET_FIELD_OFFSET);
+    };
+    ClientMessage.prototype.setRetryable = function (value) {
+        this.retryable = value;
+    };
+    ClientMessage.prototype.isRetryable = function () {
+        return this.retryable;
+    };
+    ClientMessage.prototype.appendByte = function (value) {
+        this.buffer.writeUInt8(value, this.cursor);
+        this.cursor += BitsUtil_1.BitsUtil.BYTE_SIZE_IN_BYTES;
+    };
+    ClientMessage.prototype.appendBoolean = function (value) {
+        return this.appendByte(value ? 1 : 0);
+    };
+    ClientMessage.prototype.appendInt32 = function (value) {
+        this.buffer.writeInt32LE(value, this.cursor);
+        this.cursor += BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES;
+    };
+    ClientMessage.prototype.appendUint8 = function (value) {
+        this.buffer.writeUInt8(value, this.cursor);
+        this.cursor += BitsUtil_1.BitsUtil.BYTE_SIZE_IN_BYTES;
+    };
+    ClientMessage.prototype.appendLong = function (value) {
+        this.writeLongInternal(value, this.cursor);
+        this.cursor += BitsUtil_1.BitsUtil.LONG_SIZE_IN_BYTES;
+    };
+    ClientMessage.prototype.appendString = function (value) {
+        var length = safe_buffer_1.Buffer.byteLength(value, 'utf8');
+        this.buffer.writeInt32LE(length, this.cursor);
+        this.cursor += 4;
+        this.buffer.write(value, this.cursor);
+        this.cursor += length;
+    };
+    ClientMessage.prototype.appendBuffer = function (buffer) {
+        var length = buffer.length;
+        this.appendInt32(length);
+        buffer.copy(this.buffer, this.cursor);
+        this.cursor += length;
+    };
+    ClientMessage.prototype.appendData = function (data) {
+        this.appendBuffer(data.toBuffer());
+    };
+    ClientMessage.prototype.addFlag = function (value) {
+        this.buffer.writeUInt8(value | this.getFlags(), BitsUtil_1.BitsUtil.FLAGS_FIELD_OFFSET);
+    };
+    ClientMessage.prototype.updateFrameLength = function () {
+        this.setFrameLength(this.cursor);
+    };
+    ClientMessage.prototype.readData = function () {
+        var dataPayload = this.readBuffer();
+        return new HeapData_1.HeapData(dataPayload);
+    };
+    ClientMessage.prototype.readByte = function () {
+        var value = this.buffer.readUInt8(this.cursor);
+        this.cursor += BitsUtil_1.BitsUtil.BYTE_SIZE_IN_BYTES;
+        return value;
+    };
+    ClientMessage.prototype.readBoolean = function () {
+        return this.readByte() === 1;
+    };
+    ClientMessage.prototype.readUInt8 = function () {
+        var value = this.buffer.readUInt8(this.cursor);
+        this.cursor += BitsUtil_1.BitsUtil.BYTE_SIZE_IN_BYTES;
+        return value;
+    };
+    ClientMessage.prototype.readInt32 = function () {
+        var value = this.buffer.readInt32LE(this.cursor);
+        this.cursor += BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES;
+        return value;
+    };
+    ClientMessage.prototype.readLong = function () {
+        var value = this.readLongInternal(this.cursor);
+        this.cursor += BitsUtil_1.BitsUtil.LONG_SIZE_IN_BYTES;
+        return value;
+    };
+    ClientMessage.prototype.readString = function () {
+        var length = this.buffer.readInt32LE(this.cursor);
+        this.cursor += BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES;
+        var value = this.buffer.toString('utf8', this.cursor, this.cursor + length);
+        this.cursor += length;
+        return value;
+    };
+    ClientMessage.prototype.readBuffer = function () {
+        var size = this.buffer.readUInt32LE(this.cursor);
+        this.cursor += BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES;
+        var result = this.buffer.slice(this.cursor, this.cursor + size);
+        this.cursor += size;
+        return result;
+    };
+    ClientMessage.prototype.isComplete = function () {
+        return (this.cursor >= BitsUtil_1.BitsUtil.HEADER_SIZE) && (this.cursor === this.getFrameLength());
+    };
+    ClientMessage.prototype.readMapEntry = function () {
+        // TODO
+    };
+    ClientMessage.prototype.writeLongInternal = function (value, offset) {
+        if (!Long.isLong(value)) {
+            value = Long.fromValue(value);
+        }
+        this.buffer.writeInt32LE(value.low, offset);
+        this.buffer.writeInt32LE(value.high, offset + 4);
+    };
+    ClientMessage.prototype.readLongInternal = function (offset) {
+        var low = this.buffer.readInt32LE(offset);
+        var high = this.buffer.readInt32LE(offset + 4);
+        return new Long(low, high);
+    };
+    return ClientMessage;
+}());
+module.exports = ClientMessage;

package/lib/ClusterDataFactory.d.ts

@@ -0,0 +1,4 @@
+import { IdentifiedDataSerializable, IdentifiedDataSerializableFactory } from './serialization/Serializable';
+export declare class ClusterDataFactory implements IdentifiedDataSerializableFactory {
+    create(type: number): IdentifiedDataSerializable;
+}

package/lib/ClusterDataFactory.js

@@ -0,0 +1,31 @@
+"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 Address = require("./Address");
+var ClusterDataFactoryHelper_1 = require("./ClusterDataFactoryHelper");
+var ClusterDataFactory = /** @class */ (function () {
+    function ClusterDataFactory() {
+    }
+    ClusterDataFactory.prototype.create = function (type) {
+        if (type === ClusterDataFactoryHelper_1.ClusterDataFactoryHelper.ADDRESS_ID) {
+            return new Address();
+        }
+        return null;
+    };
+    return ClusterDataFactory;
+}());
+exports.ClusterDataFactory = ClusterDataFactory;

package/lib/ClusterDataFactoryHelper.d.ts

@@ -0,0 +1,5 @@
+export declare class ClusterDataFactoryHelper {
+    static readonly FACTORY_ID: number;
+    static readonly ADDRESS_ID: number;
+    static readonly VECTOR_CLOCK: number;
+}

package/lib/ClusterDataFactoryHelper.js

@@ -0,0 +1,26 @@
+"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 ClusterDataFactoryHelper = /** @class */ (function () {
+    function ClusterDataFactoryHelper() {
+    }
+    ClusterDataFactoryHelper.FACTORY_ID = 0;
+    ClusterDataFactoryHelper.ADDRESS_ID = 1;
+    ClusterDataFactoryHelper.VECTOR_CLOCK = 43;
+    return ClusterDataFactoryHelper;
+}());
+exports.ClusterDataFactoryHelper = ClusterDataFactoryHelper;

package/lib/DataStoreHashMap.d.ts

@@ -0,0 +1,20 @@
+import { Data } from './serialization/Data';
+export declare class DataKeyedHashMap<T> {
+    size: number;
+    private internalStore;
+    constructor();
+    clear(): void;
+    delete(key: Data): boolean;
+    has(key: Data): boolean;
+    get(key: Data): T;
+    set(key: Data, value: any): this;
+    values(): T[];
+    entries(): Array<[Data, T]>;
+    /**
+     *
+     * @param key
+     * @returns index of the key if it exists, -1 if either bucket or item does not exist
+     */
+    private findIndexInBucket(key);
+    private getOrCreateBucket(key);
+}

package/lib/DataStoreHashMap.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 DataKeyedHashMap = /** @class */ (function () {
+    function DataKeyedHashMap() {
+        this.internalStore = new Map();
+        this.size = 0;
+    }
+    DataKeyedHashMap.prototype.clear = function () {
+        this.size = 0;
+        this.internalStore = new Map();
+    };
+    DataKeyedHashMap.prototype.delete = function (key) {
+        var existingIndex = this.findIndexInBucket(key);
+        if (existingIndex === -1) {
+            return false;
+        }
+        else {
+            this.getOrCreateBucket(key.hashCode()).splice(existingIndex, 1);
+            this.size--;
+            return true;
+        }
+    };
+    DataKeyedHashMap.prototype.has = function (key) {
+        return this.findIndexInBucket(key) !== -1;
+    };
+    DataKeyedHashMap.prototype.get = function (key) {
+        var keyHash = key.hashCode();
+        var existingIndex = this.findIndexInBucket(key);
+        if (existingIndex !== -1) {
+            return this.getOrCreateBucket(keyHash)[existingIndex].value;
+        }
+        else {
+            return undefined;
+        }
+    };
+    DataKeyedHashMap.prototype.set = function (key, value) {
+        var keyHash = key.hashCode();
+        var existingIndex = this.findIndexInBucket(key);
+        if (existingIndex !== -1) {
+            this.getOrCreateBucket(keyHash)[existingIndex].value = value;
+        }
+        else {
+            this.getOrCreateBucket(keyHash).push({ key: key, value: value });
+            this.size++;
+        }
+        return this;
+    };
+    DataKeyedHashMap.prototype.values = function () {
+        var snapshot = [];
+        this.internalStore.forEach(function (bucket) {
+            snapshot.push.apply(snapshot, (bucket.map(function (item) { return item.value; })));
+        });
+        return snapshot;
+    };
+    DataKeyedHashMap.prototype.entries = function () {
+        var snapshot = [];
+        this.internalStore.forEach(function (bucket) {
+            snapshot.push.apply(snapshot, (bucket.map(function (item) {
+                return [item.key, item.value];
+            })));
+        });
+        return snapshot;
+    };
+    /**
+     *
+     * @param key
+     * @returns index of the key if it exists, -1 if either bucket or item does not exist
+     */
+    DataKeyedHashMap.prototype.findIndexInBucket = function (key) {
+        var keyHash = key.hashCode();
+        var bucket = this.internalStore.get(keyHash);
+        if (bucket === undefined) {
+            return -1;
+        }
+        else {
+            return bucket.findIndex(function (item) {
+                return item.key.equals(key);
+            });
+        }
+    };
+    DataKeyedHashMap.prototype.getOrCreateBucket = function (key) {
+        var bucket;
+        bucket = this.internalStore.get(key);
+        if (bucket === undefined) {
+            bucket = [];
+            this.internalStore.set(key, bucket);
+        }
+        return bucket;
+    };
+    return DataKeyedHashMap;
+}());
+exports.DataKeyedHashMap = DataKeyedHashMap;
+var InternalRecord = /** @class */ (function () {
+    function InternalRecord() {
+    }
+    return InternalRecord;
+}());

package/lib/DistributedObject.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+export interface DistributedObject {
+    /**
+     * Returns the key of the partition that this DistributedObject is assigned to.
+     * For a partitioned data structure, the returned value will not be null, but otherwise undefined.
+     */
+    getPartitionKey(): string;
+    /**
+     * Returns the unique name of this object.
+     */
+    getName(): string;
+    /**
+     * Returns the service name for this object.
+     */
+    getServiceName(): string;
+    /**
+     * Destroys this object cluster-wide.
+     * Clears all resources taken for this object.
+     */
+    destroy(): Promise<void>;
+}

package/lib/DistributedObject.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 });