How to use couchbase - 10 common examples

cb.remaining = 0;

    for (var i = 0; i < ops.length; i++) {

        var fnparams = ops[i];
        var fn = fnparams.shift();
        fnparams.push([cb, fn.name]);
        fn.apply(cb, fnparams);
    }

    cb.remaining = i-1;
}

for (var i = 0; i < max_handles; i++) {
    var cb = new driver.Couchbase(
            "localhost:8091");

    cb.id = i + 0;
    var cberr = (function(iter) {
        return function() {
            console.log("Error handler for " + iter);
            errorHandler.apply(this, arguments);
        }
    })(cb.id);
    cb.on("error", cberr);

    // Try to connect to the server
    var clofn = function (cbv) {
        return function() {
            on_connect(cbv);
        }

it('should connect couchbase bucket without authorization', async () => {
    // Arrange
    const host = faker.random.word();
    const bucketName = faker.random.word();
    const couchbase = new CouchbaseCache({host, bucketName});
    const bucket = createBucket();
    const spy = sandbox.stub(Cluster.prototype, 'openBucket').returns(bucket as any);

    // Act
    await couchbase.connect();

    // Assert
    expect(spy.calledWithExactly(bucketName)).to.eq(true);
  });

it('should return cached content if it is valid', async () => {
    // Arrange
    const host = faker.random.word();
    const bucketName = faker.random.word();
    const username = faker.random.word();
    const password = faker.random.word();
    const key = faker.random.word();
    const couchbase = new CouchbaseCache({host, bucketName, username, password});
    const bucket = createBucket();
    const data = faker.random.word();
    sandbox.stub(Cluster.prototype, 'openBucket').returns(bucket as any);
    const getSpy = sandbox.stub(bucket, 'get')
      .callsArgWith(1, null, {
        value: data
      });

    // Act
    await couchbase.connect();
    const item = await couchbase.get(key);

    // Assert
    expect(getSpy.calledWith(key, sinon.match.func)).to.eq(true);
    expect(item).to.eq(data);
  });

bucket.get(k, function (err, gdoc) {
                expect(err).to.be.ok
                expect(err.code).to.equal(couchbase.errors.keyNotFound)

                // new ones
                var k = userSchema.getRefKey('email', user.email)
                bucket.get(k, function (err, indexRes) {
                  checkRes(err, indexRes)
                  k = userSchema.getRefKey('userName', user.username)
                  bucket.get(k, function (err, indexRes) {
                    checkRes(err, indexRes)
                    done()
                  })
                })
              })
            })

function start_connections(logbucket_config, cachebucket_config) {
    // Connect with couchbase server.  All subsequent API calls
    // to `couchbase` library is made via this Connection
    var cb_db = new couchbase.Cluster(logbucket_config.connstr);
    var cb_ca = new couchbase.Cluster(cachebucket_config.connstr);
    db = cb_db.openBucket(logbucket_config.bucket, logbucket_config.password);
    db.on('connect', function (err) {
        db.operationTimeout = OPERATION_TIMEOUT;
        if (err) {
            console.error("Failed to connect to cluster: " + err);
            process.exit(1);
        }
        console.log('Couchbase connected to ' + logbucket_config.bucket);
    });
    cache = cb_ca.openBucket(cachebucket_config.bucket, cachebucket_config.password);
    cache.on('connect', function (err) {
        if (err) {
            console.error("Failed to connect to cluster: " + err);
            process.exit(1);
        }

exports.start = function(logbucket_config, cachebucket_config) {
        // Connect with couchbase server.  All subsequent API calls
        // to `couchbase` library is made via this Connection
        var cb_db = new couchbase.Cluster(logbucket_config.connstr);
        var cb_ca = new couchbase.Cluster(cachebucket_config.connstr);
        var db = cb_db.openBucket(logbucket_config.bucket, logbucket_config.password);
        db.on('connect', function (err) {
          if (err) {
            console.error("Failed to connect to cluster: " + err);
            process.exit(1);
          }
          console.log('Couchbase connected to ' + logbucket_config.bucket);
        });
        var cache = cb_ca.openBucket(cachebucket_config.bucket, cachebucket_config.password);
        cache.on('connect', function (err) {
          if (err) {
            console.error("Failed to connect to cluster: " + err);
            process.exit(1);
         }
         console.log('Couchbase connected to ' + cachebucket_config.bucket);
        });

exports.start = function(logbucket_config, cachebucket_config) {
        // Connect with couchbase server.  All subsequent API calls
        // to `couchbase` library is made via this Connection
        var cb_db = new couchbase.Cluster(logbucket_config.connstr);
        var cb_ca = new couchbase.Cluster(cachebucket_config.connstr);
        var db = cb_db.openBucket(logbucket_config.bucket, logbucket_config.password);
        db.on('connect', function (err) {
          if (err) {
            console.error("Failed to connect to cluster: " + err);
            process.exit(1);
          }
          console.log('Couchbase connected to ' + logbucket_config.bucket);
        });
        var cache = cb_ca.openBucket(cachebucket_config.bucket, cachebucket_config.password);
        cache.on('connect', function (err) {
          if (err) {
            console.error("Failed to connect to cluster: " + err);
            process.exit(1);
         }
         console.log('Couchbase connected to ' + cachebucket_config.bucket);

function start_connections(logbucket_config, cachebucket_config) {
    // Connect with couchbase server.  All subsequent API calls
    // to `couchbase` library is made via this Connection
    var cb_db = new couchbase.Cluster(logbucket_config.connstr);
    var cb_ca = new couchbase.Cluster(cachebucket_config.connstr);
    db = cb_db.openBucket(logbucket_config.bucket, logbucket_config.password);
    db.on('connect', function (err) {
        db.operationTimeout = OPERATION_TIMEOUT;
        if (err) {
            console.error("Failed to connect to cluster: " + err);
            process.exit(1);
        }
        console.log('Couchbase connected to ' + logbucket_config.bucket);
    });
    cache = cb_ca.openBucket(cachebucket_config.bucket, cachebucket_config.password);
    cache.on('connect', function (err) {
        if (err) {
            console.error("Failed to connect to cluster: " + err);
            process.exit(1);
        }
        console.log('Couchbase connected to ' + cachebucket_config.bucket);

// vim:ts=2 sw=2:

var couchnode = require('couchbase');

console.log("--------------------------------------------------------------------------");
console.log("Couchbase Connections");
console.log("--------------------------------------------------------------------------");


var cb = new couchnode.Connection({
    "password": "",
    "host": "localhost",
    "bucket": "default"
  }, 
  function(err) {
    if (err) {
      throw (err)
    }
    console.log( "Information about Couchase Object" );
    console.log( cb );
    console.log("\n\n--------------------------------------------------------------------------");
    process.exit(0); 
  }
);

exports.setup = function (req, res) {
	db = new couchbase.Connection({
		host: req.params.host + ":" + req.params.port,
		bucket: req.params.bucket,
		connectionTimeout: '500'
	}, function (err) {
		if (err) {
			console.log('=>DB CONNECTION ERR:', err);
		} else {
			console.log('=>DB CONNECTED');
		}});
  
	// Create index
	var iterator_list = {
			map: ['function(doc, meta) {emit(meta.id,meta.expiration);}'].join('\n ')
		}
    
	// Create Design Document