couchbase 4.1.2 → 4.1.3

package/dist/collection.js

@@ -33,6 +33,7 @@ const errors_1 = require("./errors");
 const generaltypes_1 = require("./generaltypes");
 const sdspecs_1 = require("./sdspecs");
 const sdutils_1 = require("./sdutils");
+const streamablepromises_1 = require("./streamablepromises");
 const utilities_1 = require("./utilities");
 /**
  * Exposes the operations which are available to be performed against a collection.
@@ -126,6 +127,25 @@ class Collection {
             return callback(e, null);
         }
     }
+    /**
+     * @internal
+     */
+    _subdocEncode(value) {
+        return Buffer.from(value);
+    }
+    /**
+     * @internal
+     */
+    _subdocDecode(bytes) {
+        try {
+            return JSON.parse(bytes.toString('utf8'));
+        }
+        catch (e) {
+            // If we encounter a parse error, assume that we need
+            // to return bytes instead of an object.
+            return bytes;
+        }
+    }
     /**
      * The name of the collection this Collection object references.
      */
@@ -292,6 +312,103 @@ class Collection {
             });
         }, callback);
     }
+    /**
+     * @internal
+     */
+    _getReplica(key, getAllReplicas, options, callback) {
+        if (options instanceof Function) {
+            callback = arguments[2];
+            options = undefined;
+        }
+        if (!options) {
+            options = {};
+        }
+        const emitter = new streamablepromises_1.StreamableReplicasPromise((replicas) => replicas);
+        const transcoder = options.transcoder || this.transcoder;
+        const timeout = options.timeout || this.cluster.kvTimeout;
+        if (getAllReplicas) {
+            this._conn.getAllReplicas({
+                id: this._cppDocId(key),
+                timeout: timeout,
+            }, (cppErr, resp) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    emitter.emit('error', err);
+                    emitter.emit('end');
+                    return;
+                }
+                resp.entries.forEach((replica) => {
+                    this._decodeDoc(transcoder, replica.value, replica.flags, (err, content) => {
+                        if (err) {
+                            emitter.emit('error', err);
+                            emitter.emit('end');
+                            return;
+                        }
+                        emitter.emit('replica', new crudoptypes_1.GetReplicaResult({
+                            content: content,
+                            cas: replica.cas,
+                            isReplica: replica.replica,
+                        }));
+                    });
+                });
+                emitter.emit('end');
+                return;
+            });
+        }
+        else {
+            this._conn.getAnyReplica({
+                id: this._cppDocId(key),
+                timeout: timeout,
+            }, (cppErr, resp) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    emitter.emit('error', err);
+                    emitter.emit('end');
+                    return;
+                }
+                this._decodeDoc(transcoder, resp.value, resp.flags, (err, content) => {
+                    if (err) {
+                        emitter.emit('error', err);
+                        emitter.emit('end');
+                        return;
+                    }
+                    emitter.emit('replica', new crudoptypes_1.GetReplicaResult({
+                        content: content,
+                        cas: resp.cas,
+                        isReplica: resp.replica,
+                    }));
+                });
+                emitter.emit('end');
+                return;
+            });
+        }
+        return utilities_1.PromiseHelper.wrapAsync(() => emitter, callback);
+    }
+    /**
+     * Retrieves the value of the document from any of the available replicas.  This
+     * will return as soon as the first response is received from any replica node.
+     *
+     * @param key The document key to retrieve.
+     * @param options Optional parameters for this operation.
+     * @param callback A node-style callback to be invoked after execution.
+     */
+    getAnyReplica(key, options, callback) {
+        return utilities_1.PromiseHelper.wrapAsync(async () => {
+            const replicas = await this._getReplica(key, false, options);
+            return replicas[0];
+        }, callback);
+    }
+    /**
+     * Retrieves the value of the document from all available replicas.  Note that
+     * as replication is asynchronous, each node may return a different value.
+     *
+     * @param key The document key to retrieve.
+     * @param options Optional parameters for this operation.
+     * @param callback A node-style callback to be invoked after execution.
+     */
+    getAllReplicas(key, options, callback) {
+        return this._getReplica(key, true, options, callback);
+    }
     /**
      * Inserts a new document to the collection, failing if the document already exists.
      *
@@ -311,22 +428,24 @@ class Collection {
         const expiry = options.expiry;
         const transcoder = options.transcoder || this.transcoder;
         const durabilityLevel = options.durabilityLevel;
+        const persistTo = options.durabilityPersistTo;
+        const replicateTo = options.durabilityReplicateTo;
         const timeout = options.timeout || this._mutationTimeout(durabilityLevel);
         return utilities_1.PromiseHelper.wrap((wrapCallback) => {
             this._encodeDoc(transcoder, value, (err, bytes, flags) => {
                 if (err) {
                     return wrapCallback(err, null);
                 }
-                this._conn.insert({
+                const insertReq = {
                     id: this._cppDocId(key),
                     value: bytes,
                     flags,
                     expiry: expiry || 0,
-                    durability_level: (0, bindingutilities_1.durabilityToCpp)(durabilityLevel),
                     timeout,
                     partition: 0,
                     opaque: 0,
-                }, (cppErr, resp) => {
+                };
+                const insertCallback = (cppErr, resp) => {
                     const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
                     if (err) {
                         return wrapCallback(err, null);
@@ -335,7 +454,20 @@ class Collection {
                         cas: resp.cas,
                         token: resp.token,
                     }));
-                });
+                };
+                if (persistTo || replicateTo) {
+                    this._conn.insertWithLegacyDurability({
+                        ...insertReq,
+                        persist_to: (0, bindingutilities_1.persistToToCpp)(persistTo),
+                        replicate_to: (0, bindingutilities_1.replicateToToCpp)(replicateTo),
+                    }, insertCallback);
+                }
+                else {
+                    this._conn.insert({
+                        ...insertReq,
+                        durability_level: (0, bindingutilities_1.durabilityToCpp)(durabilityLevel),
+                    }, insertCallback);
+                }
             });
         }, callback);
     }
@@ -360,23 +492,25 @@ class Collection {
         const preserve_expiry = options.preserveExpiry;
         const transcoder = options.transcoder || this.transcoder;
         const durabilityLevel = options.durabilityLevel;
+        const persistTo = options.durabilityPersistTo;
+        const replicateTo = options.durabilityReplicateTo;
         const timeout = options.timeout || this._mutationTimeout(durabilityLevel);
         return utilities_1.PromiseHelper.wrap((wrapCallback) => {
             this._encodeDoc(transcoder, value, (err, bytes, flags) => {
                 if (err) {
                     return wrapCallback(err, null);
                 }
-                this._conn.upsert({
+                const upsertReq = {
                     id: this._cppDocId(key),
                     value: bytes,
                     flags,
                     expiry: expiry || 0,
                     preserve_expiry: preserve_expiry || false,
-                    durability_level: (0, bindingutilities_1.durabilityToCpp)(durabilityLevel),
                     timeout,
                     partition: 0,
                     opaque: 0,
-                }, (cppErr, resp) => {
+                };
+                const upsertCallback = (cppErr, resp) => {
                     const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
                     if (err) {
                         return wrapCallback(err, null);
@@ -385,7 +519,20 @@ class Collection {
                         cas: resp.cas,
                         token: resp.token,
                     }));
-                });
+                };
+                if (persistTo || replicateTo) {
+                    this._conn.upsertWithLegacyDurability({
+                        ...upsertReq,
+                        persist_to: (0, bindingutilities_1.persistToToCpp)(persistTo),
+                        replicate_to: (0, bindingutilities_1.replicateToToCpp)(replicateTo),
+                    }, upsertCallback);
+                }
+                else {
+                    this._conn.upsert({
+                        ...upsertReq,
+                        durability_level: (0, bindingutilities_1.durabilityToCpp)(durabilityLevel),
+                    }, upsertCallback);
+                }
             });
         }, callback);
     }
@@ -410,24 +557,26 @@ class Collection {
         const preserve_expiry = options.preserveExpiry;
         const transcoder = options.transcoder || this.transcoder;
         const durabilityLevel = options.durabilityLevel;
+        const persistTo = options.durabilityPersistTo;
+        const replicateTo = options.durabilityReplicateTo;
         const timeout = options.timeout || this._mutationTimeout(durabilityLevel);
         return utilities_1.PromiseHelper.wrap((wrapCallback) => {
             this._encodeDoc(transcoder, value, (err, bytes, flags) => {
                 if (err) {
                     return wrapCallback(err, null);
                 }
-                this._conn.replace({
+                const replaceReq = {
                     id: this._cppDocId(key),
                     value: bytes,
                     flags,
                     expiry,
                     cas: cas || binding_1.zeroCas,
                     preserve_expiry: preserve_expiry || false,
-                    durability_level: (0, bindingutilities_1.durabilityToCpp)(durabilityLevel),
                     timeout,
                     partition: 0,
                     opaque: 0,
-                }, (cppErr, resp) => {
+                };
+                const replaceCallback = (cppErr, resp) => {
                     const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
                     if (err) {
                         return wrapCallback(err, null);
@@ -436,7 +585,20 @@ class Collection {
                         cas: resp.cas,
                         token: resp.token,
                     }));
-                });
+                };
+                if (persistTo || replicateTo) {
+                    this._conn.replaceWithLegacyDurability({
+                        ...replaceReq,
+                        persist_to: (0, bindingutilities_1.persistToToCpp)(persistTo),
+                        replicate_to: (0, bindingutilities_1.replicateToToCpp)(replicateTo),
+                    }, replaceCallback);
+                }
+                else {
+                    this._conn.replace({
+                        ...replaceReq,
+                        durability_level: (0, bindingutilities_1.durabilityToCpp)(durabilityLevel),
+                    }, replaceCallback);
+                }
             });
         }, callback);
     }
@@ -457,24 +619,40 @@ class Collection {
         }
         const cas = options.cas;
         const durabilityLevel = options.durabilityLevel;
+        const persistTo = options.durabilityPersistTo;
+        const replicateTo = options.durabilityReplicateTo;
         const timeout = options.timeout || this._mutationTimeout(durabilityLevel);
         return utilities_1.PromiseHelper.wrap((wrapCallback) => {
-            this._conn.remove({
+            const removeReq = {
                 id: this._cppDocId(key),
                 cas: cas || binding_1.zeroCas,
-                durability_level: (0, bindingutilities_1.durabilityToCpp)(durabilityLevel),
                 timeout,
                 partition: 0,
                 opaque: 0,
-            }, (cppErr, resp) => {
+            };
+            const removeCallback = (cppErr, resp) => {
                 const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
                 if (err) {
                     return wrapCallback(err, null);
                 }
                 wrapCallback(err, new crudoptypes_1.MutationResult({
                     cas: resp.cas,
+                    token: resp.token,
                 }));
-            });
+            };
+            if (persistTo || replicateTo) {
+                this._conn.removeWithLegacyDurability({
+                    ...removeReq,
+                    persist_to: (0, bindingutilities_1.persistToToCpp)(persistTo),
+                    replicate_to: (0, bindingutilities_1.replicateToToCpp)(replicateTo),
+                }, removeCallback);
+            }
+            else {
+                this._conn.remove({
+                    ...removeReq,
+                    durability_level: (0, bindingutilities_1.durabilityToCpp)(durabilityLevel),
+                }, removeCallback);
+            }
         }, callback);
     }
     /**
@@ -650,19 +828,17 @@ class Collection {
         const cppSpecs = [];
         for (let i = 0; i < specs.length; ++i) {
             cppSpecs.push({
-                opcode: specs[i]._op,
-                flags: specs[i]._flags,
-                path: specs[i]._path,
-                original_index: i,
+                opcode_: specs[i]._op,
+                flags_: specs[i]._flags,
+                path_: specs[i]._path,
+                original_index_: i,
             });
         }
         const timeout = options.timeout || this.cluster.kvTimeout;
         return utilities_1.PromiseHelper.wrap((wrapCallback) => {
             this._conn.lookupIn({
                 id: this._cppDocId(key),
-                specs: {
-                    entries: cppSpecs,
-                },
+                specs: cppSpecs,
                 timeout,
                 partition: 0,
                 opaque: 0,
@@ -676,7 +852,7 @@ class Collection {
                         let error = (0, bindingutilities_1.errorFromCpp)(itemRes.ec);
                         let value = undefined;
                         if (itemRes.value && itemRes.value.length > 0) {
-                            value = JSON.parse(itemRes.value);
+                            value = this._subdocDecode(itemRes.value);
                         }
                         // BUG(JSCBC-1016): Should remove this workaround when the underlying bug is resolved.
                         if (itemRes.opcode === binding_1.default.protocol_subdoc_opcode.exists) {
@@ -718,11 +894,13 @@ class Collection {
         const cppSpecs = [];
         for (let i = 0; i < specs.length; ++i) {
             cppSpecs.push({
-                opcode: specs[i]._op,
-                flags: specs[i]._flags,
-                path: specs[i]._path,
-                param: specs[i]._data,
-                original_index: 0,
+                opcode_: specs[i]._op,
+                flags_: specs[i]._flags,
+                path_: specs[i]._path,
+                value_: specs[i]._data
+                    ? this._subdocEncode(specs[i]._data)
+                    : specs[i]._data,
+                original_index_: 0,
             });
         }
         const storeSemantics = options.upsertDocument
@@ -732,24 +910,24 @@ class Collection {
         const preserveExpiry = options.preserveExpiry;
         const cas = options.cas;
         const durabilityLevel = options.durabilityLevel;
+        const persistTo = options.durabilityPersistTo;
+        const replicateTo = options.durabilityReplicateTo;
         const timeout = options.timeout || this._mutationTimeout(durabilityLevel);
         return utilities_1.PromiseHelper.wrap((wrapCallback) => {
-            this._conn.mutateIn({
+            const mutateInReq = {
                 id: this._cppDocId(key),
                 store_semantics: (0, bindingutilities_1.storeSemanticToCpp)(storeSemantics),
-                specs: {
-                    entries: cppSpecs,
-                },
+                specs: cppSpecs,
                 expiry,
                 preserve_expiry: preserveExpiry || false,
                 cas: cas || binding_1.zeroCas,
-                durability_level: (0, bindingutilities_1.durabilityToCpp)(durabilityLevel),
                 timeout,
                 partition: 0,
                 opaque: 0,
                 access_deleted: false,
                 create_as_deleted: false,
-            }, (cppErr, resp) => {
+            };
+            const mutateInCallback = (cppErr, resp) => {
                 const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
                 if (resp && resp.fields) {
                     const content = [];
@@ -757,7 +935,7 @@ class Collection {
                         const itemRes = resp.fields[i];
                         let value = undefined;
                         if (itemRes.value && itemRes.value.length > 0) {
-                            value = JSON.parse(itemRes.value);
+                            value = this._subdocDecode(itemRes.value);
                         }
                         content.push(new crudoptypes_1.MutateInResultEntry({
                             value,
@@ -770,7 +948,20 @@ class Collection {
                     return;
                 }
                 wrapCallback(err, null);
-            });
+            };
+            if (persistTo || replicateTo) {
+                this._conn.mutateInWithLegacyDurability({
+                    ...mutateInReq,
+                    persist_to: (0, bindingutilities_1.persistToToCpp)(persistTo),
+                    replicate_to: (0, bindingutilities_1.replicateToToCpp)(replicateTo),
+                }, mutateInCallback);
+            }
+            else {
+                this._conn.mutateIn({
+                    ...mutateInReq,
+                    durability_level: (0, bindingutilities_1.durabilityToCpp)(durabilityLevel),
+                }, mutateInCallback);
+            }
         }, callback);
     }
     /**
@@ -826,18 +1017,20 @@ class Collection {
         const initial_value = options.initial;
         const expiry = options.expiry;
         const durabilityLevel = options.durabilityLevel;
+        const persistTo = options.durabilityPersistTo;
+        const replicateTo = options.durabilityReplicateTo;
         const timeout = options.timeout || this.cluster.kvTimeout;
         return utilities_1.PromiseHelper.wrap((wrapCallback) => {
-            this._conn.increment({
+            const incrementReq = {
                 id: this._cppDocId(key),
                 delta,
                 initial_value,
                 expiry: expiry || 0,
-                durability_level: (0, bindingutilities_1.durabilityToCpp)(durabilityLevel),
                 timeout,
                 partition: 0,
                 opaque: 0,
-            }, (cppErr, resp) => {
+            };
+            const incrementCallback = (cppErr, resp) => {
                 const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
                 if (err) {
                     return wrapCallback(err, null);
@@ -847,7 +1040,20 @@ class Collection {
                     token: resp.token,
                     value: resp.content,
                 }));
-            });
+            };
+            if (persistTo || replicateTo) {
+                this._conn.incrementWithLegacyDurability({
+                    ...incrementReq,
+                    persist_to: (0, bindingutilities_1.persistToToCpp)(persistTo),
+                    replicate_to: (0, bindingutilities_1.replicateToToCpp)(replicateTo),
+                }, incrementCallback);
+            }
+            else {
+                this._conn.increment({
+                    ...incrementReq,
+                    durability_level: (0, bindingutilities_1.durabilityToCpp)(durabilityLevel),
+                }, incrementCallback);
+            }
         }, callback);
     }
     /**
@@ -864,18 +1070,20 @@ class Collection {
         const initial_value = options.initial;
         const expiry = options.expiry;
         const durabilityLevel = options.durabilityLevel;
+        const persistTo = options.durabilityPersistTo;
+        const replicateTo = options.durabilityReplicateTo;
         const timeout = options.timeout || this.cluster.kvTimeout;
         return utilities_1.PromiseHelper.wrap((wrapCallback) => {
-            this._conn.decrement({
+            const decrementReq = {
                 id: this._cppDocId(key),
                 delta,
                 initial_value,
                 expiry: expiry || 0,
-                durability_level: (0, bindingutilities_1.durabilityToCpp)(durabilityLevel),
                 timeout,
                 partition: 0,
                 opaque: 0,
-            }, (cppErr, resp) => {
+            };
+            const decrementCallback = (cppErr, resp) => {
                 const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
                 if (err) {
                     return wrapCallback(err, null);
@@ -885,7 +1093,20 @@ class Collection {
                     token: resp.token,
                     value: resp.content,
                 }));
-            });
+            };
+            if (persistTo || replicateTo) {
+                this._conn.decrementWithLegacyDurability({
+                    ...decrementReq,
+                    persist_to: (0, bindingutilities_1.persistToToCpp)(persistTo),
+                    replicate_to: (0, bindingutilities_1.replicateToToCpp)(replicateTo),
+                }, decrementCallback);
+            }
+            else {
+                this._conn.decrement({
+                    ...decrementReq,
+                    durability_level: (0, bindingutilities_1.durabilityToCpp)(durabilityLevel),
+                }, decrementCallback);
+            }
         }, callback);
     }
     /**
@@ -900,19 +1121,21 @@ class Collection {
             options = {};
         }
         const durabilityLevel = options.durabilityLevel;
+        const persistTo = options.durabilityPersistTo;
+        const replicateTo = options.durabilityReplicateTo;
         const timeout = options.timeout || this.cluster.kvTimeout;
         return utilities_1.PromiseHelper.wrap((wrapCallback) => {
             if (!Buffer.isBuffer(value)) {
                 value = Buffer.from(value);
             }
-            this._conn.append({
+            const appendReq = {
                 id: this._cppDocId(key),
                 value,
-                durability_level: (0, bindingutilities_1.durabilityToCpp)(durabilityLevel),
                 timeout,
                 partition: 0,
                 opaque: 0,
-            }, (cppErr, resp) => {
+            };
+            const appendCallback = (cppErr, resp) => {
                 const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
                 if (err) {
                     return wrapCallback(err, null);
@@ -921,7 +1144,20 @@ class Collection {
                     cas: resp.cas,
                     token: resp.token,
                 }));
-            });
+            };
+            if (persistTo || replicateTo) {
+                this._conn.appendWithLegacyDurability({
+                    ...appendReq,
+                    persist_to: (0, bindingutilities_1.persistToToCpp)(persistTo),
+                    replicate_to: (0, bindingutilities_1.replicateToToCpp)(replicateTo),
+                }, appendCallback);
+            }
+            else {
+                this._conn.append({
+                    ...appendReq,
+                    durability_level: (0, bindingutilities_1.durabilityToCpp)(durabilityLevel),
+                }, appendCallback);
+            }
         }, callback);
     }
     /**
@@ -936,19 +1172,21 @@ class Collection {
             options = {};
         }
         const durabilityLevel = options.durabilityLevel;
+        const persistTo = options.durabilityPersistTo;
+        const replicateTo = options.durabilityReplicateTo;
         const timeout = options.timeout || this.cluster.kvTimeout;
         return utilities_1.PromiseHelper.wrap((wrapCallback) => {
             if (!Buffer.isBuffer(value)) {
                 value = Buffer.from(value);
             }
-            this._conn.prepend({
+            const prependReq = {
                 id: this._cppDocId(key),
                 value,
-                durability_level: (0, bindingutilities_1.durabilityToCpp)(durabilityLevel),
                 timeout,
                 partition: 0,
                 opaque: 0,
-            }, (cppErr, resp) => {
+            };
+            const prependCallback = (cppErr, resp) => {
                 const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
                 if (err) {
                     return wrapCallback(err, null);
@@ -957,7 +1195,20 @@ class Collection {
                     cas: resp.cas,
                     token: resp.token,
                 }));
-            });
+            };
+            if (persistTo || replicateTo) {
+                this._conn.prependWithLegacyDurability({
+                    ...prependReq,
+                    persist_to: (0, bindingutilities_1.persistToToCpp)(persistTo),
+                    replicate_to: (0, bindingutilities_1.replicateToToCpp)(replicateTo),
+                }, prependCallback);
+            }
+            else {
+                this._conn.prepend({
+                    ...prependReq,
+                    durability_level: (0, bindingutilities_1.durabilityToCpp)(durabilityLevel),
+                }, prependCallback);
+            }
         }, callback);
     }
 }