// this method only exists for compatibility with PouchDB and should not be used elsewhere. func BulkGet(w http.ResponseWriter, r *http.Request) { ctx := getContext(r) var ireqs interface{} /* options */ revs := flag(r, "revs") var ok bool if ireqs, ok = ctx.jsonBody["docs"]; !ok { res := responses.BadRequest("You were supposed to request some docs specified by their ids, and you didn't.") w.WriteHeader(res.Code) json.NewEncoder(w).Encode(res) return } reqs := ireqs.([]interface{}) res := responses.BulkGet{ Results: make([]responses.BulkGetResult, len(reqs)), } for i, ireq := range reqs { req := ireq.(map[string]interface{}) res.Results[i] = responses.BulkGetResult{ Docs: make([]responses.DocOrError, 1), } iid, ok := req["id"] if !ok { err := responses.BadRequest("missing id") res.Results[i].Docs[0].Error = &err continue } id := iid.(string) res.Results[i].Id = id path := db.CleanPath(ctx.path) + "/" + db.EscapeKey(id) rev := string(db.GetRev(path)) doc, err := db.GetTreeAt(path) if err != nil { err := responses.NotFound() res.Results[i].Docs[0].Error = &err continue } doc["_id"] = id doc["_rev"] = rev delete(doc, "_val") // pouchdb doesn't like top-level keys starting with _ if revs { // magic method to fetch _revisions // docs["_revisions"] = ... } res.Results[i].Docs[0].Ok = &doc } w.Header().Add("Content-Type", "application/json") w.WriteHeader(200) json.NewEncoder(w).Encode(res) }
func TestCouchDBSpecialEndpoints(t *testing.T) { g := Goblin(t) RegisterFailHandler(func(m string, _ ...int) { g.Fail(m) }) g.Describe("couchdb db special endpoints", func() { g.BeforeEach(func() { rec = httptest.NewRecorder() server = handle.BuildHandler() }) g.Before(func() { db.Erase() db.Start() populateDB() }) g.After(func() { db.End() }) var rev string var oldrev string var id string g.It("_all_docs for a sub db", func() { r, _ = http.NewRequest("GET", "/vehicles/_all_docs", nil) server.ServeHTTP(rec, r) var res responses.AllDocs json.Unmarshal(rec.Body.Bytes(), &res) Expect(res.Rows).To(HaveLen(3)) Expect(res.Rows[2].Id).To(Equal(res.Rows[2].Key)) rev, _ := res.Rows[2].Value.(map[string]interface{})["rev"] Expect(rev).To(HavePrefix("1-")) keys := []string{res.Rows[0].Id, res.Rows[1].Key, res.Rows[2].Id} Expect(keys).To(ConsistOf("airplane", "boat", "car")) }) g.It("_all_docs with selected keys", func() { r, _ = http.NewRequest("GET", "/vehicles/_all_docs?keys=%5B%22airplane%22,%22boat%22%5D", nil) server.ServeHTTP(rec, r) var res responses.AllDocs json.Unmarshal(rec.Body.Bytes(), &res) Expect(res.Rows).To(HaveLen(2)) keys := []string{res.Rows[0].Id, res.Rows[1].Key} Expect(keys).To(ConsistOf("airplane", "boat")) }) g.It("all_docs with include_docs -- for another sub db", func() { r, _ = http.NewRequest("GET", "/vehicles/airplane/_all_docs?include_docs=true", nil) server.ServeHTTP(rec, r) var res responses.AllDocs json.Unmarshal(rec.Body.Bytes(), &res) Expect(res.Rows).To(HaveLen(3)) docid, _ := res.Rows[1].Doc["_id"] Expect(res.Rows[1].Key).To(Equal(docid)) rev, _ := res.Rows[1].Value.(map[string]interface{})["rev"] docrev, _ := res.Rows[1].Doc["_rev"] Expect(rev).To(Equal(docrev)) keys := []string{res.Rows[0].Id, res.Rows[1].Key, res.Rows[2].Id} sort.Strings(keys) Expect(keys).To(Equal([]string{"air", "land", "water"})) docs := map[string]interface{}{ res.Rows[0].Key: res.Rows[0].Doc, res.Rows[1].Key: res.Rows[1].Doc, res.Rows[2].Key: res.Rows[2].Doc, } Expect(docs).To(HaveKey("air")) Expect(res.Rows[0].Doc).To(HaveKey("_rev")) Expect(res.Rows[0].Doc).To(HaveKeyWithValue("_id", res.Rows[0].Id)) }) g.It("_bulk_get", func() { r, _ = http.NewRequest("POST", "/vehicles/_bulk_get", bytes.NewReader([]byte(`{ "docs": [ {"id": "nonexisting-doc"}, {"id": "car"}, {"_id": "airplane"} ] }`))) server.ServeHTTP(rec, r) var res responses.BulkGet json.Unmarshal(rec.Body.Bytes(), &res) Expect(res.Results[0].Docs[0].Ok).To(BeNil()) Expect(res.Results[0].Docs[0].Error).ToNot(BeNil()) Expect(res.Results[1].Docs[0].Ok).ToNot(BeNil()) Expect(res.Results[1].Docs[0].Error).To(BeNil()) doc := *res.Results[1].Docs[0].Ok id, _ := doc["_id"] irev, _ := doc["_rev"] rev = irev.(string) water, _ := doc["water"] Expect(id.(string)).To(Equal("car")) Expect(res.Results[1].Id).To(Equal(id)) Expect(water).To(BeEquivalentTo(value(false))) Expect(res.Results[2].Docs[0].Ok).To(BeNil()) Expect(res.Results[0].Docs[0].Error).ToNot(BeNil()) }) g.It("_bulk_docs", func() { r, _ = http.NewRequest("POST", "/vehicles/_bulk_docs", bytes.NewReader([]byte(`{ "docs": [ {"everywhere": true}, {"_id": "car", "_rev": "`+rev+`", "space": false, "land": true}, {"_id": "airplane", "nowhere": false}, {"_id": "_local/.abchtru", "replication+data": "k"}, {"_id": "empty-doc"}, {"_id": "doc-with-a-rev-already-set", "_rev": "4-sa98hsa3i4", "val": 33} ] }`))) server.ServeHTTP(rec, r) Expect(rec.Code).To(Equal(201)) var res []responses.BulkDocsResult json.Unmarshal(rec.Body.Bytes(), &res) Expect(res).To(HaveLen(6)) Expect(res[0].Error).To(Equal("")) Expect(res[0].Ok).To(Equal(true)) Expect(res[0].Rev).To(HavePrefix("1-")) id = res[0].Id Expect(res[1].Id).To(Equal("car")) prevn, _ := strconv.Atoi(strings.Split(rev, "-")[0]) Expect(res[1].Rev).To(HavePrefix(fmt.Sprintf("%d-", prevn+1))) oldrev = rev rev = res[1].Rev cfe := responses.ConflictError() Expect(res[2].Error).To(Equal(cfe.Error)) Expect(res[3].Id).To(Equal("_local/.abchtru")) Expect(res[3].Ok).To(Equal(true)) Expect(res[4].Ok).To(Equal(true)) Expect(res[4].Rev).To(HavePrefix("1-")) Expect(res[5].Ok).To(Equal(true)) Expect(res[5].Rev).To(HavePrefix("5-")) }) g.It("_bulk_docs with new_edits=false", func() { r, _ = http.NewRequest("POST", "/animals/_bulk_docs", bytes.NewReader([]byte(`{ "docs": [ {"_id": "0", "_rev": "34-83fsop4", "name": "albatroz"}, {"_id": "1", "_rev": "0-a0a0a0a0", "name": "puppy"}, {"_id": "2"} ], "new_edits": false }`))) server.ServeHTTP(rec, r) Expect(rec.Code).To(Equal(201)) var res []responses.BulkDocsResult json.Unmarshal(rec.Body.Bytes(), &res) Expect(res).To(HaveLen(3)) Expect(res[0].Ok).To(Equal(true)) Expect(res[1].Ok).To(Equal(true)) Expect(res[2].Ok).To(Equal(false)) Expect(db.GetRev("/animals/0")).To(BeEquivalentTo("34-83fsop4")) Expect(db.GetRev("/animals/1")).ToNot(BeEquivalentTo("0-a0a0a0a0")) Expect(db.GetValueAt("/animals/0/name")).To(BeEquivalentTo(`"albatroz"`)) Expect(db.GetValueAt("/animals/1/name")).To(BeEquivalentTo(`"dog"`)) }) g.It("should have the correct docs saved", func() { Expect(db.GetValueAt("/vehicles/" + id + "/everywhere")).To(BeEquivalentTo("true")) Expect(db.GetLocalDocJsonAt("/vehicles/_local/.abchtru")).To(MatchJSON(`{ "_id": "_local/.abchtru", "_rev": "0-1", "replication+data": "k" }`)) }) g.It("shouldn't show _local docs on _all_docs", func() { r, _ = http.NewRequest("GET", "/vehicles/_all_docs", nil) server.ServeHTTP(rec, r) var res responses.AllDocs json.Unmarshal(rec.Body.Bytes(), &res) Expect(res.Rows).To(HaveLen(5)) }) g.It("_revs_diff", func() { r, _ = http.NewRequest("POST", "/vehicles/_revs_diff", bytes.NewReader([]byte(`{ "everywhere": ["2-invalidrev"], "car": ["`+oldrev+`", "`+rev+`", "1-invalidrev"], "airplane": ["1-nonexisting"] }`))) server.ServeHTTP(rec, r) Expect(rec.Code).To(Equal(200)) var res map[string]responses.RevsDiffResult json.Unmarshal(rec.Body.Bytes(), &res) everywhere, _ := res["everywhere"] car, _ := res["car"] airplane, _ := res["airplane"] Expect(everywhere.Missing).To(Equal([]string{"2-invalidrev"})) Expect(car.Missing).To(Equal([]string{oldrev, "1-invalidrev"})) Expect(airplane.Missing).To(Equal([]string{"1-nonexisting"})) }) }) }
/* Currently _all_docs does not guarantee key order and should not be used for querying or anything. It is here just to provide PouchDB replication support. */ func AllDocs(w http.ResponseWriter, r *http.Request) { ctx := getContext(r) /* options */ include_docs := flag(r, "include_docs") jsonKeys := param(r, "keys") // startkey := param(r, "startkey") // endkey := param(r, "endkey") // descending := flag(r, "descending") // skip := param(r, "skip") // limit := param(r, "limit") path := db.CleanPath(ctx.path) tree, err := db.GetTreeAt(path) if err != nil { res := responses.UnknownError(err.Error()) w.WriteHeader(res.Code) json.NewEncoder(w).Encode(res) return } res := responses.AllDocs{ TotalRows: 0, Offset: 0, // temporary Rows: make([]responses.Row, 0), } if jsonKeys != "" { // in case "keys" was provided we can just pick the requested keys from our tree var keys []string err = json.Unmarshal([]byte(jsonKeys), &keys) if err != nil { res := responses.BadRequest() w.WriteHeader(res.Code) json.NewEncoder(w).Encode(res) return } for _, id := range keys { var doc interface{} var ok bool if doc, ok = tree[id]; !ok || strings.HasPrefix(id, "_") { res.Rows = append(res.Rows, responses.Row{ Key: id, Error: (responses.NotFound()).Reason, }) } rev := string(db.GetRev(path + "/" + db.EscapeKey(id))) row := responses.Row{ Id: id, Key: id, Value: map[string]interface{}{"rev": rev}, } if include_docs { row.Doc = doc.(map[string]interface{}) row.Doc["_id"] = id row.Doc["_rev"] = rev delete(row.Doc, "_val") // pouchdb doesn't like top-level keys starting with _ } res.Rows = append(res.Rows, row) res.TotalRows += 1 } } else { // otherwise iterate through the entire tree for id, doc := range tree { if strings.HasPrefix(id, "_") { continue } rev := string(db.GetRev(path + "/" + db.EscapeKey(id))) row := responses.Row{ Id: id, Key: id, Value: map[string]interface{}{"rev": rev}, } if include_docs { row.Doc = doc.(map[string]interface{}) row.Doc["_id"] = id row.Doc["_rev"] = rev delete(row.Doc, "_val") // pouchdb doesn't like top-level keys starting with _ } res.Rows = append(res.Rows, row) res.TotalRows += 1 } } w.Header().Add("Content-Type", "application/json") w.WriteHeader(200) json.NewEncoder(w).Encode(res) }
// this method only exists for compatibility with PouchDB and should not be used elsewhere. func BulkDocs(w http.ResponseWriter, r *http.Request) { ctx := getContext(r) var idocs interface{} var iid interface{} var irev interface{} var id string var rev string var ok bool if idocs, ok = ctx.jsonBody["docs"]; !ok { res := responses.BadRequest("You're supposed to send an array of docs to input on the database, and you didn't.") w.WriteHeader(res.Code) json.NewEncoder(w).Encode(res) return } /* options */ new_edits := true if inew_edits, ok := ctx.jsonBody["new_edits"]; ok { new_edits = inew_edits.(bool) } path := db.CleanPath(ctx.path) docs := idocs.([]interface{}) res := make([]responses.BulkDocsResult, len(docs)) var err error if new_edits { /* procedure for normal document saving */ for i, idoc := range docs { var newrev string localDoc := false doc := idoc.(map[string]interface{}) if iid, ok = doc["_id"]; ok { id = iid.(string) if strings.HasPrefix(id, "_local/") { localDoc = true } if irev, ok = doc["_rev"]; ok { rev = irev.(string) } else { rev = "" } } else { id = db.Random(5) } if !localDoc { // procedure for normal documents // check rev matching: if iid != nil /* when iid is nil that means the doc had no _id, so we don't have to check. */ { currentRev := db.GetRev(path + "/" + db.EscapeKey(id)) if string(currentRev) != rev && !bytes.HasPrefix(currentRev, []byte{'0', '-'}) { // rev is not matching, don't input this document e := responses.ConflictError() res[i] = responses.BulkDocsResult{ Id: id, Error: e.Error, Reason: e.Reason, } continue } } // proceed to write the document. newrev, err = db.ReplaceTreeAt(path+"/"+db.EscapeKey(id), doc, false) if err != nil { e := responses.UnknownError() res[i] = responses.BulkDocsResult{ Id: id, Error: e.Error, Reason: e.Reason, } continue } } else { // procedure for local documents // check rev matching: currentRev := db.GetLocalDocRev(path + "/" + id) if currentRev != "0-0" && currentRev != rev { // rev is not matching, don't input this document e := responses.ConflictError() res[i] = responses.BulkDocsResult{ Id: id, Error: e.Error, Reason: e.Reason, } continue } // proceed to write the document. newrev, err = db.SaveLocalDocAt(path+"/"+id, doc) if err != nil { e := responses.UnknownError() res[i] = responses.BulkDocsResult{ Id: id, Error: e.Error, Reason: e.Reason, } continue } } res[i] = responses.BulkDocsResult{ Id: id, Ok: true, Rev: newrev, } } } else { /* procedure for replication-type _bulk_docs (new_edits=false)*/ for i, idoc := range docs { id = "" rev = "" doc := idoc.(map[string]interface{}) if iid, ok = doc["_id"]; ok { id = iid.(string) if irev, ok = doc["_rev"]; ok { rev = irev.(string) } } if id == "" || rev == "" { e := responses.UnknownError() res[i] = responses.BulkDocsResult{ Id: id, Error: e.Error, Reason: e.Reason, } continue } // proceed to write currentRev := db.GetRev(path + "/" + db.EscapeKey(id)) if rev < string(currentRev) { // will write only the rev if it is not the winning rev db.AcknowledgeRevFor(path+"/"+db.EscapeKey(id), rev) } else { // otherwise will write the whole doc normally (replacing the current) rev, err = db.ReplaceTreeAt(path+"/"+db.EscapeKey(id), doc, true) } // handle write error if err != nil { e := responses.UnknownError() res[i] = responses.BulkDocsResult{ Id: id, Error: e.Error, Reason: e.Reason, } continue } res[i] = responses.BulkDocsResult{ Id: id, Ok: true, Rev: rev, } } } w.WriteHeader(201) json.NewEncoder(w).Encode(res) }