@celerispay/hazelcast-client 3.12.5-1

package/config-schema.json

@@ -0,0 +1,343 @@
+{
+    "$schema": "http://json-schema.org/schema#",
+    "id": "https://github.com/hazelcast/hazelcast-nodejs-client/blob/schema/config-schema.json",
+    "title": "Hazelcast Node.js Client Configuration",
+    "type": "object",
+    "definitions": {
+        "importPath": {
+            "type": "object",
+            "properties": {
+                "path": {
+                    "type": "string",
+                    "format": "uri-reference"
+                },
+                "exportedName": {
+                    "type": "string"
+                }
+            }
+        },
+        "propertiesObject": {
+            "type": "object",
+            "propertyNames": {
+                "pattern": "^[^ ]*$"
+            },
+            "additionalProperties": {
+                "type": [
+                    "number",
+                    "string",
+                    "boolean"
+                ]
+            }
+        },
+        "positiveInteger": {
+            "type": "number",
+            "minimum": 0,
+            "multipleOf": 1
+        },
+        "listenerConfig": {
+            "allOf": [
+                {
+                    "$ref": "#/definitions/importPath"
+                },
+                {
+                    "properties": {
+                        "type": {
+                            "enum": [
+                                "lifecycle"
+                            ]
+                        }
+                    }
+                }
+            ]
+        },
+        "factoryConfig": {
+            "allOf": [
+                {
+                    "$ref": "#/definitions/importPath"
+                },
+                {
+                    "properties": {
+                        "factoryId": {
+                            "$ref": "#/definitions/positiveInteger"
+                        }
+                    }
+                }
+            ]
+        },
+        "factoryConfigArray": {
+            "type": "array",
+            "items": {
+                "$ref": "#/definitions/factoryConfig"
+            }
+        }
+    },
+    "properties": {
+        "group": {
+            "type": "object",
+            "required": [
+                "name",
+                "password"
+            ],
+            "properties": {
+                "name": {
+                    "type": "string"
+                },
+                "password": {
+                    "type": "string"
+                }
+            },
+            "additionalProperties": false
+        },
+        "properties": {
+            "$ref": "#/definitions/propertiesObject"
+        },
+        "network": {
+            "type": "object",
+            "properties": {
+                "clusterMembers": {
+                    "type": "array",
+                    "minItems": 1,
+                    "uniqueItems": true,
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "smartRouting": {
+                    "type": "boolean",
+                    "default": true
+                },
+                "connectionTimeout": {
+                    "type": "number",
+                    "minimum": 1000,
+                    "default": 5000
+                },
+                "connectionAttemptPeriod": {
+                    "type": "number",
+                    "minimum": 1,
+                    "default": 3000
+                },
+                "connectionAttemptLimit": {
+                    "type": "number",
+                    "minimum": 0,
+                    "default": 2
+                },
+                "hazelcastCloud": {
+                    "type": "object",
+                    "properties": {
+                        "discoveryToken": {
+                            "type": ["string", "null"]
+                        },
+                        "enabled": {
+                            "type": "boolean",
+                            "default": false
+                        }
+                    }
+                },
+                "ssl": {
+                    "type": "object",
+                    "properties": {
+                        "enabled": {
+                            "type": "boolean",
+                            "default": false
+                        },
+                        "sslOptions": {
+                            "anyOf": [
+                                {
+                                    "type": "object",
+                                    "properties": {
+                                        "properties": {
+                                            "$ref": "#/definitions/propertiesObject"
+                                        }
+                                    }
+                                },
+                                {
+                                    "type": "null"
+                                }
+                            ]
+                        },
+                        "factory": {
+                            "anyOf": [
+                                {
+                                    "$ref": "#/definitions/importPath"
+                                },
+                                {
+                                    "type": "object",
+                                    "properties": {
+                                        "properties": {
+                                            "$ref": "#/definitions/propertiesObject"
+                                        }
+                                    }
+                                },
+                                {
+                                    "type": "null"
+                                }
+                            ]
+                        }
+                    }
+                }
+            }
+        },
+        "listeners": {
+            "type": "array",
+            "items": {
+                "$ref": "#/definitions/listenerConfig"
+            }
+        },
+        "serialization": {
+            "type": "object",
+            "properties": {
+                "defaultNumberType": {
+                    "enum": [
+                        "integer",
+                        "float",
+                        "double"
+                    ],
+                    "default": "double"
+                },
+                "jsonStringDeserializationPolicy": {
+                    "enum": [
+                        "eager",
+                        "no_deserialization"
+                    ],
+                    "default": "eager"
+                },
+                "stringSerialization": {
+                    "enum": [
+                        "standard",
+                        "legacy"
+                    ],
+                    "default": "standard"
+                },
+                "isBigEndian": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "portableVersion": {
+                    "$ref": "#/definitions/positiveInteger"
+                },
+                "dataSerializableFactories": {
+                    "$ref": "#/definitions/factoryConfigArray"
+                },
+                "portableFactories": {
+                    "$ref": "#/definitions/factoryConfigArray"
+                },
+                "globalSerializer": {
+                    "$ref": "#/definitions/importPath"
+                },
+                "serializers": {
+                    "type": "array",
+                    "items": {
+                        "allOf": [
+                            {
+                                "$ref": "#/definitions/importPath"
+                            },
+                            {
+                                "required": [
+                                    "typeId"
+                                ],
+                                "properties": {
+                                    "typeId": {
+                                        "$ref": "#/definitions/positiveInteger"
+                                    }
+                                }
+                            }
+                        ]
+                    }
+                }
+            }
+        },
+        "nearCaches": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "required": [
+                    "name"
+                ],
+                "properties": {
+                    "name": {
+                        "type": "string",
+                        "minLength": 1
+                    },
+                    "invalidateOnChange": {
+                        "type": "boolean",
+                        "default": true
+                    },
+                    "maxIdleSeconds": {
+                        "type": "number",
+                        "default": 0,
+                        "minimum": 0
+                    },
+                    "inMemoryFormat": {
+                        "enum": [
+                            "object",
+                            "binary"
+                        ],
+                        "default": "binary"
+                    },
+                    "timeToLiveSeconds": {
+                        "type": "number",
+                        "minimum": 0,
+                        "default": 0
+                    },
+                    "evictionPolicy": {
+                        "enum": [
+                            "none",
+                            "lru",
+                            "lfu",
+                            "random"
+                        ],
+                        "default": "none"
+                    },
+                    "evictionMaxSize": {
+                        "$ref": "#/definitions/positiveInteger",
+                        "default": "maximum safe integer"
+                    },
+                    "evictionSamplingCount": {
+                        "$ref": "#/definitions/positiveInteger",
+                        "default": 8
+                    },
+                    "evictionSamplingPoolSize": {
+                        "$ref": "#/definitions/positiveInteger",
+                        "default": 16
+                    }
+                }
+            }
+        },
+        "reliableTopics": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "required": [
+                    "name"
+                ],
+                "additionalProperties": false,
+                "properties": {
+                    "name": {
+                        "type": "string",
+                        "minLength": 1
+                    },
+                    "readBatchSize": {
+                        "$ref": "#/definitions/positiveInteger",
+                        "default": 25
+                    },
+                    "overloadPolicy": {
+                        "enum": [
+                            "discard_oldest",
+                            "discard_newest",
+                            "block",
+                            "error"
+                        ],
+                        "default": "block"
+                    }
+                }
+            }
+        },
+        "import": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+                "type": "string"
+            }
+        }
+    }
+}

package/hazelcast-client-default.json

@@ -0,0 +1,56 @@
+{
+    "group": {
+        "name": "dev",
+        "password": "dev-pass"
+    },
+    "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.cloud.url": "https://coordinator.hazelcast.cloud",
+        "hazelcast.client.statistics.enabled": false,
+        "hazelcast.client.statistics.period.seconds": 3,
+        "hazelcast.invalidation.reconciliation.interval.seconds": 60,
+        "hazelcast.invalidation.max.tolerated.miss.count": 10,
+        "hazelcast.invalidation.min.reconciliation.interval.seconds": 30,
+        "hazelcast.logging.level": 2,
+        "hazelcast.client.autopipelining.enabled": true,
+        "hazelcast.client.autopipelining.threshold.bytes": 8192,
+        "hazelcast.client.socket.no.delay": true
+    },
+    "network": {
+        "clusterMembers": [
+            "127.0.0.1:5701"
+        ],
+        "smartRouting": true,
+        "redoOperation": false,
+        "connectionTimeout": 5000,
+        "connectionAttemptPeriod": 3000,
+        "connectionAttemptLimit": 2,
+        "ssl": {
+            "enabled": false,
+            "sslOptions": null,
+            "factory": null
+        },
+        "hazelcastCloud": {
+            "discoveryToken": null,
+            "enabled": false
+        }
+    },
+    "listeners": [],
+    "serialization": {
+        "defaultNumberType": "double",
+        "isBigEndian": true,
+        "jsonStringDeserializationPolicy": "eager",
+        "stringSerialization": "standard",
+        "dataSerializableFactories": [],
+        "portableFactories": [],
+        "portableVersion": 0,
+        "globalSerializer": {},
+        "serializers": []
+    },
+    "nearCaches": [],
+    "reliableTopics": [],
+    "flakeIdGeneratorConfigs": []
+}

package/hazelcast-client-full.json

@@ -0,0 +1,137 @@
+{
+    "group": {
+        "name": "hazel",
+        "password": "cast"
+    },
+    "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.cloud.url": "https://coordinator.hazelcast.cloud",
+        "hazelcast.client.statistics.enabled": false,
+        "hazelcast.client.statistics.period.seconds": 3,
+        "hazelcast.invalidation.reconciliation.interval.seconds": 60,
+        "hazelcast.invalidation.max.tolerated.miss.count": 10,
+        "hazelcast.invalidation.min.reconciliation.interval.seconds": 30,
+        "hazelcast.logging.level": 2,
+        "hazelcast.client.autopipelining.enabled": true,
+        "hazelcast.client.autopipelining.threshold.bytes": 8192,
+        "hazelcast.client.socket.no.delay": true
+    },
+    "network": {
+        "clusterMembers": [
+            "127.0.0.1",
+            "127.0.0.2:5702"
+        ],
+        "smartRouting": true,
+        "redoOperation": false,
+        "connectionTimeout": 5000,
+        "connectionAttemptPeriod": 3000,
+        "connectionAttemptLimit": 2,
+        "ssl": {
+            "enabled": false,
+            "sslOptions": null,
+            "factory": {
+                "path": "path/to/file",
+                "exportedName": "exportedName",
+                "properties": {
+                    "userDefinedProperty1": "userDefinedValue"
+                }
+            }
+        },
+        "hazelcastCloud": {
+            "discoveryToken": "EXAMPLE_TOKEN",
+            "enabled": false
+        }
+    },
+    "listeners": [
+        {
+            "type": "lifecycle",
+            "path": "path/to/file",
+            "exportedName": "listener"
+        },
+        {
+            "type": "lifecycle",
+            "path": "path/to/file",
+            "exportedName": "listener2"
+        }
+    ],
+    "serialization": {
+        "defaultNumberType": "double",
+        "isBigEndian": true,
+        "jsonStringDeserializationPolicy": "eager",
+        "stringSerialization": "standard",
+        "dataSerializableFactories": [
+            {
+                "path": "path/to/file",
+                "exportedName": "exportedName",
+                "factoryId": 0
+            }
+        ],
+        "portableFactories": [
+            {
+                "path": "path/to/file",
+                "exportedName": "exportedName",
+                "factoryId": 1
+            }
+        ],
+        "portableVersion": 0,
+        "globalSerializer": {
+            "path": "path/to/file",
+            "exportedName": "exportedName"
+        },
+        "serializers": [
+            {
+                "path": "path/to/custom",
+                "exportedName": "CustomSerializer1",
+                "typeId": 2
+            },
+            {
+                "path": "path/to/custom",
+                "exportedName": "CustomSerializer2",
+                "typeId": 3
+            }
+        ]
+    },
+    "nearCaches": [
+        {
+            "name": "nc-map",
+            "invalidateOnChange": false,
+            "maxIdleSeconds": 2,
+            "inMemoryFormat": "object",
+            "timeToLiveSeconds": 3,
+            "evictionPolicy": "lru",
+            "evictionMaxSize": 3000,
+            "evictionSamplingCount": 4,
+            "evictionSamplingPoolSize": 8
+        }
+    ],
+    "reliableTopics": [
+        {
+            "name": "rt1",
+            "readBatchSize": 35,
+            "overloadPolicy": "discard_newest"
+        },
+        {
+            "name": "rt2",
+            "readBatchSize": 15,
+            "overloadPolicy": "discard_newest"
+        }
+    ],
+    "flakeIdGeneratorConfigs": [
+        {
+            "name": "flakeid",
+            "prefetchCount": 1000,
+            "prefetchValidityMillis": 30000
+        },
+        {
+            "name": "flakeid2",
+            "prefetchCount": 5000,
+            "prefetchValidityMillis": 500000
+        }
+    ],
+    "import": [
+        "hazelcast-client-near-cache.json"
+    ]
+}

package/lib/Address.d.ts

@@ -0,0 +1,17 @@
+import { DataInput, DataOutput } from './serialization/Data';
+import { IdentifiedDataSerializable } from './serialization/Serializable';
+declare class Address implements IdentifiedDataSerializable {
+    host: string;
+    port: number;
+    type: number;
+    private addrStr;
+    constructor(host?: string, port?: number);
+    readData(input: DataInput): any;
+    writeData(output: DataOutput): void;
+    getFactoryId(): number;
+    getClassId(): number;
+    equals(other: Address): boolean;
+    toString(): string;
+    private toStringInternal();
+}
+export = Address;

package/lib/Address.js

@@ -0,0 +1,65 @@
+"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 net = require("net");
+var ClusterDataFactoryHelper_1 = require("./ClusterDataFactoryHelper");
+var Address = /** @class */ (function () {
+    function Address(host, port) {
+        this.host = host;
+        this.port = port;
+        this.type = net.isIP(host);
+        this.addrStr = this.toStringInternal();
+    }
+    Address.prototype.readData = function (input) {
+        this.port = input.readInt();
+        this.type = input.readByte();
+        this.host = input.readUTF();
+        this.addrStr = this.toStringInternal();
+    };
+    Address.prototype.writeData = function (output) {
+        output.writeInt(this.port);
+        output.writeByte(this.type);
+        output.writeUTF(this.host);
+    };
+    Address.prototype.getFactoryId = function () {
+        return ClusterDataFactoryHelper_1.ClusterDataFactoryHelper.FACTORY_ID;
+    };
+    Address.prototype.getClassId = function () {
+        return ClusterDataFactoryHelper_1.ClusterDataFactoryHelper.ADDRESS_ID;
+    };
+    Address.prototype.equals = function (other) {
+        if (other === this) {
+            return true;
+        }
+        if (other == null) {
+            return false;
+        }
+        if (other.host === this.host &&
+            other.port === this.port &&
+            other.type === this.type) {
+            return true;
+        }
+        return false;
+    };
+    Address.prototype.toString = function () {
+        return this.addrStr;
+    };
+    Address.prototype.toStringInternal = function () {
+        return this.host + ':' + this.port;
+    };
+    return Address;
+}());
+module.exports = Address;

package/lib/BitsUtil.d.ts

@@ -0,0 +1,69 @@
+import { Buffer } from 'safe-buffer';
+import Address = require('./Address');
+import { Data } from './serialization/Data';
+export declare class BitsUtil {
+    static EVENT_MEMBER: number;
+    static EVENT_MEMBERLIST: number;
+    static EVENT_MEMBERATTRIBUTECHANGE: number;
+    static EVENT_ENTRY: number;
+    static EVENT_ITEM: number;
+    static EVENT_TOPIC: number;
+    static EVENT_PARTITIONLOST: number;
+    static EVENT_DISTRIBUTEDOBJECT: number;
+    static EVENT_CACHEINVALIDATION: number;
+    static EVENT_MAPPARTITIONLOST: number;
+    static EVENT_CACHE: number;
+    static EVENT_CACHEBATCHINVALIDATION: number;
+    static EVENT_QUERYCACHESINGLE: number;
+    static EVENT_QUERYCACHEBATCH: number;
+    static EVENT_CACHEPARTITIONLOST: number;
+    static EVENT_IMAPINVALIDATION: number;
+    static EVENT_IMAPBATCHINVALIDATION: number;
+    static EVENT_PARTITIONS: number;
+    static BYTE_SIZE_IN_BYTES: number;
+    static BOOLEAN_SIZE_IN_BYTES: number;
+    static SHORT_SIZE_IN_BYTES: number;
+    static CHAR_SIZE_IN_BYTES: number;
+    static INT_SIZE_IN_BYTES: number;
+    static FLOAT_SIZE_IN_BYTES: number;
+    static LONG_SIZE_IN_BYTES: number;
+    static DOUBLE_SIZE_IN_BYTES: number;
+    static BIG_ENDIAN: number;
+    static LITTLE_ENDIAN: number;
+    static VERSION: number;
+    static BEGIN_FLAG: number;
+    static END_FLAG: number;
+    static BEGIN_END_FLAG: number;
+    static LISTENER_FLAG: number;
+    static NULL_ARRAY_LENGTH: number;
+    static SIZE_OFFSET: number;
+    static FRAME_LENGTH_FIELD_OFFSET: number;
+    static VERSION_FIELD_OFFSET: number;
+    static FLAGS_FIELD_OFFSET: number;
+    static TYPE_FIELD_OFFSET: number;
+    static CORRELATION_ID_FIELD_OFFSET: number;
+    static PARTITION_ID_FIELD_OFFSET: number;
+    static DATA_OFFSET_FIELD_OFFSET: number;
+    static HEADER_SIZE: number;
+    static calculateSizeData(data: Data): number;
+    static getStringSize(value: string, nullable?: boolean): number;
+    static calculateSizeString(value: string): number;
+    static calculateSizeBuffer(value: Buffer): number;
+    static calculateSizeAddress(value: Address): number;
+    static writeUInt32(buffer: Buffer, pos: number, val: number, isBigEndian: boolean): void;
+    static writeUInt16(buffer: Buffer, pos: number, val: number, isBigEndian: boolean): void;
+    static writeUInt8(buffer: Buffer, pos: number, val: number): void;
+    static writeInt32(buffer: Buffer, pos: number, val: number, isBigEndian: boolean): void;
+    static writeInt16(buffer: Buffer, pos: number, val: number, isBigEndian: boolean): void;
+    static writeInt8(buffer: Buffer, pos: number, val: number): void;
+    static writeFloat(buffer: Buffer, pos: number, val: number, isBigEndian: boolean): void;
+    static writeDouble(buffer: Buffer, pos: number, val: number, isBigEndian: boolean): void;
+    static readDouble(buffer: Buffer, pos: number, isBigEndian: boolean): number;
+    static readFloat(buffer: Buffer, pos: number, isBigEndian: boolean): number;
+    static readInt8(buffer: Buffer, pos: number): number;
+    static readInt16(buffer: Buffer, pos: number, isBigEndian: boolean): number;
+    static readInt32(buffer: Buffer, pos: number, isBigEndian: boolean): number;
+    static readUInt8(buffer: Buffer, pos: number): number;
+    static readUInt16(buffer: Buffer, pos: number, isBigEndian: boolean): number;
+    static readUInt32(buffer: Buffer, pos: number, isBigEndian: boolean): number;
+}