[chttpd_auth]
; proxy authentication secret. shared by CouchDB and feat accounts service.
secret = 609e42e49def19dcb2428027d95b9db7
require_valid_user = true
proxy_use_secret = true

[cors]
; cors origins. * is bad, set all frontend domain names here.
origins = *
headers = accept, authorization, content-type, origin, referer, X-Auth-CouchDB-UserName, X-Auth-CouchDB-Token
methods = GET, PUT, POST, HEAD, DELETE
credentials = true

[httpd]
enable_cors = true

[couch_peruser]
enable = true

[chttpd]
authentication_handlers = {chttpd_auth, cookie_authentication_handler},{chttpd_auth, proxy_authentication_handler},{chttpd_auth, default_authentication_handler}

map $request_method $proxy_method {
        POST PUT;
        default $request_method;
}

server {
# port for elb
  listen 5984;
# server name. maybe couchdb.feat.com
  server_name localhost;

  set $couchdb_base "http://localhost:5984";

  error_page 418 = @normal;
  error_page 420 = @newuser;
  recursive_error_pages on;

  location @normal {
# proxy to couchdb
    proxy_pass $couchdb_base;
    proxy_redirect off;
    proxy_buffering off;
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Auth-CouchDB-Roles "";
  }

# HACK: set roles = _admin when create user
  location @newuser {
    set $the_username "$http_x_auth_couchdb_username";

    proxy_pass "$couchdb_base/_users/org.couchdb.user:$the_username";
    proxy_redirect off;
    proxy_buffering off;
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

    proxy_set_header X-Auth-CouchDB-Roles _admin;

    proxy_method $proxy_method;

    set $body '{"name": "${the_username}", "roles": [], "type": "user"}';
    proxy_set_body $body;
  }

  location / {
    return 418;
  }

  location ~ /_users/org.couchdb.user:(?<username>.+) {
    set $the_username "$http_x_auth_couchdb_username";

    if ($the_username != $username) {
      return 418;
    }

    if ($request_method != PUT) {
      return 418;
    }

    return 420;
  }

  location /_users/create-new-user {
    if ($request_method !~* (POST|OPTIONS)) {
      return 405;
    }

    return 420;
  }

}

{
    "data": {
        "headers": {
            "X-Auth-CouchDB-UserName": "4222704093994",
            "X-Auth-CouchDB-Token": "2197693d9ab1c56bf45633f6326d0078d670fd1d"
        },
        "dbname": "userdb-34323232373034303933393934"
    }
}

// 从 https://accounts.feat.com/couchdb/token/ 获取
{
    "X-Auth-CouchDB-UserName": "4222704093994",
    "X-Auth-CouchDB-Token": "2197693d9ab1c56bf45633f6326d0078d670fd1d"
}

{
    "name": "4222704093994",
    "type": "user",
    "roles": []
}

     var PouchDB = require('pouchdb'); 
     class MyPouchDB extends PouchDB {
        constructor (db, opts) {
          opts.fetch = function(url, options) {
            options.credentials = 'omit';
            options.headers = {...options.headers, ...(opts.headers || {})};
            return PouchDB.fetch(url, options);
          }
          opts.skip_setup = true;
          super(db, opts);
        }

        setupPromise = undefined;

        ensure_user_and_db () {
// 这个函数只支持http、https adapter，如果要同时使用PouchDB的其他adapter需要做兼容处理。
          if (this.setupPromise) {
            return this.setupPromise;
          }

          this.setupPromise = this.info().then(res => {
            if (res && !res.error) {
              return Promise.resolve(res);
            }
            const err = res;
            if (err && err.error && err.error === 'not_found') {
              return this.signUp();
            } else {
              return Promise.reject(err);
            }
          }).catch(function (err) {
            if (err && err.status && err.status === 412) {
              return true;
            }
            return Promise.reject(err);
          })

          this.setupPromise.catch(() => {
            this.setupPromise = null;
          });

          return this.setupPromise;
        }

        signUp () {
          const username = this.__opts.headers['X-Auth-CouchDB-UserName'];
          const user = {
            _id: `org.couchdb.user:${username}`,
            name: username,
            roles: [],
            type: 'user',
          };

          const getBaseUrl = function (db) {
            const prebase = db.substr(-1, 1) === '/' ? db.substr(0, -1) : db;
            return prebase.split('/').slice(0, -1).join('/');
          }

          const usersDb = new this.constructor(getBaseUrl(this.name) + '/_users', this.__opts);

          return usersDb.put(user)
        }
      }

      class PouchDBStorage {
        constructor(db, options = {}) {
          if (typeof db !== "string" && options == {}) {
            this.db = db;
          } else {
            this.db = new MyPouchDB(db, options);
          }

          this.docRevs = {};
        }

        async getItem(key) {
          await this.db.ensure_user_and_db();
          try {
            const doc = await this.db.get(key);
            this.docRevs[key] = doc._rev;
            return JSON.stringify(doc.doc);
          } catch (err) {
            if (err && err.status && err.status === 404) {
              return undefined;
            } else {
              throw err;
            }
          }
        }

        async setItem(key, value) {
          await this.db.ensure_user_and_db();
          const doc = JSON.parse(value);
          const _rev = this.docRevs[key];

          try {
            const result = await this.db.put({ _id: key, _rev, doc });

            this.docRevs[key] = result.rev;
            return result;
          } catch (err) {
            if (err && err.status && err.status === 409) {
              // TODO: 版本冲突，需要重新获取最新版本并进行处理。这里的例子是覆盖远端修改。
              const new_value = await this.getItem(key);
              // value = merge(value, new_value)
              return await this.setItem(key, value);
            } else {
              throw err;
            }
          }
        }

        async removeItem(key) {
          await this.db.ensure_user_and_db();
          if (!this.docRevs[key]) {
            // 删除一个本地没有的key，也许是搞错了什么？这里只是简单获取最新版本并删除。
            const v = await this.getItem(key);
            if (!v) {
              return;
            }
          }

          // TODO: 跟setItem类似，这里也可能出现版本冲突，需要进行处理。
          await this.db.remove({ _id: key, _rev: this.docRevs[key] });
          delete this.docRevs[key];
        }
      }

      const getDbToken = async function (auth) {
        const ret = await fetch('http://127.0.0.1:8123/couchdb/token/', {headers: new Headers({"Authorization": auth})})
        return await ret.json()
      }


      const setupStorage = async function (opts) {
        const {data} = await getDbToken(opts);
        if (!data) {
          // TODO
          return;
        }
        const {headers, dbname} = data;
        const storage = new PouchDBStorage('http://127.0.0.1:5984/'+dbname, {headers});
        return storage;
      }

      const storage = await setupStorage("Bearer qAg3jdtuCUB4dWuc8d5pD81PnpCqUX");

      await storage.getItem('test') === undefined;
      await storage.setItem('test', '{"test": 1}');
      await storage.getItem('test') === '{"test": 1}';
      await storage.removeItem('test');
      await storage.getItem('test') === undefined;