v2

LICENSE.md

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright © 2020 Nikita Tokarchuk
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

README.md

@@ -1,21 +1 @@
-# mongox-go-driver
+mongox-go-driver
-
-## testing locally
-
-reqs:
-- mongodb v4.0 or newer run on localhost
-- golang v1.13 or newer
-
-test it by calling go tests
-```sh
-$ go test ./...
-```
-
-## testing by using dockerfile
-
-reqs:
-- docker with buildkit
-
-```sh
-$ DOCKER_BUILDKIT=1 docker build -t mongox-testing -f testing.Dockerfile .
-```

go.mod

@@ -1,10 +1,13 @@
 module github.com/mainnika/mongox-go-driver/v2
 
-go 1.13
-
 require (
-	github.com/modern-go/reflect2 v1.0.2
+	github.com/google/go-cmp v0.3.0 // indirect
-	github.com/stretchr/testify v1.8.4
+	github.com/klauspost/compress v1.10.1 // indirect
-	github.com/valyala/bytebufferpool v1.0.0
+	github.com/pkg/errors v0.9.1 // indirect
-	go.mongodb.org/mongo-driver v1.11.6
+	github.com/xdg/stringprep v1.0.0 // indirect
+	go.mongodb.org/mongo-driver v1.3.0
+	golang.org/x/crypto v0.0.0-20200221231518-2aa609cf4a9d // indirect
+	golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e // indirect
 )
+
+go 1.13

go.sum

@@ -1,66 +1,116 @@
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/go-stack/stack v1.8.0 h1:5SgMzNM5HxrEjV0ww2lTmX6E2Izsfxas4+YHWRs3Lsk=
+github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
+github.com/gobuffalo/attrs v0.0.0-20190224210810-a9411de4debd/go.mod h1:4duuawTqi2wkkpB4ePgWMaai6/Kc6WEz83bhFwpHzj0=
+github.com/gobuffalo/depgen v0.0.0-20190329151759-d478694a28d3/go.mod h1:3STtPUQYuzV0gBVOY3vy6CfMm/ljR4pABfrTeHNLHUY=
+github.com/gobuffalo/depgen v0.1.0/go.mod h1:+ifsuy7fhi15RWncXQQKjWS9JPkdah5sZvtHc2RXGlg=
+github.com/gobuffalo/envy v1.6.15/go.mod h1:n7DRkBerg/aorDM8kbduw5dN3oXGswK5liaSCx4T5NI=
+github.com/gobuffalo/envy v1.7.0/go.mod h1:n7DRkBerg/aorDM8kbduw5dN3oXGswK5liaSCx4T5NI=
+github.com/gobuffalo/flect v0.1.0/go.mod h1:d2ehjJqGOH/Kjqcoz+F7jHTBbmDb38yXA598Hb50EGs=
+github.com/gobuffalo/flect v0.1.1/go.mod h1:8JCgGVbRjJhVgD6399mQr4fx5rRfGKVzFjbj6RE/9UI=
+github.com/gobuffalo/flect v0.1.3/go.mod h1:8JCgGVbRjJhVgD6399mQr4fx5rRfGKVzFjbj6RE/9UI=
+github.com/gobuffalo/genny v0.0.0-20190329151137-27723ad26ef9/go.mod h1:rWs4Z12d1Zbf19rlsn0nurr75KqhYp52EAGGxTbBhNk=
+github.com/gobuffalo/genny v0.0.0-20190403191548-3ca520ef0d9e/go.mod h1:80lIj3kVJWwOrXWWMRzzdhW3DsrdjILVil/SFKBzF28=
+github.com/gobuffalo/genny v0.1.0/go.mod h1:XidbUqzak3lHdS//TPu2OgiFB+51Ur5f7CSnXZ/JDvo=
+github.com/gobuffalo/genny v0.1.1/go.mod h1:5TExbEyY48pfunL4QSXxlDOmdsD44RRq4mVZ0Ex28Xk=
+github.com/gobuffalo/gitgen v0.0.0-20190315122116-cc086187d211/go.mod h1:vEHJk/E9DmhejeLeNt7UVvlSGv3ziL+djtTr3yyzcOw=
+github.com/gobuffalo/gogen v0.0.0-20190315121717-8f38393713f5/go.mod h1:V9QVDIxsgKNZs6L2IYiGR8datgMhB577vzTDqypH360=
+github.com/gobuffalo/gogen v0.1.0/go.mod h1:8NTelM5qd8RZ15VjQTFkAW6qOMx5wBbW4dSCS3BY8gg=
+github.com/gobuffalo/gogen v0.1.1/go.mod h1:y8iBtmHmGc4qa3urIyo1shvOD8JftTtfcKi+71xfDNE=
+github.com/gobuffalo/logger v0.0.0-20190315122211-86e12af44bc2/go.mod h1:QdxcLw541hSGtBnhUc4gaNIXRjiDppFGaDqzbrBd3v8=
+github.com/gobuffalo/mapi v1.0.1/go.mod h1:4VAGh89y6rVOvm5A8fKFxYG+wIW6LO1FMTG9hnKStFc=
+github.com/gobuffalo/mapi v1.0.2/go.mod h1:4VAGh89y6rVOvm5A8fKFxYG+wIW6LO1FMTG9hnKStFc=
+github.com/gobuffalo/packd v0.0.0-20190315124812-a385830c7fc0/go.mod h1:M2Juc+hhDXf/PnmBANFCqx4DM3wRbgDvnVWeG2RIxq4=
+github.com/gobuffalo/packd v0.1.0/go.mod h1:M2Juc+hhDXf/PnmBANFCqx4DM3wRbgDvnVWeG2RIxq4=
+github.com/gobuffalo/packr/v2 v2.0.9/go.mod h1:emmyGweYTm6Kdper+iywB6YK5YzuKchGtJQZ0Odn4pQ=
+github.com/gobuffalo/packr/v2 v2.2.0/go.mod h1:CaAwI0GPIAv+5wKLtv8Afwl+Cm78K/I/VCm/3ptBN+0=
+github.com/gobuffalo/syncx v0.0.0-20190224160051-33c29581e754/go.mod h1:HhnNqWY95UYwwW3uSASeV7vtgYkT2t16hJgV3AEPUpw=
 github.com/golang/snappy v0.0.1 h1:Qgr9rKW7uDUkrbSmQeiDsGa8SjGyCOGtuasMWwvp2P4=
 github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/google/go-cmp v0.5.2 h1:X2ev0eStA3AbceY54o37/0PQ/UWqKEiiO2dKL5OPaFM=
+github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
-github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.3.0 h1:crn/baboCvb5fXaQ0IJ1SGTsTVrWpDsCWC8EGETZijY=
-github.com/klauspost/compress v1.13.6 h1:P76CopJELS0TiO2mebmnzgWaajssP/EszplttgQxcgc=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/klauspost/compress v1.13.6/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=
+github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
-github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
+github.com/joho/godotenv v1.3.0/go.mod h1:7hK45KPybAkOC6peb+G5yklZfMxEjkZhHbwpqxOKXbg=
+github.com/karrick/godirwalk v1.8.0/go.mod h1:H5KPZjojv4lE+QYImBI8xVtrBRgYrIVsaRPx4tDPEn4=
+github.com/karrick/godirwalk v1.10.3/go.mod h1:RoGL9dQei4vP9ilrpETWE8CLOZ1kiN0LhBygSwrAsHA=
+github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00=
+github.com/klauspost/compress v1.9.5 h1:U+CaK85mrNNb4k8BNOfgJtJ/gr6kswUCFj6miSzVC6M=
+github.com/klauspost/compress v1.9.5/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A=
+github.com/klauspost/compress v1.10.1 h1:a/QY0o9S6wCi0XhxaMX/QmusicNUqCqFugR6WKPOSoQ=
+github.com/klauspost/compress v1.10.1/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
+github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
+github.com/markbates/oncer v0.0.0-20181203154359-bf2de49a0be2/go.mod h1:Ld9puTsIW75CHf65OeIOkyKbteujpZVXDpWK6YGZbxE=
-github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/markbates/safe v1.0.1/go.mod h1:nAqgmRi7cY2nqMc92/bSEeQA+R4OheNU2T1kNSCBdG0=
-github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe h1:iruDEfMl2E6fbMZ9s0scYfZQ84/6SPL6zC8ACM2oIL0=
 github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe/go.mod h1:wL8QJuTMNUDYhXwkmfOly8iTdp5TEcJFWZD2D7SIkUc=
+github.com/pelletier/go-toml v1.4.0/go.mod h1:PN7xzY2wHTK0K9p34ErDQMlFxa51Fk0OUruD3k1mMwo=
+github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rogpeppe/go-internal v1.1.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
+github.com/rogpeppe/go-internal v1.2.2/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
+github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
+github.com/sirupsen/logrus v1.4.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
+github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q=
+github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
+github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
+github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
-github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 github.com/tidwall/pretty v1.0.0 h1:HsD+QiTn7sK6flMKIvNmpqz1qrpP3Ps6jOKIKMooyg4=
 github.com/tidwall/pretty v1.0.0/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk=
-github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
+github.com/xdg/scram v0.0.0-20180814205039-7eeb5667e42c h1:u40Z8hqBAAQyv+vATcGgV0YCnDjqSL7/q/JyPhhJSPk=
-github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
+github.com/xdg/scram v0.0.0-20180814205039-7eeb5667e42c/go.mod h1:lB8K/P019DLNhemzwFU4jHLhdvlE6uDZjXFejJXr49I=
-github.com/xdg-go/pbkdf2 v1.0.0 h1:Su7DPu48wXMwC3bs7MCNG+z4FhcyEuz5dlvchbq0B0c=
+github.com/xdg/stringprep v0.0.0-20180714160509-73f8eece6fdc/go.mod h1:Jhud4/sHMO4oL310DaZAKk9ZaJ08SJfe+sJh0HrGL1Y=
-github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI=
+github.com/xdg/stringprep v1.0.0 h1:d9X0esnoa3dFsV0FG35rAT0RIhYFlPq7MiP+DW89La0=
-github.com/xdg-go/scram v1.1.1 h1:VOMT+81stJgXW3CpHyqHN3AXDYIMsx56mEFrB37Mb/E=
+github.com/xdg/stringprep v1.0.0/go.mod h1:Jhud4/sHMO4oL310DaZAKk9ZaJ08SJfe+sJh0HrGL1Y=
-github.com/xdg-go/scram v1.1.1/go.mod h1:RaEWvsqvNKKvBPvcKeFjrG2cJqOkHTiyTpzz23ni57g=
+go.mongodb.org/mongo-driver v1.3.0 h1:ew6uUIeJOo+qdUUv7LxFCUhtWmVv7ZV/Xuy4FAUsw2E=
-github.com/xdg-go/stringprep v1.0.3 h1:kdwGpVNwPFtjs98xCGkHjQtGKh86rDcRZN17QEMCOIs=
+go.mongodb.org/mongo-driver v1.3.0/go.mod h1:MSWZXKOynuguX+JSvwP8i+58jYCXxbia8HS3gZBapIE=
-github.com/xdg-go/stringprep v1.0.3/go.mod h1:W3f5j4i+9rC0kuIEJL0ky1VpHXQU3ocBgklLGvcBnW8=
+golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d h1:splanxYIlg+5LfHAM6xpdFEAYOk8iySO56hMFq6uLyA=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d/go.mod h1:rHwXgn7JulP+udvsHwJoVG1YGAP6VLg4y9I5dyZdqmA=
+golang.org/x/crypto v0.0.0-20190422162423-af44ce270edf/go.mod h1:WFFai1msRO1wXaEeE5yQxYXgSfI8pQAWXbQop6sCtWE=
-go.mongodb.org/mongo-driver v1.11.6 h1:XM7G6PjiGAO5betLF13BIa5TlLUUE3uJ/2Ox3Lz1K+o=
+golang.org/x/crypto v0.0.0-20190530122614-20be4c3c3ed5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-go.mongodb.org/mongo-driver v1.11.6/go.mod h1:G9TgswdsWjX4tmDA5zfs2+6AEPpYJwqblyjsfuh8oXY=
+golang.org/x/crypto v0.0.0-20200221231518-2aa609cf4a9d h1:1ZiEyfaQIg3Qh0EoqpwAakHVhecoE5wlSg5GjnafJGw=
-golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d h1:sK3txAijHtOK88l68nt020reeT1ZdKLIYetKl95FzVY=
+golang.org/x/crypto v0.0.0-20200221231518-2aa609cf4a9d/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ=
+golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190412183630-56d357773e84/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58 h1:8gQV6CLnAEikrhgkHFbMAEhagSSnXWGV915qUMm9mrU=
-golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e h1:vcxGaoTs7kV8m5Np9uUNQin4BrLOthgV7252N8V+FwY=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/sys v0.0.0-20190403152447-81d4e9dc473e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190419153524-e8e3143a4f4a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190531175056-4c3a928424d2/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/tools v0.0.0-20190329151228-23e29df326fe/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190416151739-9c9e1878f421/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190420181800-aa740d480789/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190531172133-b3315ee88b7d/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

mongox-testing/database/ephemeral.go

@@ -1,55 +0,0 @@
-package database
-
-import (
-	"context"
-	"os"
-
-	"go.mongodb.org/mongo-driver/bson/primitive"
-	"go.mongodb.org/mongo-driver/mongo"
-	"go.mongodb.org/mongo-driver/mongo/options"
-
-	"github.com/mainnika/mongox-go-driver/v2/mongox"
-	"github.com/mainnika/mongox-go-driver/v2/mongox/database"
-)
-
-// defaultURI is a mongodb uri that is being used by tests
-var defaultURI = "mongodb://localhost"
-
-// EphemeralDatabase is a temporary database connection that will be destroyed after close
-type EphemeralDatabase struct {
-	mongox.Database
-}
-
-func init() {
-	envURI := os.Getenv("MONGODB_URI")
-	if envURI != "" {
-		defaultURI = envURI
-	}
-}
-
-// NewEphemeral creates new mongo connection
-func NewEphemeral(URI string) (db *EphemeralDatabase, err error) {
-	return NewEphemeralWithContext(context.Background(), URI)
-}
-
-func NewEphemeralWithContext(ctx context.Context, URI string) (db *EphemeralDatabase, err error) {
-	if URI == "" {
-		URI = defaultURI
-	}
-
-	name := primitive.NewObjectID().Hex()
-	opts := options.Client().ApplyURI(URI)
-	client, err := mongo.Connect(ctx, opts)
-	if err != nil {
-		return nil, err
-	}
-
-	db = &EphemeralDatabase{Database: database.NewDatabase(ctx, client, name)}
-
-	return db, nil
-}
-
-// Close the connection and drop database
-func (e *EphemeralDatabase) Close() (err error) {
-	return e.Client().Database(e.Name()).Drop(e.Context())
-}

mongox/base/docbased/id.go

@@ -1,44 +0,0 @@
-package docbased
-
-import (
-	"github.com/modern-go/reflect2"
-	"go.mongodb.org/mongo-driver/bson/primitive"
-
-	"github.com/mainnika/mongox-go-driver/v2/mongox"
-)
-
-var _ mongox.DocBased = (*Primary)(nil)
-
-// Primary is a structure with object as an _id field
-type Primary struct {
-	ID primitive.D `bson:"_id" json:"_id"`
-}
-
-// GetID returns an _id
-func (p *Primary) GetID() (id primitive.D) {
-	return p.ID
-}
-
-// SetID sets an _id
-func (p *Primary) SetID(id primitive.D) {
-	p.ID = id
-}
-
-// New creates a new Primary structure with a defined _id
-func New(e primitive.E, ee ...primitive.E) Primary {
-	id := primitive.D{e}
-	if len(ee) > 0 {
-		id = append(id, ee...)
-	}
-
-	return Primary{ID: id}
-}
-
-func GetID(source mongox.DocBased) (id primitive.D, err error) {
-	id = source.GetID()
-	if !reflect2.IsNil(id) {
-		return id, nil
-	}
-
-	return nil, mongox.ErrUninitializedBase
-}

mongox/base/docbased/id_test.go

@@ -1,76 +0,0 @@
-package docbased_test
-
-import (
-	"encoding/json"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"go.mongodb.org/mongo-driver/bson/primitive"
-
-	"github.com/mainnika/mongox-go-driver/v2/mongox-testing/database"
-	"github.com/mainnika/mongox-go-driver/v2/mongox/base/docbased"
-)
-
-func Test_GetID(t *testing.T) {
-	type DocWithObject struct {
-		docbased.Primary `bson:",inline" json:",inline" collection:"1"`
-	}
-
-	doc := &DocWithObject{Primary: docbased.New(primitive.E{"1", "one"}, primitive.E{"2", "two"})}
-
-	assert.Equal(t, primitive.D{{"1", "one"}, {"2", "two"}}, doc.GetID())
-}
-
-func Test_SetID(t *testing.T) {
-	type DocWithObject struct {
-		docbased.Primary `bson:",inline" json:",inline" collection:"1"`
-	}
-
-	doc := &DocWithObject{Primary: docbased.New(primitive.E{"1", "one"}, primitive.E{"2", "two"})}
-
-	doc.SetID(primitive.D{{"3", "three"}, {"4", "you"}})
-
-	assert.Equal(t, primitive.D{{"3", "three"}, {"4", "you"}}, doc.Primary.ID)
-	assert.Equal(t, primitive.D{{"3", "three"}, {"4", "you"}}, doc.GetID())
-}
-
-func Test_SaveLoad(t *testing.T) {
-	type DocWithObjectID struct {
-		docbased.Primary `bson:",inline" json:",inline" collection:"1"`
-	}
-
-	db, err := database.NewEphemeral("")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	defer func() { _ = db.Close() }()
-
-	doc1 := &DocWithObjectID{Primary: docbased.New(primitive.E{"1", "one"}, primitive.E{"2", "two"})}
-	doc2 := &DocWithObjectID{}
-
-	err = db.SaveOne(doc1)
-	assert.NoError(t, err)
-
-	err = db.LoadOne(doc2)
-	assert.NoError(t, err)
-
-	assert.Equal(t, doc1, doc2)
-
-	bytes1, _ := json.Marshal(doc1)
-	bytes2, _ := json.Marshal(doc2)
-
-	assert.Equal(t, bytes1, bytes2)
-}
-
-func Test_Marshal(t *testing.T) {
-	type DocWithObjectID struct {
-		docbased.Primary `bson:",inline" json:",inline" collection:"1"`
-	}
-
-	doc := &DocWithObjectID{Primary: docbased.New(primitive.E{"1", "one"}, primitive.E{"2", "two"})}
-
-	bytes, err := json.Marshal(doc)
-	assert.NoError(t, err)
-	assert.Equal(t, `{"_id":[{"Key":"1","Value":"one"},{"Key":"2","Value":"two"}]}`, string(bytes))
-}

mongox/base/getid.go

@@ -1,27 +1,56 @@
 package base
 
 import (
-	"fmt"
+	"go.mongodb.org/mongo-driver/bson/primitive"
-	"github.com/mainnika/mongox-go-driver/v2/mongox/base/docbased"
-	"github.com/mainnika/mongox-go-driver/v2/mongox/base/ifacebased"
-	"github.com/mainnika/mongox-go-driver/v2/mongox/base/oidbased"
-	"github.com/mainnika/mongox-go-driver/v2/mongox/base/stringbased"
 
 	"github.com/mainnika/mongox-go-driver/v2/mongox"
+	"github.com/mainnika/mongox-go-driver/v2/mongox/errors"
 )
 
 // GetID returns source document id
-func GetID(source interface{}) (id interface{}, err error) {
+func GetID(source interface{}) (id interface{}) {
+
 	switch doc := source.(type) {
-	case mongox.OIDBased:
+	case mongox.BaseObjectID:
-		return oidbased.GetID(doc)
+		return getObjectIDOrGenerate(doc)
-	case mongox.StringBased:
+	case mongox.BaseString:
-		return stringbased.GetID(doc)
+		return getStringIDOrPanic(doc)
-	case mongox.DocBased:
+	case mongox.BaseObject:
-		return docbased.GetID(doc)
+		return getObjectOrPanic(doc)
-	case mongox.InterfaceBased:
-		return ifacebased.GetID(doc)
 	default:
-		return nil, fmt.Errorf("%w: unknown base type", mongox.ErrMalformedBase)
+		panic(errors.Malformedf("source contains malformed document, %v", source))
 	}
 }
+
+func getObjectIDOrGenerate(source mongox.BaseObjectID) (id primitive.ObjectID) {
+
+	id = source.GetID()
+	if id != primitive.NilObjectID {
+		return id
+	}
+
+	id = primitive.NewObjectID()
+	source.SetID(id)
+
+	return
+}
+
+func getStringIDOrPanic(source mongox.BaseString) (id string) {
+
+	id = source.GetID()
+	if id != "" {
+		return id
+	}
+
+	panic(errors.Malformedf("victim contains malformed document, %v", source))
+}
+
+func getObjectOrPanic(source mongox.BaseObject) (id primitive.D) {
+
+	id = source.GetID()
+	if id != nil {
+		return id
+	}
+
+	panic(errors.Malformedf("victim contains malformed document, %v", source))
+}

mongox/base/getid_test.go

@@ -1,53 +0,0 @@
-package base_test
-
-import (
-	"github.com/mainnika/mongox-go-driver/v2/mongox/base/docbased"
-	"github.com/stretchr/testify/require"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"go.mongodb.org/mongo-driver/bson/primitive"
-
-	"github.com/mainnika/mongox-go-driver/v2/mongox/base"
-	"github.com/mainnika/mongox-go-driver/v2/mongox/base/oidbased"
-	"github.com/mainnika/mongox-go-driver/v2/mongox/base/stringbased"
-)
-
-type DocWithCustomInterface struct {
-	ID int `bson:"_id" json:"_id" collection:"4"`
-}
-
-func (d *DocWithCustomInterface) GetID() interface{} {
-	return d.ID
-}
-
-func (d *DocWithCustomInterface) SetID(interface{}) {
-	panic("not implemented")
-}
-
-func TestGetID(t *testing.T) {
-
-	type DocWithObjectID struct {
-		oidbased.Primary `bson:",inline" json:",inline" collection:"1"`
-	}
-	id, err := base.GetID(&DocWithObjectID{Primary: oidbased.Primary{ID: [12]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2}}})
-	require.NoError(t, err)
-	assert.Equal(t, primitive.ObjectID([12]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2}), id)
-
-	type DocWithObject struct {
-		docbased.Primary `bson:",inline" json:",inline" collection:"2"`
-	}
-	id, err = base.GetID(&DocWithObject{Primary: docbased.Primary{ID: primitive.D{{"1", "2"}}}})
-	require.NoError(t, err)
-	assert.Equal(t, primitive.D{{"1", "2"}}, id)
-
-	type DocWithString struct {
-		stringbased.Primary `bson:",inline" json:",inline" collection:"3"`
-	}
-	id, err = base.GetID(&DocWithString{Primary: stringbased.Primary{ID: "foobar"}})
-	assert.Equal(t, "foobar", id)
-
-	id, err = base.GetID(&DocWithCustomInterface{ID: 420})
-	assert.NoError(t, err)
-	assert.Equal(t, 420, id)
-}

mongox/base/getprotection.go

@@ -0,0 +1,33 @@
+package base
+
+import (
+	"reflect"
+)
+
+// GetProtection function finds protection field in the source document otherwise returns nil
+func GetProtection(source interface{}) *Protection {
+
+	v := reflect.ValueOf(source)
+	if v.Kind() != reflect.Ptr || v.IsNil() {
+		return nil
+	}
+
+	el := v.Elem()
+	numField := el.NumField()
+
+	for i := 0; i < numField; i++ {
+		field := el.Field(i)
+
+		switch field.Interface().(type) {
+		case *Protection:
+			return field.Interface().(*Protection)
+		case Protection:
+			ptr := field.Addr()
+			return ptr.Interface().(*Protection)
+		default:
+			continue
+		}
+	}
+
+	return nil
+}

mongox/base/ifacebased/id.go

@@ -1,16 +0,0 @@
-package ifacebased
-
-import (
-	"github.com/mainnika/mongox-go-driver/v2/mongox"
-	"github.com/modern-go/reflect2"
-)
-
-// GetID returns an _id from the source document
-func GetID(source mongox.InterfaceBased) (id interface{}, err error) {
-	id = source.GetID()
-	if !reflect2.IsNil(id) {
-		return id, nil
-	}
-
-	return nil, mongox.ErrUninitializedBase
-}

mongox/base/object.go

@@ -0,0 +1,24 @@
+package base
+
+import (
+	"go.mongodb.org/mongo-driver/bson/primitive"
+
+	"github.com/mainnika/mongox-go-driver/v2/mongox"
+)
+
+var _ mongox.BaseObject = &Object{}
+
+// Object is a structure with object as an _id field
+type Object struct {
+	ID primitive.D `bson:"_id,omitempty" json:"_id,omitempty"`
+}
+
+// GetID returns an _id
+func (db *Object) GetID() primitive.D {
+	return db.ID
+}
+
+// SetID sets an _id
+func (db *Object) SetID(id primitive.D) {
+	db.ID = id
+}

mongox/base/objectid.go

@@ -0,0 +1,24 @@
+package base
+
+import (
+	"go.mongodb.org/mongo-driver/bson/primitive"
+
+	"github.com/mainnika/mongox-go-driver/v2/mongox"
+)
+
+var _ mongox.BaseObjectID = &ObjectID{}
+
+// ObjectID is a structure with objectId as an _id field
+type ObjectID struct {
+	ID primitive.ObjectID `bson:"_id,omitempty" json:"_id,omitempty"`
+}
+
+// GetID returns an _id
+func (db *ObjectID) GetID() primitive.ObjectID {
+	return db.ID
+}
+
+// SetID sets an _id
+func (db *ObjectID) SetID(id primitive.ObjectID) {
+	db.ID = id
+}

mongox/base/oidbased/id.go

@@ -1,43 +0,0 @@
-package oidbased
-
-import (
-	"go.mongodb.org/mongo-driver/bson/primitive"
-
-	"github.com/mainnika/mongox-go-driver/v2/mongox"
-)
-
-var _ mongox.OIDBased = (*Primary)(nil)
-
-// Primary is a structure with objectId as the primary key
-type Primary struct {
-	ID primitive.ObjectID `bson:"_id" json:"_id"`
-}
-
-// GetID returns an _id
-func (p *Primary) GetID() (id primitive.ObjectID) {
-	return p.ID
-}
-
-// SetID sets an _id
-func (p *Primary) SetID(id primitive.ObjectID) {
-	p.ID = id
-}
-
-// Generate creates a new Primary structure with a new objectId
-func Generate() Primary {
-	return Primary{ID: primitive.NewObjectID()}
-}
-
-// New creates a new Primary structure with a defined objectId
-func New(id primitive.ObjectID) Primary {
-	return Primary{ID: id}
-}
-
-func GetID(source mongox.OIDBased) (id primitive.ObjectID, err error) {
-	id = source.GetID()
-	if id != primitive.NilObjectID {
-		return id, nil
-	}
-
-	return primitive.NilObjectID, mongox.ErrUninitializedBase
-}

mongox/base/oidbased/id_test.go

@@ -1,77 +0,0 @@
-package oidbased_test
-
-import (
-	"encoding/json"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"go.mongodb.org/mongo-driver/bson/primitive"
-
-	"github.com/mainnika/mongox-go-driver/v2/mongox-testing/database"
-	"github.com/mainnika/mongox-go-driver/v2/mongox/base/oidbased"
-)
-
-func Test_GetID(t *testing.T) {
-	type DocWithObjectID struct {
-		oidbased.Primary `bson:",inline" json:",inline" collection:"1"`
-	}
-
-	doc := &DocWithObjectID{Primary: oidbased.New([12]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2})}
-
-	assert.Equal(t, primitive.ObjectID([12]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2}), doc.Primary.ID)
-	assert.Equal(t, primitive.ObjectID([12]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2}), doc.GetID())
-}
-
-func Test_SetID(t *testing.T) {
-	type DocWithObjectID struct {
-		oidbased.Primary `bson:",inline" json:",inline" collection:"1"`
-	}
-
-	doc := &DocWithObjectID{Primary: oidbased.Generate()}
-	doc.SetID([12]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2})
-
-	assert.Equal(t, primitive.ObjectID([12]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2}), doc.Primary.ID)
-	assert.Equal(t, primitive.ObjectID([12]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2}), doc.GetID())
-}
-
-func Test_SaveLoad(t *testing.T) {
-	type DocWithObjectID struct {
-		oidbased.Primary `bson:",inline" json:",inline" collection:"1"`
-	}
-
-	db, err := database.NewEphemeral("")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	defer func() { _ = db.Close() }()
-
-	doc1 := &DocWithObjectID{Primary: oidbased.Generate()}
-	doc2 := &DocWithObjectID{Primary: oidbased.Generate()}
-
-	err = db.SaveOne(doc1)
-	assert.NoError(t, err)
-
-	err = db.LoadOne(doc2)
-	assert.NoError(t, err)
-
-	assert.Equal(t, doc1, doc2)
-
-	bytes1, _ := json.Marshal(doc1)
-	bytes2, _ := json.Marshal(doc2)
-
-	assert.Equal(t, bytes1, bytes2)
-}
-
-func Test_Marshal(t *testing.T) {
-	type DocWithObjectID struct {
-		oidbased.Primary `bson:",inline" json:",inline" collection:"1"`
-	}
-
-	id, _ := primitive.ObjectIDFromHex("feadbeeffeadbeeffeadbeef")
-	doc := &DocWithObjectID{Primary: oidbased.New(id)}
-
-	bytes, err := json.Marshal(doc)
-	assert.NoError(t, err)
-	assert.Equal(t, `{"_id":"feadbeeffeadbeeffeadbeef"}`, string(bytes))
-}

mongox/base/protection.go

@@ -0,0 +1,11 @@
+package base
+
+import (
+	"go.mongodb.org/mongo-driver/bson/primitive"
+)
+
+// Protection field stores unique document id and version
+type Protection struct {
+	X primitive.ObjectID `bson:"_x" json:"_x" index:",hashed"`
+	V int64              `bson:"_v" json:"_v"`
+}

mongox/base/protection/key.go

@@ -1,68 +0,0 @@
-package protection
-
-import (
-	"reflect"
-	"time"
-
-	"github.com/modern-go/reflect2"
-	"go.mongodb.org/mongo-driver/bson/primitive"
-)
-
-// Key field stores unique document id and version
-type Key struct {
-	X primitive.ObjectID `bson:"_x" json:"_x" index:",hashed"`
-	V int64              `bson:"_v" json:"_v"`
-}
-
-// Inject extends the doc with protection key values
-func (k *Key) Inject(doc primitive.M) {
-	if reflect2.IsNil(doc) {
-		return
-	}
-
-	if k.X.IsZero() {
-		doc["_x"] = primitive.M{"$exists": false}
-		doc["_v"] = primitive.M{"$exists": false}
-	} else {
-		doc["_x"] = k.X
-		doc["_v"] = k.V
-	}
-}
-
-// Restate creates a new protection key
-func (k *Key) Restate() {
-	k.X = primitive.NewObjectID()
-	k.V = time.Now().Unix()
-}
-
-// Get finds protection field in the source document otherwise returns nil
-func Get(source interface{}) (key *Key) {
-	v := reflect.ValueOf(source)
-	if v.Kind() != reflect.Ptr || v.IsNil() {
-		return nil
-	}
-
-	el := v.Elem()
-	numField := el.NumField()
-
-	for i := 0; i < numField; i++ {
-		field := el.Field(i)
-		if !field.CanInterface() {
-			continue
-		}
-
-		switch field.Interface().(type) {
-		case *Key:
-			key = field.Interface().(*Key)
-		case Key:
-			ptr := field.Addr()
-			key = ptr.Interface().(*Key)
-		default:
-			continue
-		}
-
-		return key
-	}
-
-	return nil
-}

mongox/base/protection/key_test.go

@@ -1,3 +0,0 @@
-package protection_test
-
-// TODO:

mongox/base/reset.go

@@ -1,31 +1,27 @@
 package base
 
 import (
-	"fmt"
 	"reflect"
+
+	"github.com/mainnika/mongox-go-driver/v2/mongox"
 )
 
 // Reset function creates new zero object for the target pointer
-func Reset(target interface{}) (created bool) {
+func Reset(target interface{}) {
-	type resetter interface {
-		Reset()
-	}
 
-	resettable, canReset := target.(resetter)
+	resettable, canReset := target.(mongox.Resetter)
 	if canReset {
 		resettable.Reset()
-		return false
+		return
 	}
 
 	v := reflect.ValueOf(target)
 	if v.Kind() != reflect.Ptr {
-		panic(fmt.Errorf("reset target should be a pointer"))
+		panic("reset target should be a pointer")
 	}
 
 	t := v.Elem().Type()
 	zero := reflect.Zero(t)
 
 	v.Elem().Set(zero)
-
-	return true
 }

mongox/base/string.go

@@ -0,0 +1,22 @@
+package base
+
+import (
+	"github.com/mainnika/mongox-go-driver/v2/mongox"
+)
+
+var _ mongox.BaseString = &String{}
+
+// String is a structure with string as an _id field
+type String struct {
+	ID string `bson:"_id,omitempty" json:"_id,omitempty"`
+}
+
+// GetID returns an _id
+func (db *String) GetID() string {
+	return db.ID
+}
+
+// SetID sets an _id
+func (db *String) SetID(id string) {
+	db.ID = id
+}

mongox/base/stringbased/id.go

@@ -1,36 +0,0 @@
-package stringbased
-
-import (
-	"github.com/mainnika/mongox-go-driver/v2/mongox"
-)
-
-var _ mongox.StringBased = (*Primary)(nil)
-
-// Primary is a structure with string as an _id field
-type Primary struct {
-	ID string `bson:"_id" json:"_id"`
-}
-
-// GetID returns an _id
-func (p *Primary) GetID() (id string) {
-	return p.ID
-}
-
-// SetID sets an _id
-func (p *Primary) SetID(id string) {
-	p.ID = id
-}
-
-// New creates a new Primary structure with a defined _id
-func New(id string) Primary {
-	return Primary{ID: id}
-}
-
-func GetID(source mongox.StringBased) (id string, err error) {
-	id = source.GetID()
-	if id != "" {
-		return id, nil
-	}
-
-	return "", mongox.ErrUninitializedBase
-}

mongox/base/stringbased/id_test.go

@@ -1,75 +0,0 @@
-package stringbased_test
-
-import (
-	"encoding/json"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/mainnika/mongox-go-driver/v2/mongox-testing/database"
-	"github.com/mainnika/mongox-go-driver/v2/mongox/base/stringbased"
-)
-
-func Test_GetID(t *testing.T) {
-	type DocWithString struct {
-		stringbased.Primary `bson:",inline" json:",inline" collection:"1"`
-	}
-
-	doc := &DocWithString{Primary: stringbased.New("foobar")}
-
-	assert.Equal(t, "foobar", doc.GetID())
-}
-
-func Test_SetID(t *testing.T) {
-	type DocWithString struct {
-		stringbased.Primary `bson:",inline" json:",inline" collection:"1"`
-	}
-
-	doc := &DocWithString{Primary: stringbased.New("foobar")}
-
-	doc.SetID("rockrockrock")
-
-	assert.Equal(t, "rockrockrock", doc.Primary.ID)
-	assert.Equal(t, "rockrockrock", doc.GetID())
-}
-
-func Test_SaveLoad(t *testing.T) {
-	type DocWithObjectID struct {
-		stringbased.Primary `bson:",inline" json:",inline" collection:"1"`
-	}
-
-	db, err := database.NewEphemeral("")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	defer func() { _ = db.Close() }()
-
-	doc1 := &DocWithObjectID{Primary: stringbased.New("foobar")}
-	doc2 := &DocWithObjectID{}
-
-	err = db.SaveOne(doc1)
-	assert.NoError(t, err)
-
-	err = db.LoadOne(doc2)
-	assert.NoError(t, err)
-
-	assert.Equal(t, doc1, doc2)
-
-	bytes1, _ := json.Marshal(doc1)
-	bytes2, _ := json.Marshal(doc2)
-
-	assert.Equal(t, bytes1, bytes2)
-}
-
-func Test_Marshal(t *testing.T) {
-	type DocWithObjectID struct {
-		stringbased.Primary `bson:",inline" json:",inline" collection:"1"`
-	}
-
-	doc := &DocWithObjectID{Primary: stringbased.New("foobar")}
-
-	bytes, err := json.Marshal(doc)
-	assert.NoError(t, err)
-	assert.Equal(t, `{"_id":"foobar"}`, string(bytes))
-}

mongox/common/common.go

@@ -1,53 +1,40 @@
-package database
+package common
 
 import (
-	"fmt"
 	"reflect"
 	"strconv"
 	"strings"
 
 	"go.mongodb.org/mongo-driver/bson/primitive"
+	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
 
 	"github.com/mainnika/mongox-go-driver/v2/mongox"
+	"github.com/mainnika/mongox-go-driver/v2/mongox/errors"
 	"github.com/mainnika/mongox-go-driver/v2/mongox/query"
 )
 
-func (d *Database) createCursor(target interface{}, composed *query.Query) (cursor *mongox.Cursor, err error) {
+func createSimpleLoad(db mongox.Database, target interface{}, composed *query.Query) (cursor *mongo.Cursor, err error) {
-	_, hasPreloader := composed.Preloader()
-	if hasPreloader {
-		return d.createAggregateCursor(target, composed)
-	}
-
-	return d.createSimpleCursor(target, composed)
-}
-
-func (d *Database) createSimpleCursor(target interface{}, composed *query.Query) (cursor *mongox.Cursor, err error) {
-	collection, err := d.GetCollectionOf(target)
-	if err != nil {
-		return nil, err
-	}
 
+	collection := db.GetCollectionOf(target)
 	opts := options.Find()
+
 	opts.Sort = composed.Sorter()
 	opts.Limit = composed.Limiter()
 	opts.Skip = composed.Skipper()
 
-	ctx := d.Context()
+	return collection.Find(db.Context(), composed.M(), opts)
-	m := composed.M()
-
-	return collection.Find(ctx, m, opts)
 }
 
-func (d *Database) createAggregateCursor(target interface{}, composed *query.Query) (cursor *mongox.Cursor, err error) {
+func createAggregateLoad(db mongox.Database, target interface{}, composed *query.Query) (cursor *mongo.Cursor, err error) {
-	collection, err := d.GetCollectionOf(target)
+
-	if err != nil {
+	collection := db.GetCollectionOf(target)
-		return nil, err
+	opts := options.Aggregate()
-	}
 
 	pipeline := primitive.A{}
+
 	if !composed.Empty() {
-		pipeline = append(pipeline, primitive.M{"$match": composed.M()})
+		pipeline = append(pipeline, primitive.M{"$match": primitive.M{"$expr": composed.M()}})
 	}
 	if composed.Sorter() != nil {
 		pipeline = append(pipeline, primitive.M{"$sort": composed.Sorter()})
@@ -59,15 +46,13 @@ func (d *Database) createAggregateCursor(target interface{}, composed *query.Que
 		pipeline = append(pipeline, primitive.M{"$limit": *composed.Limiter()})
 	}
 
-	el := reflect.ValueOf(target)
+	el := reflect.ValueOf(target).Elem()
 	elType := el.Type()
-	if elType.Kind() == reflect.Ptr {
-		elType = elType.Elem()
-	}
-
 	numField := elType.NumField()
-	preloads, _ := composed.Preloader()
+	_, preloads := composed.Preloader()
+
 	for i := 0; i < numField; i++ {
+
 		field := elType.Field(i)
 		tag := field.Tag
 
@@ -75,9 +60,9 @@ func (d *Database) createAggregateCursor(target interface{}, composed *query.Que
 		if !ok {
 			continue
 		}
-		jsonTag, _ := tag.Lookup("json")
+		jsonTag, ok := tag.Lookup("json")
 		if jsonTag == "-" {
-			return nil, fmt.Errorf("%w: private field is not preloadable", mongox.ErrMalformedBase)
+			return nil, errors.Malformedf("preload private field is impossible")
 		}
 
 		jsonData := strings.SplitN(jsonTag, ",", 2)
@@ -91,16 +76,17 @@ func (d *Database) createAggregateCursor(target interface{}, composed *query.Que
 			continue
 		}
 		if len(preloadData) == 1 {
-			return nil, fmt.Errorf("%w: foreign field is not specified", mongox.ErrMalformedBase)
+			panic("there is no foreign field")
+		}
+
+		localField := strings.TrimSpace(preloadData[0])
+		if len(localField) == 0 {
+			localField = "_id"
 		}
 
 		foreignField := strings.TrimSpace(preloadData[1])
 		if len(foreignField) == 0 {
-			return nil, fmt.Errorf("%w: foreign field is empty", mongox.ErrMalformedBase)
+			panic("there is no foreign field")
-		}
-		localField := strings.TrimSpace(preloadData[0])
-		if len(localField) == 0 {
-			localField = "_id"
 		}
 
 		preloadLimiter := 100
@@ -117,8 +103,6 @@ func (d *Database) createAggregateCursor(target interface{}, composed *query.Que
 			intLimit, err = strconv.Atoi(stringLimit)
 			if err == nil {
 				preloadLimiter = intLimit
-			} else {
-				return nil, fmt.Errorf("%w: preload limit should be an integer", mongox.ErrMalformedBase)
 			}
 		}
 
@@ -127,24 +111,17 @@ func (d *Database) createAggregateCursor(target interface{}, composed *query.Que
 				continue
 			}
 
-			field := elType.Field(i)
+			isSlice := el.Field(i).Kind() == reflect.Slice
-			fieldType := field.Type
 
-			isSlice := fieldType.Kind() == reflect.Slice
+			typ := el.Field(i).Type()
-			if isSlice {
+			if typ.Kind() == reflect.Slice {
-				fieldType = fieldType.Elem()
+				typ = typ.Elem()
-			}
+			}
-
+			if typ.Kind() != reflect.Ptr {
-			isPtr := fieldType.Kind() != reflect.Ptr
+				panic("preload field should have ptr type")
-			if isPtr {
-				return nil, fmt.Errorf("%w: preload field should have ptr type", mongox.ErrMalformedBase)
-			}
-
-			lookupCollection, err := d.GetCollectionOf(reflect.Zero(fieldType).Interface())
-			if err != nil {
-				return nil, err
 			}
 
+			lookupCollection := db.GetCollectionOf(reflect.Zero(typ).Interface())
 			lookupVars := primitive.M{"selector": "$" + localField}
 			lookupPipeline := primitive.A{
 				primitive.M{"$match": primitive.M{"$expr": primitive.M{"$eq": primitive.A{"$" + foreignField, "$$selector"}}}},
@@ -181,8 +158,5 @@ func (d *Database) createAggregateCursor(target interface{}, composed *query.Que
 		}
 	}
 
-	ctx := d.Context()
+	return collection.Aggregate(db.Context(), pipeline, opts)
-	opts := options.Aggregate()
-
-	return collection.Aggregate(ctx, pipeline, opts)
 }

mongox/common/count.go

@@ -0,0 +1,32 @@
+package common
+
+import (
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+
+	"github.com/mainnika/mongox-go-driver/v2/mongox"
+	"github.com/mainnika/mongox-go-driver/v2/mongox/errors"
+	"github.com/mainnika/mongox-go-driver/v2/mongox/query"
+)
+
+// Count function counts documents in the database by query
+// target is used only to get collection by tag so it'd be better to use nil ptr here
+func Count(db mongox.Database, target interface{}, filters ...interface{}) (int64, error) {
+
+	collection := db.GetCollectionOf(target)
+	opts := options.Count()
+	composed := query.Compose(filters...)
+
+	opts.Limit = composed.Limiter()
+	opts.Skip = composed.Skipper()
+
+	result, err := collection.CountDocuments(db.Context(), composed.M(), opts)
+	if err == mongo.ErrNoDocuments {
+		return 0, errors.NotFoundErrorf("%s", err)
+	}
+	if err != nil {
+		return 0, errors.InternalErrorf("can't decode desult: %s", err)
+	}
+
+	return result, nil
+}

mongox/common/deletearray.go

@@ -0,0 +1,60 @@
+package common
+
+import (
+	"reflect"
+
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"go.mongodb.org/mongo-driver/mongo/options"
+
+	"github.com/mainnika/mongox-go-driver/v2/mongox"
+	"github.com/mainnika/mongox-go-driver/v2/mongox/base"
+	"github.com/mainnika/mongox-go-driver/v2/mongox/errors"
+)
+
+// DeleteArray removes documents list from a database by their ids
+func DeleteArray(db mongox.Database, target interface{}) error {
+
+	targetV := reflect.ValueOf(target)
+	targetT := targetV.Type()
+
+	targetK := targetV.Kind()
+	if targetK != reflect.Ptr {
+		panic(errors.Malformedf("target is not a ptr"))
+	}
+
+	targetSliceV := targetV.Elem()
+	targetSliceT := targetT.Elem()
+	if targetSliceT.Kind() != reflect.Slice {
+		panic(errors.Malformedf("target should be a ptr to a slice"))
+	}
+
+	targetSliceElemT := targetSliceT.Elem()
+	if targetSliceElemT.Kind() != reflect.Ptr {
+		panic(errors.Malformedf("target slice should contain ptrs"))
+	}
+
+	zeroElem := reflect.Zero(targetSliceElemT)
+	targetLen := targetSliceV.Len()
+	collection := db.GetCollectionOf(zeroElem.Interface())
+	opts := options.Delete()
+	ids := primitive.A{}
+
+	for i := 0; i < targetLen; i++ {
+		elem := targetSliceV.Index(i)
+		ids = append(ids, base.GetID(elem.Interface()))
+	}
+
+	if len(ids) == 0 {
+		return errors.Malformedf("can't delete zero elements")
+	}
+
+	result, err := collection.DeleteMany(db.Context(), primitive.M{"_id": primitive.M{"$in": ids}}, opts)
+	if err != nil {
+		return errors.NotFoundErrorf("can't create find and delete result: %s", err)
+	}
+	if result.DeletedCount != int64(targetLen) {
+		return errors.InternalErrorf("can't verify delete result: removed count mismatch %d != %d", result.DeletedCount, targetLen)
+	}
+
+	return nil
+}

mongox/common/deleteone.go

@@ -0,0 +1,50 @@
+package common
+
+import (
+	"time"
+
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+
+	"github.com/mainnika/mongox-go-driver/v2/mongox"
+	"github.com/mainnika/mongox-go-driver/v2/mongox/base"
+	"github.com/mainnika/mongox-go-driver/v2/mongox/errors"
+	"github.com/mainnika/mongox-go-driver/v2/mongox/query"
+)
+
+// DeleteOne removes a document from a database and then returns it into target
+func DeleteOne(db mongox.Database, target interface{}, filters ...interface{}) error {
+
+	collection := db.GetCollectionOf(target)
+	opts := &options.FindOneAndDeleteOptions{}
+	composed := query.Compose(filters...)
+	protected := base.GetProtection(target)
+
+	opts.Sort = composed.Sorter()
+
+	if target != nil {
+		composed.And(primitive.M{"_id": base.GetID(target)})
+	}
+
+	if protected != nil {
+		query.Push(composed, protected)
+		protected.X = primitive.NewObjectID()
+		protected.V = time.Now().Unix()
+	}
+
+	result := collection.FindOneAndDelete(db.Context(), composed.M(), opts)
+	if result.Err() != nil {
+		return errors.InternalErrorf("can't create find one and delete result: %s", result.Err())
+	}
+
+	err := result.Decode(target)
+	if err == mongo.ErrNoDocuments {
+		return errors.NotFoundErrorf("%s", err)
+	}
+	if err != nil {
+		return errors.InternalErrorf("can't decode result: %s", err)
+	}
+
+	return nil
+}

mongox/common/loadarray.go

@@ -0,0 +1,78 @@
+package common
+
+import (
+	"reflect"
+
+	"go.mongodb.org/mongo-driver/mongo"
+
+	"github.com/mainnika/mongox-go-driver/v2/mongox"
+	"github.com/mainnika/mongox-go-driver/v2/mongox/base"
+	"github.com/mainnika/mongox-go-driver/v2/mongox/errors"
+	"github.com/mainnika/mongox-go-driver/v2/mongox/query"
+)
+
+// LoadArray loads an array of documents from the database by query
+func LoadArray(db mongox.Database, target interface{}, filters ...interface{}) error {
+
+	targetV := reflect.ValueOf(target)
+	targetT := targetV.Type()
+
+	targetK := targetV.Kind()
+	if targetK != reflect.Ptr {
+		panic(errors.InternalErrorf("target is not a ptr"))
+	}
+
+	targetSliceV := targetV.Elem()
+	targetSliceT := targetT.Elem()
+	if targetSliceT.Kind() != reflect.Slice {
+		panic(errors.InternalErrorf("target should be a ptr to a slice"))
+	}
+
+	targetSliceElemT := targetSliceT.Elem()
+	if targetSliceElemT.Kind() != reflect.Ptr {
+		panic(errors.InternalErrorf("target slice should contain ptrs"))
+	}
+
+	composed := query.Compose(filters...)
+	zeroElem := reflect.Zero(targetSliceElemT)
+	hasPreloader, _ := composed.Preloader()
+
+	var result *mongo.Cursor
+	var err error
+
+	if hasPreloader {
+		result, err = createAggregateLoad(db, zeroElem.Interface(), composed)
+	} else {
+		result, err = createSimpleLoad(db, zeroElem.Interface(), composed)
+	}
+	if err != nil {
+		return errors.InternalErrorf("can't create find result: %s", err)
+	}
+
+	defer result.Close(db.Context())
+	var i int
+
+	for i = 0; result.Next(db.Context()); {
+		if targetSliceV.Len() == i {
+			elem := reflect.New(targetSliceElemT.Elem())
+			if err = result.Decode(elem.Interface()); err == nil {
+				targetSliceV = reflect.Append(targetSliceV, elem)
+			} else {
+				continue
+			}
+		} else {
+			elem := targetSliceV.Index(i).Interface()
+			base.Reset(elem)
+			if err = result.Decode(elem); err != nil {
+				continue
+			}
+		}
+
+		i++
+	}
+
+	targetSliceV = targetSliceV.Slice(0, i)
+	targetV.Elem().Set(targetSliceV)
+
+	return nil
+}

mongox/common/loadone.go

@@ -0,0 +1,38 @@
+package common
+
+import (
+	"go.mongodb.org/mongo-driver/mongo"
+
+	"github.com/mainnika/mongox-go-driver/v2/mongox"
+	"github.com/mainnika/mongox-go-driver/v2/mongox/base"
+	"github.com/mainnika/mongox-go-driver/v2/mongox/errors"
+	"github.com/mainnika/mongox-go-driver/v2/mongox/query"
+)
+
+// LoadOne function loads a first single target document by a query
+func LoadOne(db mongox.Database, target interface{}, filters ...interface{}) error {
+
+	composed := query.Compose(append(filters, query.Limit(1))...)
+	hasPreloader, _ := composed.Preloader()
+
+	var result *mongo.Cursor
+	var err error
+
+	if hasPreloader {
+		result, err = createAggregateLoad(db, target, composed)
+	} else {
+		result, err = createSimpleLoad(db, target, composed)
+	}
+	if err != nil {
+		return errors.InternalErrorf("can't create find result: %s", err)
+	}
+
+	hasNext := result.Next(db.Context())
+	if !hasNext {
+		return errors.NotFoundErrorf("can't find result: %s", result.Err())
+	}
+
+	base.Reset(target)
+
+	return result.Decode(target)
+}

mongox/common/loadstream.go

@@ -0,0 +1,78 @@
+package common
+
+import (
+	"context"
+
+	"go.mongodb.org/mongo-driver/mongo"
+
+	"github.com/mainnika/mongox-go-driver/v2/mongox"
+	"github.com/mainnika/mongox-go-driver/v2/mongox/base"
+	"github.com/mainnika/mongox-go-driver/v2/mongox/errors"
+	"github.com/mainnika/mongox-go-driver/v2/mongox/query"
+)
+
+// StreamLoader is a controller for a database cursor
+type StreamLoader struct {
+	*mongo.Cursor
+	ctx    context.Context
+	target interface{}
+}
+
+// DecodeNext loads next documents to a target or returns an error
+func (l *StreamLoader) DecodeNext() error {
+
+	hasNext := l.Cursor.Next(l.ctx)
+
+	if !hasNext {
+		return errors.NotFoundErrorf("%s", mongo.ErrNoDocuments)
+	}
+
+	base.Reset(l.target)
+
+	err := l.Decode(l.target)
+	if err != nil {
+		return errors.InternalErrorf("can't decode desult: %s", err)
+	}
+
+	return nil
+}
+
+// Next loads next documents but doesn't perform decoding
+func (l *StreamLoader) Next() error {
+
+	hasNext := l.Cursor.Next(l.ctx)
+	if !hasNext {
+		return errors.NotFoundErrorf("%s", mongo.ErrNoDocuments)
+	}
+
+	return nil
+}
+
+// Close cursor
+func (l *StreamLoader) Close() error {
+
+	return l.Cursor.Close(l.ctx)
+}
+
+// LoadStream function loads documents one by one into a target channel
+func LoadStream(db mongox.Database, target interface{}, filters ...interface{}) (*StreamLoader, error) {
+
+	var cursor *mongo.Cursor
+	var err error
+
+	composed := query.Compose(filters...)
+	hasPreloader, _ := composed.Preloader()
+
+	if hasPreloader {
+		cursor, err = createAggregateLoad(db, target, composed)
+	} else {
+		cursor, err = createSimpleLoad(db, target, composed)
+	}
+	if err != nil {
+		return nil, errors.InternalErrorf("can't create find result: %s", err)
+	}
+
+	l := &StreamLoader{Cursor: cursor, ctx: db.Context(), target: target}
+
+	return l, nil
+}

mongox/common/saveone.go

@@ -0,0 +1,40 @@
+package common
+
+import (
+	"time"
+
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"go.mongodb.org/mongo-driver/mongo/options"
+
+	"github.com/mainnika/mongox-go-driver/v2/mongox"
+	"github.com/mainnika/mongox-go-driver/v2/mongox/base"
+	"github.com/mainnika/mongox-go-driver/v2/mongox/errors"
+	"github.com/mainnika/mongox-go-driver/v2/mongox/query"
+)
+
+// SaveOne saves a single source document to the database
+func SaveOne(db mongox.Database, source interface{}) error {
+
+	collection := db.GetCollectionOf(source)
+	opts := options.FindOneAndReplace()
+	id := base.GetID(source)
+	protected := base.GetProtection(source)
+	composed := query.Compose(bson.M{"_id": id})
+
+	opts.SetUpsert(true)
+	opts.SetReturnDocument(options.After)
+
+	if protected != nil {
+		query.Push(composed, protected)
+		protected.X = primitive.NewObjectID()
+		protected.V = time.Now().Unix()
+	}
+
+	result := collection.FindOneAndReplace(db.Context(), composed.M(), source, opts)
+	if result.Err() != nil {
+		return errors.NotFoundErrorf("%s", result.Err())
+	}
+
+	return result.Decode(source)
+}

mongox/database/context.go

@@ -1,23 +0,0 @@
-package database
-
-import (
-	"context"
-)
-
-type ctxDatabaseKey struct{}
-
-// GetFromContext function extracts the request data from context
-func GetFromContext(ctx context.Context) (q *Database, ok bool) {
-	q, ok = ctx.Value(ctxDatabaseKey{}).(*Database)
-	if !ok {
-		return nil, false
-	}
-
-	return q, true
-}
-
-// WithContext creates the new context with a database attached
-func WithContext(ctx context.Context, q *Database) (withQuery context.Context) {
-	db := NewDatabase(ctx, q.Client(), q.Name())
-	return context.WithValue(ctx, ctxDatabaseKey{}, db)
-}

mongox/database/count.go

@@ -1,37 +0,0 @@
-package database
-
-import (
-	"go.mongodb.org/mongo-driver/mongo/options"
-
-	"github.com/mainnika/mongox-go-driver/v2/mongox/query"
-)
-
-// Count function counts documents in the database by query
-// target is used only to get collection by tag so it'd be better to use nil ptr here
-func (d *Database) Count(target interface{}, filters ...interface{}) (result int64, err error) {
-	composed, err := query.Compose(filters...)
-	if err != nil {
-		return -1, err
-	}
-
-	collection, err := d.GetCollectionOf(target)
-	if err != nil {
-		return -1, err
-	}
-	ctx := query.WithContext(d.Context(), composed)
-
-	m := composed.M()
-
-	opts := options.Count()
-	opts.Limit = composed.Limiter()
-	opts.Skip = composed.Skipper()
-
-	defer func() { _ = composed.OnClose().Invoke(ctx, target) }()
-
-	result, err = collection.CountDocuments(ctx, m, opts)
-	if err != nil {
-		return -1, err
-	}
-
-	return result, nil
-}

mongox/database/database.go

@@ -4,68 +4,79 @@ import (
 	"context"
 	"reflect"
 
+	"go.mongodb.org/mongo-driver/mongo"
+
 	"github.com/mainnika/mongox-go-driver/v2/mongox"
+	"github.com/mainnika/mongox-go-driver/v2/mongox/errors"
 )
 
 // Database handler
 type Database struct {
-	client *mongox.Client
+	client *mongo.Client
-	name   string
+	dbname string
 	ctx    context.Context
 }
 
 // NewDatabase function creates new database instance with mongo client and empty context
-func NewDatabase(ctx context.Context, client *mongox.Client, name string) (db mongox.Database) {
+func NewDatabase(client *mongo.Client, dbname string) mongox.Database {
-	db = &Database{
+
-		client: client,
+	db := &Database{}
-		name:   name,
+	db.client = client
-		ctx:    ctx,
+	db.dbname = dbname
-	}
 
 	return db
 }
 
 // Client function returns a mongo client
-func (d *Database) Client() (client *mongox.Client) {
+func (d *Database) Client() mongox.MongoClient {
 	return d.client
 }
 
-// Name function returns a database name
+// Context function returns a context
-func (d *Database) Name() (name string) {
+func (d *Database) Context() context.Context {
-	return d.name
+	return d.ctx
 }
 
-// Context function returns a context
+// Name function returns a database name
-func (d *Database) Context() (ctx context.Context) {
+func (d *Database) Name() string {
-	ctx = d.ctx
+	return d.dbname
-	if ctx == nil {
+}
+
+// New function creates new database context with same client
+func (d *Database) New(ctx context.Context) mongox.Database {
+
+	if ctx != nil {
 		ctx = context.Background()
 	}
 
-	return ctx
+	return &Database{
+		client: d.client,
+		dbname: d.dbname,
+		ctx:    ctx,
+	}
 }
 
 // GetCollectionOf returns the collection object by the «collection» tag of the given document;
-//
+// the «collection» tag should exists, e.g.:
-//	 example:
 // type Foobar struct {
 //     base.ObjectID `bson:",inline" json:",inline" collection:"foobars"`
 // 	   ...
-func (d *Database) GetCollectionOf(document interface{}) (collection *mongox.Collection, err error) {
+// Will panic if there is no «collection» tag
+func (d *Database) GetCollectionOf(document interface{}) mongox.MongoCollection {
+
 	el := reflect.TypeOf(document).Elem()
 	numField := el.NumField()
-	databaseName := d.name
 
 	for i := 0; i < numField; i++ {
 		field := el.Field(i)
 		tag := field.Tag
-		collectionName, found := tag.Lookup("collection")
+		found, ok := tag.Lookup("collection")
-		if !found {
+		if !ok {
 			continue
 		}
 
-		return d.client.Database(databaseName).Collection(collectionName), nil
+		return d.client.Database(d.dbname).Collection(found)
 	}
 
-	return nil, mongox.ErrNoCollection
+	panic(errors.InternalErrorf("document %v does not have a collection tag", document))
 }

mongox/database/deletearray.go

@@ -1,77 +0,0 @@
-package database
-
-import (
-	"fmt"
-	"reflect"
-
-	"go.mongodb.org/mongo-driver/bson/primitive"
-	"go.mongodb.org/mongo-driver/mongo/options"
-
-	"github.com/mainnika/mongox-go-driver/v2/mongox/base"
-	"github.com/mainnika/mongox-go-driver/v2/mongox/query"
-)
-
-// DeleteArray removes documents list from a database by their ids
-func (d *Database) DeleteArray(target interface{}, filters ...interface{}) (err error) {
-	targetV := reflect.ValueOf(target)
-	targetT := targetV.Type()
-
-	targetK := targetV.Kind()
-	if targetK != reflect.Ptr {
-		panic(fmt.Errorf("target is not a ptr"))
-	}
-
-	targetSliceV := targetV.Elem()
-	targetSliceT := targetT.Elem()
-	if targetSliceT.Kind() != reflect.Slice {
-		panic(fmt.Errorf("target should be a ptr to a slice"))
-	}
-
-	targetSliceElemT := targetSliceT.Elem()
-	if targetSliceElemT.Kind() != reflect.Ptr {
-		panic(fmt.Errorf("target slice should contain ptrs"))
-	}
-
-	zeroElem := reflect.Zero(targetSliceElemT)
-	targetLen := targetSliceV.Len()
-
-	collection, err := d.GetCollectionOf(zeroElem.Interface())
-	if err != nil {
-		return err
-	}
-
-	composed, err := query.Compose(filters...)
-	if err != nil {
-		return err
-	}
-
-	if targetLen > 0 {
-		var ids primitive.A
-		for i := 0; i < targetLen; i++ {
-			elem := targetSliceV.Index(i)
-			elemID, err := base.GetID(elem.Interface())
-			if err != nil {
-				return err
-			}
-
-			ids = append(ids, elemID)
-		}
-		composed.And(primitive.M{"_id": primitive.M{"$in": ids}})
-	}
-
-	ctx := query.WithContext(d.Context(), composed)
-	m := composed.M()
-	opts := options.Delete()
-
-	defer func() { _ = composed.OnClose().Invoke(ctx, target) }()
-
-	result, err := collection.DeleteMany(ctx, m, opts)
-	if err != nil {
-		return fmt.Errorf("while deleting array: %w", err)
-	}
-	if result.DeletedCount != int64(targetLen) {
-		return fmt.Errorf("deleted count mismatch %d != %d", result.DeletedCount, targetLen)
-	}
-
-	return nil
-}

mongox/database/deleteone.go

@@ -1,66 +0,0 @@
-package database
-
-import (
-	"fmt"
-	"github.com/mainnika/mongox-go-driver/v2/mongox/base/protection"
-
-	"github.com/modern-go/reflect2"
-	"go.mongodb.org/mongo-driver/bson/primitive"
-	"go.mongodb.org/mongo-driver/mongo/options"
-
-	"github.com/mainnika/mongox-go-driver/v2/mongox/base"
-	"github.com/mainnika/mongox-go-driver/v2/mongox/query"
-)
-
-// DeleteOne removes a document from a database and then returns it into target
-func (d *Database) DeleteOne(target interface{}, filters ...interface{}) (err error) {
-	composed, err := query.Compose(filters...)
-	if err != nil {
-		return err
-	}
-
-	collection, err := d.GetCollectionOf(target)
-	if err != nil {
-		return err
-	}
-
-	if !reflect2.IsNil(target) {
-		targetID, err := base.GetID(target)
-		if err != nil {
-			return err
-		}
-
-		composed.And(primitive.M{"_id": targetID})
-	}
-
-	protected := protection.Get(target)
-	if protected != nil {
-		_, err := query.Push(composed, protected)
-		if err != nil {
-			return err
-		}
-
-		protected.Restate()
-	}
-
-	ctx := query.WithContext(d.Context(), composed)
-	m := composed.M()
-	opts := options.FindOneAndDelete()
-	opts.Sort = composed.Sorter()
-
-	defer func() { _ = composed.OnClose().Invoke(ctx, target) }()
-
-	result := collection.FindOneAndDelete(ctx, m, opts)
-	if result.Err() != nil {
-		return fmt.Errorf("can't create find one and delete result: %w", result.Err())
-	}
-
-	err = result.Decode(target)
-	if err != nil {
-		return fmt.Errorf("can't decode find one and delete result: %w", err)
-	}
-
-	_ = composed.OnDecode().Invoke(ctx, target)
-
-	return nil
-}

mongox/database/index.go

@@ -1,139 +0,0 @@
-package database
-
-import (
-	"bytes"
-	"fmt"
-	"reflect"
-	"strconv"
-	"strings"
-	"text/template"
-
-	"go.mongodb.org/mongo-driver/bson/primitive"
-	"go.mongodb.org/mongo-driver/mongo"
-	"go.mongodb.org/mongo-driver/mongo/options"
-)
-
-// IndexEnsure function ensures index in mongo collection of document
-//
-//	`index:""` -- https://docs.mongodb.com/manual/indexes/#create-an-index
-//	`index:"-"` -- (descending)
-//	`index:"-,+foo,+-bar"` -- https://docs.mongodb.com/manual/core/index-compound
-//	`index:"-,+foo,+-bar,unique"` -- https://docs.mongodb.com/manual/core/index-unique
-//	`index:"-,+foo,+-bar,unique,allowNull"` -- https://docs.mongodb.com/manual/core/index-partial
-//	`index:"-,unique,allowNull,expireAfter=86400"` -- https://docs.mongodb.com/manual/core/index-ttl
-//	`index:"-,unique,allowNull,expireAfter={{.Expire}}"` -- evaluate index as a golang template with `cfg` arguments
-func (d *Database) IndexEnsure(cfg interface{}, document interface{}) (err error) {
-	el := reflect.ValueOf(document).Elem().Type()
-	numField := el.NumField()
-	collection, err := d.GetCollectionOf(document)
-	if err != nil {
-		return err
-	}
-
-	for i := 0; i < numField; i++ {
-
-		field := el.Field(i)
-		tag := field.Tag
-
-		indexTag, ok := tag.Lookup("index")
-		if !ok {
-			continue
-		}
-		bsonTag, ok := tag.Lookup("bson")
-		if !ok {
-			return fmt.Errorf("bson tag is not defined for field:%v document:%v", field, document)
-		}
-
-		var tmpBuffer = &bytes.Buffer{}
-		var tpl *template.Template
-
-		tpl, err = template.New("").Parse(indexTag)
-		if err != nil {
-			panic(fmt.Errorf("invalid prop template %v, err:%w", indexTag, err))
-		}
-		err = tpl.Execute(tmpBuffer, cfg)
-		if err != nil {
-			panic(fmt.Errorf("failed to evaluate prop template %v, err:%w", indexTag, err))
-		}
-
-		indexString := tmpBuffer.String()
-		indexValues := strings.Split(indexString, ",")
-		bsonValues := strings.Split(bsonTag, ",")
-
-		var f = false
-		var t = true
-		var key = bsonValues[0]
-		var name = fmt.Sprintf("%s_%s_", indexString, key)
-
-		if len(key) == 0 {
-			panic(fmt.Errorf("cannot evaluate index key"))
-		}
-
-		opts := &options.IndexOptions{
-			Background: &f,
-			Unique:     &f,
-			Name:       &name,
-		}
-
-		index := primitive.D{{Key: key, Value: 1}}
-		if indexValues[0] == "-" {
-			index = primitive.D{{Key: key, Value: -1}}
-		}
-
-		for _, prop := range indexValues[1:] {
-			var left string
-			var right string
-
-			pair := strings.SplitN(prop, "=", 2)
-			left = pair[0]
-			if len(pair) > 1 {
-				right = pair[1]
-			}
-
-			switch {
-			case left == "unique":
-				opts.Unique = &t
-
-			case left == "allowNull":
-				expression, isMap := opts.PartialFilterExpression.(primitive.M)
-				if !isMap || expression == nil {
-					expression = primitive.M{}
-				}
-
-				expression[key] = primitive.M{"$exists": true}
-				opts.PartialFilterExpression = expression
-
-			case left == "expireAfter":
-				expireAfter, err := strconv.Atoi(right)
-				if err != nil || expireAfter < 1 {
-					panic(fmt.Errorf("invalid expireAfter value, err: %w", err))
-				}
-
-				expireAfterInt32 := int32(expireAfter)
-				opts.ExpireAfterSeconds = &expireAfterInt32
-
-			case len(left) > 0 && left[0] == '+':
-				compoundValue := left[1:]
-				if len(compoundValue) == 0 {
-					panic(fmt.Errorf("invalid compound value"))
-				}
-
-				if compoundValue[0] == '-' {
-					index = append(index, primitive.E{compoundValue[1:], -1})
-				} else {
-					index = append(index, primitive.E{compoundValue, 1})
-				}
-
-			default:
-				panic(fmt.Errorf("unsupported flag:%q in tag:%q of type:%s", prop, tag, el))
-			}
-		}
-
-		_, err = collection.Indexes().CreateOne(d.Context(), mongo.IndexModel{Keys: index, Options: opts})
-		if err != nil {
-			return
-		}
-	}
-
-	return
-}

mongox/database/index_test.go

@@ -1,160 +0,0 @@
-package database_test
-
-import (
-	"github.com/stretchr/testify/require"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/mainnika/mongox-go-driver/v2/mongox-testing/database"
-	"github.com/mainnika/mongox-go-driver/v2/mongox/base/oidbased"
-)
-
-func TestDatabase_Ensure(t *testing.T) {
-
-	db, err := database.NewEphemeral("")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer db.Close()
-
-	testvalues := []struct {
-		doc      interface{}
-		settings map[string]interface{}
-		index    map[string]interface{}
-	}{
-		{
-			doc: &struct {
-				oidbased.Primary `bson:",inline" json:",inline" collection:"1"`
-
-				Foobar int `bson:"foobar" json:"foobar" index:"-,unique,allowNull,expireAfter=86400"`
-				Foo    int `bson:"foo" json:"foo"`
-				Bar    int `bson:"bar" json:"bar"`
-			}{},
-			index: map[string]interface{}{
-				"background":         false,
-				"expireAfterSeconds": int32(86400),
-				"key": map[string]interface{}{
-					"foobar": int32(-1),
-				},
-				"name": "-,unique,allowNull,expireAfter=86400_foobar_",
-				"partialFilterExpression": map[string]interface{}{
-					"foobar": map[string]interface{}{"$exists": true},
-				},
-				"unique": true,
-			},
-		},
-		{
-			doc: &struct {
-				oidbased.Primary `bson:",inline" json:",inline" collection:"2"`
-
-				Foobar int `bson:"foobar" json:"foobar" index:",unique"`
-			}{},
-			index: map[string]interface{}{
-				"background": false,
-				"key": map[string]interface{}{
-					"foobar": int32(1),
-				},
-				"name":   ",unique_foobar_",
-				"unique": true,
-			},
-		},
-		{
-			doc: &struct {
-				oidbased.Primary `bson:",inline" json:",inline" collection:"3"`
-
-				Foobar int `bson:"foobar" json:"foobar" index:"-,+foo,+-bar,unique,allowNull"`
-				Foo    int `bson:"foo" json:"foo"`
-				Bar    int `bson:"bar" json:"bar"`
-			}{},
-			index: map[string]interface{}{
-				"background": false,
-				"key": map[string]interface{}{
-					"foobar": int32(-1),
-					"foo":    int32(1),
-					"bar":    int32(-1),
-				},
-				"name": "-,+foo,+-bar,unique,allowNull_foobar_",
-				"partialFilterExpression": map[string]interface{}{
-					"foobar": map[string]interface{}{"$exists": true},
-				},
-				"unique": true,
-			},
-		},
-		{
-			doc: &struct {
-				oidbased.Primary `bson:",inline" json:",inline" collection:"4"`
-
-				Foobar int `bson:"foobar" json:"foobar" index:""`
-				Foo    int `bson:"foo" json:"foo"`
-				Bar    int `bson:"bar" json:"bar"`
-			}{},
-			index: map[string]interface{}{
-				"background": false,
-				"key": map[string]interface{}{
-					"foobar": int32(1),
-				},
-				"name": "_foobar_",
-			},
-		},
-		{
-			doc: &struct {
-				oidbased.Primary `bson:",inline" json:",inline" collection:"5"`
-
-				Foobar int `bson:"foobar" json:"foobar" index:"-"`
-				Foo    int `bson:"foo" json:"foo"`
-				Bar    int `bson:"bar" json:"bar"`
-			}{},
-			index: map[string]interface{}{
-				"background": false,
-				"key": map[string]interface{}{
-					"foobar": int32(-1),
-				},
-				"name": "-_foobar_",
-			},
-		},
-		{
-			doc: &struct {
-				oidbased.Primary `bson:",inline" json:",inline" collection:"1"`
-
-				Foobar int `bson:"foobar" json:"foobar" index:"-,unique,allowNull,expireAfter={{.Expire}}"`
-				Foo    int `bson:"foo" json:"foo"`
-				Bar    int `bson:"bar" json:"bar"`
-			}{},
-			settings: map[string]interface{}{
-				"Expire": 86400,
-			},
-			index: map[string]interface{}{
-				"background":         false,
-				"expireAfterSeconds": int32(86400),
-				"key": map[string]interface{}{
-					"foobar": int32(-1),
-				},
-				"name": "-,unique,allowNull,expireAfter=86400_foobar_",
-				"partialFilterExpression": map[string]interface{}{
-					"foobar": map[string]interface{}{"$exists": true},
-				},
-				"unique": true,
-			},
-		},
-	}
-
-	for _, tt := range testvalues {
-		err = db.IndexEnsure(tt.settings, tt.doc)
-		assert.NoError(t, err)
-
-		collection, err := db.GetCollectionOf(tt.doc)
-		require.NoError(t, err)
-
-		indexes, _ := collection.Indexes().List(db.Context())
-		index := new(map[string]interface{})
-
-		indexes.Next(db.Context()) // skip _id_
-		indexes.Next(db.Context())
-		indexes.Decode(&index)
-
-		for k, v := range tt.index {
-			assert.Equal(t, v, (*index)[k])
-		}
-	}
-}

mongox/database/loadarray.go

@@ -1,89 +0,0 @@
-package database
-
-import (
-	"fmt"
-	"reflect"
-
-	"github.com/mainnika/mongox-go-driver/v2/mongox/base"
-	"github.com/mainnika/mongox-go-driver/v2/mongox/query"
-)
-
-// LoadArray loads an array of documents from the database by query
-func (d *Database) LoadArray(target interface{}, filters ...interface{}) (err error) {
-	targetV := reflect.ValueOf(target)
-	targetT := targetV.Type()
-
-	targetK := targetV.Kind()
-	if targetK != reflect.Ptr {
-		panic(fmt.Errorf("target is not a ptr"))
-	}
-
-	targetSliceV := targetV.Elem()
-	targetSliceT := targetT.Elem()
-	if targetSliceT.Kind() != reflect.Slice {
-		panic(fmt.Errorf("target should be a ptr to a slice"))
-	}
-
-	targetSliceElemT := targetSliceT.Elem()
-	if targetSliceElemT.Kind() != reflect.Ptr {
-		panic(fmt.Errorf("target slice should contain ptrs"))
-	}
-
-	zeroElem := reflect.Zero(targetSliceElemT)
-
-	composed, err := query.Compose(filters...)
-	if err != nil {
-		return err
-	}
-
-	ctx := query.WithContext(d.Context(), composed)
-
-	defer func() { _ = composed.OnClose().Invoke(ctx, target) }()
-
-	cur, err := d.createCursor(zeroElem.Interface(), composed)
-	if err != nil {
-		return fmt.Errorf("can't create find result: %w", err)
-	}
-
-	defer func() { _ = cur.Close(ctx) }()
-
-	var i int
-	for i = 0; cur.Next(ctx); i++ {
-		var elem interface{}
-		if i == targetSliceV.Len() {
-			value := reflect.New(targetSliceElemT.Elem())
-			elem = value.Interface()
-
-			_ = composed.OnCreate().Invoke(ctx, elem)
-
-			err = cur.Decode(elem)
-			if err != nil {
-				return err
-			}
-
-			targetSliceV = reflect.Append(targetSliceV, value)
-		} else {
-			elem = targetSliceV.Index(i).Interface()
-
-			if created := base.Reset(elem); created {
-				_ = composed.OnCreate().Invoke(ctx, elem)
-			}
-
-			err = cur.Decode(elem)
-			if err != nil {
-				return err
-			}
-		}
-
-		_ = composed.OnDecode().Invoke(ctx, elem)
-	}
-	err = cur.Err()
-	if err != nil {
-		return err
-	}
-
-	targetSliceV = targetSliceV.Slice(0, i)
-	targetV.Elem().Set(targetSliceV)
-
-	return nil
-}

mongox/database/loadone.go

@@ -1,46 +0,0 @@
-package database
-
-import (
-	"github.com/mainnika/mongox-go-driver/v2/mongox"
-	"github.com/mainnika/mongox-go-driver/v2/mongox/base"
-	"github.com/mainnika/mongox-go-driver/v2/mongox/query"
-)
-
-// LoadOne function loads a first single target document by a query
-func (d *Database) LoadOne(target interface{}, filters ...interface{}) (err error) {
-	composed, err := query.Compose(append(filters, query.Limit(1))...)
-	if err != nil {
-		return err
-	}
-
-	ctx := query.WithContext(d.Context(), composed)
-
-	defer func() { _ = composed.OnClose().Invoke(ctx, target) }()
-
-	cur, err := d.createCursor(target, composed)
-	if err != nil {
-		return err
-	}
-	defer func() { _ = cur.Close(ctx) }()
-
-	hasNext := cur.Next(ctx)
-	if cur.Err() != nil {
-		return cur.Err()
-	}
-	if !hasNext {
-		return mongox.ErrNoDocuments
-	}
-
-	if created := base.Reset(target); created {
-		_ = composed.OnCreate().Invoke(ctx, target)
-	}
-
-	err = cur.Decode(target)
-	if err != nil {
-		return err
-	}
-
-	_ = composed.OnDecode().Invoke(ctx, target)
-
-	return nil
-}

mongox/database/loadstream.go

@@ -1,25 +0,0 @@
-package database
-
-import (
-	"github.com/mainnika/mongox-go-driver/v2/mongox"
-	"github.com/mainnika/mongox-go-driver/v2/mongox/query"
-)
-
-// LoadStream function loads documents one by one into a target channel
-func (d *Database) LoadStream(target interface{}, filters ...interface{}) (loader mongox.StreamLoader, err error) {
-	composed, err := query.Compose(filters...)
-	if err != nil {
-		return
-	}
-
-	ctx := query.WithContext(d.Context(), composed)
-
-	cur, err := d.createCursor(target, composed)
-	if err != nil {
-		return nil, err
-	}
-
-	loader = &StreamLoader{cur: cur, ctx: ctx, query: composed}
-
-	return loader, nil
-}

mongox/database/saveone.go

@@ -1,60 +0,0 @@
-package database
-
-import (
-	"github.com/mainnika/mongox-go-driver/v2/mongox/base/protection"
-	"go.mongodb.org/mongo-driver/bson/primitive"
-	"go.mongodb.org/mongo-driver/mongo/options"
-
-	"github.com/mainnika/mongox-go-driver/v2/mongox/base"
-	"github.com/mainnika/mongox-go-driver/v2/mongox/query"
-)
-
-// SaveOne saves a single source document to the database
-func (d *Database) SaveOne(source interface{}, filters ...interface{}) (err error) {
-	collection, err := d.GetCollectionOf(source)
-	if err != nil {
-		return err
-	}
-
-	composed, err := query.Compose(filters...)
-	if err != nil {
-		return err
-	}
-
-	id, err := base.GetID(source)
-	if err != nil {
-		return err
-	}
-	composed.And(primitive.M{"_id": id})
-
-	protected := protection.Get(source)
-	if protected != nil {
-		query.Push(composed, protected)
-		protected.Restate()
-	}
-
-	ctx := query.WithContext(d.Context(), composed)
-	m := composed.M()
-	opts := options.FindOneAndReplace()
-	opts.SetUpsert(true)
-	opts.SetReturnDocument(options.After)
-
-	defer func() { _ = composed.OnClose().Invoke(ctx, source) }()
-
-	result := collection.FindOneAndReplace(ctx, m, source, opts)
-	if result.Err() != nil {
-		return result.Err()
-	}
-
-	err = result.Decode(source)
-	if err != nil {
-		return
-	}
-
-	err = composed.OnDecode().Invoke(ctx, source)
-	if err != nil {
-		return
-	}
-
-	return
-}

mongox/database/streamloader.go

@@ -1,90 +0,0 @@
-package database
-
-import (
-	"context"
-
-	"github.com/mainnika/mongox-go-driver/v2/mongox"
-	"github.com/mainnika/mongox-go-driver/v2/mongox/base"
-	"github.com/mainnika/mongox-go-driver/v2/mongox/query"
-)
-
-// StreamLoader is a controller for a database cursor
-type StreamLoader struct {
-	cur   *mongox.Cursor
-	query *query.Query
-	ctx   context.Context
-}
-
-// DecodeNextMsg decodes the next document to an interface or returns an error
-func (l *StreamLoader) DecodeNextMsg(i interface{}) (err error) {
-	err = l.Next()
-	if err != nil {
-		return
-	}
-
-	err = l.DecodeMsg(i)
-	if err != nil {
-		return
-	}
-
-	return
-}
-
-// DecodeMsg decodes the current cursor document into an interface
-func (l *StreamLoader) DecodeMsg(i interface{}) (err error) {
-	if created := base.Reset(i); created {
-		_ = l.query.OnDecode().Invoke(l.ctx, i)
-	}
-	if err != nil {
-		return err
-	}
-
-	err = l.cur.Decode(i)
-	if err != nil {
-		return err
-	}
-
-	_ = l.query.OnDecode().Invoke(l.ctx, i)
-
-	return nil
-}
-
-// Next loads next documents but doesn't perform decoding
-func (l *StreamLoader) Next() (err error) {
-	hasNext := l.cur.Next(l.ctx)
-	err = l.cur.Err()
-	if err != nil {
-		return err
-	}
-	if !hasNext {
-		return mongox.ErrNoDocuments
-	}
-
-	return nil
-}
-
-// Cursor returns the underlying cursor
-func (l *StreamLoader) Cursor() (cursor *mongox.Cursor) {
-	return l.cur
-}
-
-// Close stream loader and the underlying cursor
-func (l *StreamLoader) Close() (err error) {
-	defer func() { _ = l.query.OnClose().Invoke(l.ctx, nil) }()
-
-	err = l.cur.Close(l.ctx)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// Err returns the last error
-func (l *StreamLoader) Err() (err error) {
-	return l.cur.Err()
-}
-
-func (l *StreamLoader) Context() (ctx context.Context) {
-	return l.ctx
-}

mongox/database/updateone.go

@@ -1,64 +0,0 @@
-package database
-
-import (
-	"github.com/mainnika/mongox-go-driver/v2/mongox/base/protection"
-	"github.com/modern-go/reflect2"
-	"go.mongodb.org/mongo-driver/bson/primitive"
-	"go.mongodb.org/mongo-driver/mongo/options"
-
-	"github.com/mainnika/mongox-go-driver/v2/mongox/query"
-)
-
-// UpdateOne updates a single document in the database and loads it into target
-func (d *Database) UpdateOne(target interface{}, filters ...interface{}) (err error) {
-	composed, err := query.Compose(filters...)
-	if err != nil {
-		return err
-	}
-
-	update, err := composed.Updater()
-	if err != nil {
-		return err
-	}
-
-	protected := protection.Get(target)
-	if protected != nil {
-		if !protected.X.IsZero() {
-			query.Push(composed, protected)
-		}
-		protected.Restate()
-
-		setCmd, _ := update["$set"].(primitive.M)
-		if reflect2.IsNil(setCmd) {
-			setCmd = primitive.M{}
-		}
-		protected.Inject(setCmd)
-		update["$set"] = setCmd
-	}
-
-	collection, err := d.GetCollectionOf(target)
-	if err != nil {
-		return err
-	}
-
-	ctx := query.WithContext(d.Context(), composed)
-	m := composed.M()
-	opts := options.FindOneAndUpdate()
-	opts.SetReturnDocument(options.After)
-
-	defer func() { _ = composed.OnClose().Invoke(ctx, target) }()
-
-	result := collection.FindOneAndUpdate(ctx, m, update, opts)
-	if result.Err() != nil {
-		return result.Err()
-	}
-
-	err = result.Decode(target)
-	if err != nil {
-		return err
-	}
-
-	_ = composed.OnDecode().Invoke(ctx, target)
-
-	return nil
-}

mongox/errors.go

@@ -1,28 +0,0 @@
-package mongox
-
-import (
-	"errors"
-
-	"go.mongodb.org/mongo-driver/mongo"
-)
-
-// Reexported mongo errors
-var (
-	ErrMissingResumeToken  = mongo.ErrMissingResumeToken
-	ErrNilCursor           = mongo.ErrNilCursor
-	ErrUnacknowledgedWrite = mongo.ErrUnacknowledgedWrite
-	ErrClientDisconnected  = mongo.ErrClientDisconnected
-	ErrNilDocument         = mongo.ErrNilDocument
-	ErrEmptySlice          = mongo.ErrEmptySlice
-	ErrInvalidIndexValue   = mongo.ErrInvalidIndexValue
-	ErrNonStringIndexName  = mongo.ErrNonStringIndexName
-	ErrMultipleIndexDrop   = mongo.ErrMultipleIndexDrop
-	ErrWrongClient         = mongo.ErrWrongClient
-	ErrNoDocuments         = mongo.ErrNoDocuments
-)
-
-var (
-	ErrMalformedBase     = errors.New("source contains malformed document base")
-	ErrUninitializedBase = errors.New("uninitialized document")
-	ErrNoCollection      = errors.New("no collection found")
-)

mongox/errors/internalerror.go

@@ -0,0 +1,16 @@
+package errors
+
+import "fmt"
+
+// InternalError error
+type InternalError string
+
+// Error message
+func (ie InternalError) Error() string {
+	return fmt.Sprintf("internal error, %s", string(ie))
+}
+
+// InternalErrorf function creates an instance of InternalError
+func InternalErrorf(format string, params ...interface{}) error {
+	return InternalError(fmt.Sprintf(format, params...))
+}

mongox/errors/malformed.go

@@ -0,0 +1,16 @@
+package errors
+
+import "fmt"
+
+// Malformed error
+type Malformed string
+
+// Error message
+func (m Malformed) Error() string {
+	return fmt.Sprintf("Malformed, %s", string(m))
+}
+
+// Malformedf creates an instance of Malformed
+func Malformedf(format string, params ...interface{}) error {
+	return Malformed(fmt.Sprintf(format, params...))
+}

mongox/errors/notfound.go

@@ -0,0 +1,16 @@
+package errors
+
+import "fmt"
+
+// NotFound error
+type NotFound string
+
+// Error message
+func (nf NotFound) Error() string {
+	return fmt.Sprintf("can not find, %s", string(nf))
+}
+
+// NotFoundErrorf function creates an instance of BadRequestError
+func NotFoundErrorf(format string, params ...interface{}) error {
+	return NotFound(fmt.Sprintf(format, params...))
+}

mongox/mongox.go

@@ -5,62 +5,95 @@ import (
 
 	"go.mongodb.org/mongo-driver/bson/primitive"
 	"go.mongodb.org/mongo-driver/mongo"
-)
+	"go.mongodb.org/mongo-driver/mongo/options"
-
+	"go.mongodb.org/mongo-driver/mongo/readpref"
-// Reexport basic mongo structs
-type (
-	Cursor     = mongo.Cursor
-	Client     = mongo.Client
-	Collection = mongo.Collection
 )
 
 // Database is the mongox database interface
 type Database interface {
-	Client() (client *Client)
+	Client() MongoClient
-	Context() (context context.Context)
+	Context() context.Context
-	Name() (name string)
+	Name() string
-	GetCollectionOf(document interface{}) (collection *Collection, err error)
+	New(ctx context.Context) Database
-	Count(target interface{}, filters ...interface{}) (count int64, err error)
+	GetCollectionOf(document interface{}) MongoCollection
-	DeleteArray(target interface{}, filters ...interface{}) (err error)
-	DeleteOne(target interface{}, filters ...interface{}) (err error)
-	LoadArray(target interface{}, filters ...interface{}) (err error)
-	LoadOne(target interface{}, filters ...interface{}) (err error)
-	LoadStream(target interface{}, filters ...interface{}) (loader StreamLoader, err error)
-	SaveOne(source interface{}, filters ...interface{}) (err error)
-	UpdateOne(target interface{}, filters ...interface{}) (err error)
-	IndexEnsure(cfg interface{}, document interface{}) (err error)
 }
 
-// StreamLoader is a interface to control database cursor
+// MongoClient is the mongo client interface
-type StreamLoader interface {
+type MongoClient interface {
-	Cursor() (cursor *Cursor)
+	Connect(ctx context.Context) error
-	DecodeNextMsg(i interface{}) (err error)
+	Disconnect(ctx context.Context) error
-	DecodeMsg(i interface{}) (err error)
+	Ping(ctx context.Context, rp *readpref.ReadPref) error
-	Next() (err error)
+	StartSession(opts ...*options.SessionOptions) (mongo.Session, error)
-	Close() (err error)
+	Database(name string, opts ...*options.DatabaseOptions) *mongo.Database
-	Err() (err error)
+	ListDatabases(ctx context.Context, filter interface{}, opts ...*options.ListDatabasesOptions) (mongo.ListDatabasesResult, error)
+	ListDatabaseNames(ctx context.Context, filter interface{}, opts ...*options.ListDatabasesOptions) ([]string, error)
+	UseSession(ctx context.Context, fn func(mongo.SessionContext) error) error
+	UseSessionWithOptions(ctx context.Context, opts *options.SessionOptions, fn func(mongo.SessionContext) error) error
+	Watch(ctx context.Context, pipeline interface{}, opts ...*options.ChangeStreamOptions) (*mongo.ChangeStream, error)
+	NumberSessionsInProgress() int
 }
 
-// OIDBased is an interface for documents that have objectId type for the _id field
+// MongoCollection is the mongo collection interface
-type OIDBased interface {
+type MongoCollection interface {
-	GetID() (id primitive.ObjectID)
+	Clone(opts ...*options.CollectionOptions) (*mongo.Collection, error)
+	Name() string
+	Database() *mongo.Database
+	BulkWrite(ctx context.Context, models []mongo.WriteModel, opts ...*options.BulkWriteOptions) (*mongo.BulkWriteResult, error)
+	InsertOne(ctx context.Context, document interface{}, opts ...*options.InsertOneOptions) (*mongo.InsertOneResult, error)
+	InsertMany(ctx context.Context, documents []interface{}, opts ...*options.InsertManyOptions) (*mongo.InsertManyResult, error)
+	DeleteOne(ctx context.Context, filter interface{}, opts ...*options.DeleteOptions) (*mongo.DeleteResult, error)
+	DeleteMany(ctx context.Context, filter interface{}, opts ...*options.DeleteOptions) (*mongo.DeleteResult, error)
+	UpdateOne(ctx context.Context, filter interface{}, update interface{}, opts ...*options.UpdateOptions) (*mongo.UpdateResult, error)
+	UpdateMany(ctx context.Context, filter interface{}, update interface{}, opts ...*options.UpdateOptions) (*mongo.UpdateResult, error)
+	ReplaceOne(ctx context.Context, filter interface{}, replacement interface{}, opts ...*options.ReplaceOptions) (*mongo.UpdateResult, error)
+	Aggregate(ctx context.Context, pipeline interface{}, opts ...*options.AggregateOptions) (*mongo.Cursor, error)
+	CountDocuments(ctx context.Context, filter interface{}, opts ...*options.CountOptions) (int64, error)
+	EstimatedDocumentCount(ctx context.Context, opts ...*options.EstimatedDocumentCountOptions) (int64, error)
+	Distinct(ctx context.Context, fieldName string, filter interface{}, opts ...*options.DistinctOptions) ([]interface{}, error)
+	Find(ctx context.Context, filter interface{}, opts ...*options.FindOptions) (*mongo.Cursor, error)
+	FindOne(ctx context.Context, filter interface{}, opts ...*options.FindOneOptions) *mongo.SingleResult
+	FindOneAndDelete(ctx context.Context, filter interface{}, opts ...*options.FindOneAndDeleteOptions) *mongo.SingleResult
+	FindOneAndReplace(ctx context.Context, filter interface{}, replacement interface{}, opts ...*options.FindOneAndReplaceOptions) *mongo.SingleResult
+	FindOneAndUpdate(ctx context.Context, filter interface{}, update interface{}, opts ...*options.FindOneAndUpdateOptions) *mongo.SingleResult
+	Watch(ctx context.Context, pipeline interface{}, opts ...*options.ChangeStreamOptions) (*mongo.ChangeStream, error)
+	Indexes() mongo.IndexView
+	Drop(ctx context.Context) error
+}
+
+// Saver is an interface for documents that can be saved
+type Saver interface {
+	Save(db Database) error
+}
+
+// Deleter is an interface for documents that can be deleted
+type Deleter interface {
+	Delete(db Database) error
+}
+
+// Loader is an interface for documents that can be loaded
+type Loader interface {
+	Load(db Database, filters ...interface{}) error
+}
+
+// Resetter is an interface for documenta that can be resetted
+type Resetter interface {
+	Reset()
+}
+
+// BaseObjectID is an interface for documents that have objectId type for the _id field
+type BaseObjectID interface {
+	GetID() primitive.ObjectID
 	SetID(id primitive.ObjectID)
 }
 
-// StringBased is an interface for documents that have string type for the _id field
+// BaseString is an interface for documents that have string type for the _id field
-type StringBased interface {
+type BaseString interface {
-	GetID() (id string)
+	GetID() string
 	SetID(id string)
 }
 
-// DocBased is an interface for documents that have object type for the _id field
+// BaseObject is an interface for documents that have object type for the _id field
-type DocBased interface {
+type BaseObject interface {
-	GetID() (id primitive.D)
+	GetID() primitive.D
 	SetID(id primitive.D)
 }
-
-// InterfaceBased is an interface for documents that have custom declated type for the _id field
-type InterfaceBased interface {
-	GetID() (id interface{})
-	SetID(id interface{})
-}

mongox/query/callbacks.go

@@ -1,26 +0,0 @@
-package query
-
-import (
-	"context"
-)
-
-type Callback func(ctx context.Context, iter interface{}) (err error)
-type Callbacks []Callback
-
-type (
-	OnDecode Callback
-	OnClose  Callback
-)
-
-// Invoke callbacks sequence
-func (c Callbacks) Invoke(ctx context.Context, iter interface{}) (err error) {
-
-	for _, cb := range c {
-		err = cb(ctx, iter)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}

mongox/query/callbacks_test.go

@@ -1,58 +0,0 @@
-package query_test
-
-import (
-	"context"
-	"fmt"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
-
-	"github.com/mainnika/mongox-go-driver/v2/mongox/query"
-)
-
-func TestCallbacks_InvokeOk(t *testing.T) {
-
-	mocked := mock.Mock{}
-
-	var callbacks = query.Callbacks{
-		func(ctx context.Context, iter interface{}) (err error) {
-			return mocked.Called(ctx, iter).Error(0)
-		},
-		func(ctx context.Context, iter interface{}) (err error) {
-			return mocked.Called(ctx, iter).Error(0)
-		},
-	}
-
-	ctx := context.Background()
-	iter := int64(42)
-
-	mocked.On("func1", ctx, iter).Return(nil).Once()
-	mocked.On("func2", ctx, iter).Return(nil).Once()
-
-	assert.NoError(t, callbacks.Invoke(ctx, iter))
-	assert.True(t, mocked.AssertExpectations(t))
-}
-
-func TestCallbacks_InvokeStopIfError(t *testing.T) {
-
-	mocked := mock.Mock{}
-
-	var callbacks = query.Callbacks{
-		func(ctx context.Context, iter interface{}) (err error) {
-			return mocked.Called(ctx, iter).Error(0)
-		},
-		func(ctx context.Context, iter interface{}) (err error) {
-			t.FailNow()
-			return
-		},
-	}
-
-	ctx := context.Background()
-	iter := int(42)
-
-	mocked.On("func1", ctx, iter).Return(fmt.Errorf("wat"))
-
-	assert.EqualError(t, callbacks.Invoke(ctx, iter), "wat")
-	assert.True(t, mocked.AssertExpectations(t))
-}

mongox/query/compose.go

@@ -1,68 +1,46 @@
 package query
 
 import (
-	"fmt"
+	"go.mongodb.org/mongo-driver/bson"
-
-	"github.com/modern-go/reflect2"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 
-	"github.com/mainnika/mongox-go-driver/v2/mongox/base/protection"
+	"github.com/mainnika/mongox-go-driver/v2/mongox/base"
+	"github.com/mainnika/mongox-go-driver/v2/mongox/errors"
 )
 
-type applyFilterFunc func(query *Query, filter interface{}) (ok bool)
-
 // Compose is a function to compose filters into a single query
-func Compose(filters ...interface{}) (query *Query, err error) {
+func Compose(filters ...interface{}) *Query {
-	query = &Query{}
+
-	for _, filter := range filters {
+	q := &Query{}
-		ok, err := Push(query, filter)
+
-		if err != nil {
+	for _, f := range filters {
-			return nil, fmt.Errorf("invalid filter %v, %w", filter, err)
+		if !Push(q, f) {
-		}
+			panic(errors.InternalErrorf("unknown filter %v", f))
-		if !ok {
-			panic(fmt.Errorf("unknown filter %v", filter))
 		}
 	}
 
-	return query, nil
+	return q
 }
 
 // Push applies single filter to a query
-func Push(query *Query, filter interface{}) (ok bool, err error) {
+func Push(q *Query, f interface{}) bool {
-	emptyFilter := reflect2.IsNil(filter)
-	if emptyFilter {
-		return true, nil
-	}
 
-	validator, hasValidator := filter.(Validator)
+	ok := false
-	if hasValidator {
+	ok = ok || applyBson(q, f)
-		err := validator.Validate()
+	ok = ok || applyLimit(q, f)
-		if err != nil {
+	ok = ok || applySort(q, f)
-			return false, fmt.Errorf("while validating filter %v, %w", filter, err)
+	ok = ok || applySkip(q, f)
-		}
+	ok = ok || applyProtection(q, f)
-	}
+	ok = ok || applyPreloader(q, f)
 
-	ok = false // true if at least one filter was applied
+	return ok
-	for _, applier := range []applyFilterFunc{
-		applyBson,
-		applyLimit,
-		applySort,
-		applySkip,
-		applyProtection,
-		applyPreloader,
-		applyUpdater,
-		applyCallbacks,
-	} {
-		ok = applier(query, filter) || ok
-	}
-
-	return ok, nil
 }
 
-// applyBson is a fallback for a custom primitive.M
+// applyBson is a fallback for a custom bson.M
-func applyBson(query *Query, filter interface{}) (ok bool) {
+func applyBson(q *Query, f interface{}) bool {
-	if filter, ok := filter.(primitive.M); ok {
+
-		query.And(filter)
+	if f, ok := f.(bson.M); ok {
+		q.And(f)
 		return true
 	}
 
@@ -70,9 +48,10 @@ func applyBson(query *Query, filter interface{}) (ok bool) {
 }
 
 // applyLimits extends query with a limiter
-func applyLimit(query *Query, filter interface{}) (ok bool) {
+func applyLimit(q *Query, f interface{}) bool {
-	if filter, ok := filter.(Limiter); ok {
+
-		query.limiter = filter
+	if f, ok := f.(Limiter); ok {
+		q.limiter = f
 		return true
 	}
 
@@ -80,9 +59,10 @@ func applyLimit(query *Query, filter interface{}) (ok bool) {
 }
 
 // applySort extends query with a sort rule
-func applySort(query *Query, filter interface{}) (ok bool) {
+func applySort(q *Query, f interface{}) bool {
-	if filter, ok := filter.(Sorter); ok {
+
-		query.sorter = filter
+	if f, ok := f.(Sorter); ok {
+		q.sorter = f
 		return true
 	}
 
@@ -90,58 +70,53 @@ func applySort(query *Query, filter interface{}) (ok bool) {
 }
 
 // applySkip extends query with a skip number
-func applySkip(query *Query, filter interface{}) (ok bool) {
+func applySkip(q *Query, f interface{}) bool {
-	if filter, ok := filter.(Skipper); ok {
+
-		query.skipper = filter
+	if f, ok := f.(Skipper); ok {
+		q.skipper = f
 		return true
 	}
 
 	return false
 }
 
-func applyProtection(query *Query, filter interface{}) (ok bool) {
+func applyProtection(q *Query, f interface{}) bool {
-	keyDoc := primitive.M{}
+
-	switch filter := filter.(type) {
+	var x *primitive.ObjectID
-	case protection.Key:
+	var v *int64
-		filter.Inject(keyDoc)
+
-	case *protection.Key:
+	switch f := f.(type) {
-		filter.Inject(keyDoc)
+	case base.Protection:
+		x = &f.X
+		v = &f.V
+	case *base.Protection:
+		if f == nil {
+			return false
+		}
+		x = &f.X
+		v = &f.V
+
 	default:
 		return false
 	}
 
-	query.And(keyDoc)
+	if x.IsZero() {
+		q.And(primitive.M{"_x": primitive.M{"$exists": false}})
+		q.And(primitive.M{"_v": primitive.M{"$exists": false}})
+	} else {
+		q.And(primitive.M{"_x": *x})
+		q.And(primitive.M{"_v": *v})
+	}
 
 	return true
 }
 
-func applyPreloader(query *Query, filter interface{}) (ok bool) {
+func applyPreloader(q *Query, f interface{}) bool {
-	if filter, ok := filter.(Preloader); ok {
+
-		query.preloader = filter
+	if f, ok := f.(Preloader); ok {
+		q.preloader = f
 		return true
 	}
 
 	return false
 }
-
-func applyUpdater(query *Query, filter interface{}) (ok bool) {
-	if filter, ok := filter.(Updater); ok {
-		query.updater = filter
-		return true
-	}
-
-	return false
-}
-
-func applyCallbacks(query *Query, filter interface{}) (ok bool) {
-	switch callback := filter.(type) {
-	case OnDecode:
-		query.onDecode = append(query.onDecode, Callback(callback))
-	case OnClose:
-		query.onClose = append(query.onClose, Callback(callback))
-	default:
-		return false
-	}
-
-	return true
-}

mongox/query/compose_test.go

@@ -1,128 +0,0 @@
-package query_test
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"go.mongodb.org/mongo-driver/bson/primitive"
-
-	"github.com/mainnika/mongox-go-driver/v2/mongox/base/protection"
-	"github.com/mainnika/mongox-go-driver/v2/mongox/query"
-)
-
-func TestPushBSON(t *testing.T) {
-
-	q := &query.Query{}
-
-	ok, err := query.Push(q, primitive.M{"foo": "bar"})
-
-	assert.True(t, ok)
-	assert.NoError(t, err)
-	assert.NotEmpty(t, q.M())
-	assert.Len(t, q.M()["$and"], 1)
-	assert.Contains(t, q.M()["$and"], primitive.M{"foo": "bar"})
-
-	ok, err = query.Push(q, primitive.M{"bar": "foo"})
-
-	assert.True(t, ok)
-	assert.NoError(t, err)
-	assert.NotEmpty(t, q.M())
-	assert.Len(t, q.M()["$and"], 2)
-	assert.Contains(t, q.M()["$and"], primitive.M{"foo": "bar"})
-	assert.Contains(t, q.M()["$and"], primitive.M{"bar": "foo"})
-}
-
-func TestPushLimiter(t *testing.T) {
-
-	q := &query.Query{}
-	lim := query.Limit(2)
-
-	ok, err := query.Push(q, lim)
-
-	assert.True(t, ok)
-	assert.NoError(t, err)
-	assert.NotNil(t, q.Limiter())
-	assert.EqualValues(t, q.Limiter(), query.Limit(2).Limit())
-}
-
-func TestPushSorter(t *testing.T) {
-
-	q := &query.Query{}
-	sort := query.Sort{"foo": 1}
-
-	ok, err := query.Push(q, sort)
-
-	assert.True(t, ok)
-	assert.NoError(t, err)
-	assert.NotNil(t, q.Sorter())
-	assert.EqualValues(t, q.Sorter(), primitive.M{"foo": 1})
-}
-
-func TestPushSkipper(t *testing.T) {
-
-	q := &query.Query{}
-	skip := query.Skip(66)
-
-	ok, err := query.Push(q, skip)
-
-	assert.True(t, ok)
-	assert.NoError(t, err)
-	assert.NotNil(t, q.Skipper())
-	assert.EqualValues(t, q.Skipper(), query.Skip(66).Skip())
-}
-
-func TestPushProtection(t *testing.T) {
-
-	t.Run("push protection key pointer", func(t *testing.T) {
-		q := &query.Query{}
-		protected := &protection.Key{V: 1, X: primitive.ObjectID{2}}
-
-		ok, err := query.Push(q, protected)
-
-		assert.True(t, ok)
-		assert.NoError(t, err)
-		assert.NotEmpty(t, q.M()["$and"])
-		assert.Contains(t, q.M()["$and"], primitive.M{"_x": primitive.ObjectID{2}, "_v": int64(1)})
-	})
-
-	t.Run("push protection key struct", func(t *testing.T) {
-		q := &query.Query{}
-		protected := protection.Key{V: 1, X: primitive.ObjectID{2}}
-
-		ok, err := query.Push(q, protected)
-
-		assert.True(t, ok)
-		assert.NoError(t, err)
-		assert.NotEmpty(t, q.M()["$and"])
-		assert.Contains(t, q.M()["$and"], primitive.M{"_x": primitive.ObjectID{2}, "_v": int64(1)})
-	})
-
-	t.Run("protection key is empty", func(t *testing.T) {
-		q := &query.Query{}
-		protected := &protection.Key{}
-
-		ok, err := query.Push(q, protected)
-
-		assert.True(t, ok)
-		assert.NoError(t, err)
-		assert.NotEmpty(t, q.M()["$and"])
-		assert.Contains(t, q.M()["$and"], primitive.M{"_x": primitive.M{"$exists": false}, "_v": primitive.M{"$exists": false}})
-	})
-}
-
-func TestPushPreloader(t *testing.T) {
-
-	q := &query.Query{}
-	preloader := query.Preload{"a", "b"}
-
-	ok, err := query.Push(q, preloader)
-
-	assert.True(t, ok)
-	assert.NoError(t, err)
-
-	p, hasPreloader := q.Preloader()
-
-	assert.NotNil(t, p)
-	assert.True(t, hasPreloader)
-	assert.EqualValues(t, p, query.Preload{"a", "b"})
-}

mongox/query/context.go

@@ -1,22 +0,0 @@
-package query
-
-import (
-	"context"
-)
-
-type ctxQueryKey struct{}
-
-// GetFromContext function extracts the request data from context
-func GetFromContext(ctx context.Context) (q *Query, ok bool) {
-	q, ok = ctx.Value(ctxQueryKey{}).(*Query)
-	if !ok {
-		return nil, false
-	}
-
-	return q, true
-}
-
-// WithContext function creates the new context with request data
-func WithContext(ctx context.Context, q *Query) (withQuery context.Context) {
-	return context.WithValue(ctx, ctxQueryKey{}, q)
-}

mongox/query/limit.go

@@ -2,7 +2,7 @@ package query
 
 // Limiter is a filter to limit the result
 type Limiter interface {
-	Limit() (limit *int64)
+	Limit() *int64
 }
 
 // Limit is a simple implementation of the Limiter filter
@@ -11,13 +11,12 @@ type Limit int64
 var _ Limiter = Limit(0)
 
 // Limit returns a limit
-func (l Limit) Limit() (limit *int64) {
+func (l Limit) Limit() *int64 {
-	if l <= 0 {
+
+	lim := int64(l)
+	if lim <= 0 {
 		return nil
 	}
 
-	limit = new(int64)
+	return &lim
-	*limit = int64(l)
-
-	return limit
 }

mongox/query/preload.go

@@ -1,16 +1,17 @@
 package query
 
-// Preloader is a filter to preload the result
+// Preloader is a filter to skip the result
 type Preloader interface {
-	Preload() (preloads []string)
+	Preload() []string
 }
 
-// Preload is a simple implementation of the Preloader filter
+// Preload is a simple implementation of the Skipper filter
 type Preload []string
 
 var _ Preloader = Preload{}
 
 // Preload returns a preload list
-func (l Preload) Preload() (preloads []string) {
+func (l Preload) Preload() []string {
-	return l
+
+	return Preload(l)
 }

mongox/query/query.go

@@ -1,43 +1,42 @@
 package query
 
 import (
-	"github.com/modern-go/reflect2"
-	"github.com/valyala/bytebufferpool"
 	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/primitive"
+
+	"reflect"
 )
 
-// Query is an enchanched primitive.M map
+// Query is an enchanched bson.M map
 type Query struct {
-	m         primitive.M
+	m         bson.M
 	limiter   Limiter
 	sorter    Sorter
 	skipper   Skipper
 	preloader Preloader
-	updater   Updater
-	onDecode  Callbacks
-	onClose   Callbacks
-	onCreate  Callbacks
 }
 
 // And function pushes the elem query to the $and array of the query
-func (q *Query) And(elem primitive.M) (query *Query) {
+func (q *Query) And(elem bson.M) *Query {
+
 	if q.m == nil {
-		q.m = primitive.M{}
+		q.m = bson.M{}
 	}
 
-	queries, exists := q.m["$and"].(primitive.A)
+	queries, exists := q.m["$and"].(bson.A)
+
 	if !exists {
-		q.m["$and"] = primitive.A{elem}
+		q.m["$and"] = bson.A{elem}
 		return q
 	}
 
 	q.m["$and"] = append(queries, elem)
+
 	return q
 }
 
 // Limiter returns limiter value or nil
-func (q *Query) Limiter() (limit *int64) {
+func (q *Query) Limiter() *int64 {
+
 	if q.limiter == nil {
 		return nil
 	}
@@ -46,7 +45,8 @@ func (q *Query) Limiter() (limit *int64) {
 }
 
 // Sorter is a sort rule for a query
-func (q *Query) Sorter() (sort interface{}) {
+func (q *Query) Sorter() interface{} {
+
 	if q.sorter == nil {
 		return nil
 	}
@@ -55,7 +55,8 @@ func (q *Query) Sorter() (sort interface{}) {
 }
 
 // Skipper is a skipper for a query
-func (q *Query) Skipper() (skip *int64) {
+func (q *Query) Skipper() *int64 {
+
 	if q.skipper == nil {
 		return nil
 	}
@@ -63,72 +64,32 @@ func (q *Query) Skipper() (skip *int64) {
 	return q.skipper.Skip()
 }
 
-// Updater is an update command for a query
-func (q *Query) Updater() (update primitive.M, err error) {
-	if q.updater == nil {
-		return primitive.M{}, nil
-	}
-
-	update = q.updater.Update()
-	if reflect2.IsNil(update) {
-		return primitive.M{}, nil
-	}
-
-	buffer := bytebufferpool.Get()
-	defer bytebufferpool.Put(buffer)
-
-	// convert update document to bson map values
-	buffer.Reset()
-	bsonBytes, err := bson.MarshalAppend(buffer.B, update)
-	if err != nil {
-		return primitive.M{}, err
-	}
-	update = primitive.M{} // reset update map and unmarshal bson bytes to it again
-	err = bson.Unmarshal(bsonBytes, update)
-	if err != nil {
-		return primitive.M{}, err
-	}
-
-	return update, nil
-}
-
 // Preloader is a preloader list for a query
-func (q *Query) Preloader() (preloads []string, ok bool) {
+func (q *Query) Preloader() (empty bool, preloader []string) {
+
 	if q.preloader == nil {
-		return nil, false
+		return false, nil
 	}
 
-	preloads = q.preloader.Preload()
+	preloader = q.preloader.Preload()
 
-	return preloads, len(preloads) > 0
+	if len(preloader) == 0 {
-}
+		return false, nil
+	}
 
-// OnDecode callback is called after the mongo decode function
+	return true, preloader
-func (q *Query) OnDecode() (callbacks Callbacks) {
-	return q.onDecode
-}
-
-// OnClose callback is called after the mongox ends a loading procedure
-func (q *Query) OnClose() (callbacks Callbacks) {
-	return q.onClose
-}
-
-// OnCreate callback is called if the mongox creates a new document instance during loading
-func (q *Query) OnCreate() (callbacks Callbacks) {
-	return q.onClose
 }
 
 // Empty checks the query for any content
-func (q *Query) Empty() (isEmpty bool) {
+func (q *Query) Empty() bool {
-	return len(q.m) == 0
+
+	qv := reflect.ValueOf(q.m)
+	keys := qv.MapKeys()
+
+	return len(keys) == 0
 }
 
 // M returns underlying query map
-func (q *Query) M() (m primitive.M) {
+func (q *Query) M() bson.M {
 	return q.m
 }
-
-// New creates a new query
-func New() (query *Query) {
-	return &Query{}
-}

mongox/query/skip.go

@@ -2,7 +2,7 @@ package query
 
 // Skipper is a filter to skip the result
 type Skipper interface {
-	Skip() (skip *int64)
+	Skip() *int64
 }
 
 // Skip is a simple implementation of the Skipper filter
@@ -11,13 +11,12 @@ type Skip int64
 var _ Skipper = Skip(0)
 
 // Skip returns a skip number
-func (l Skip) Skip() (skip *int64) {
+func (l Skip) Skip() *int64 {
-	if l <= 0 {
+
+	lim := int64(l)
+	if lim <= 0 {
 		return nil
 	}
 
-	skip = new(int64)
+	return &lim
-	*skip = int64(l)
-
-	return skip
 }

mongox/query/sort.go

@@ -1,20 +1,20 @@
 package query
 
 import (
-	"go.mongodb.org/mongo-driver/bson/primitive"
+	"go.mongodb.org/mongo-driver/bson"
 )
 
 // Sorter is a filter to sort the data before query
 type Sorter interface {
-	Sort() (sort primitive.M)
+	Sort() bson.M
 }
 
 // Sort is a simple implementations of the Sorter filter
-type Sort primitive.M
+type Sort bson.M
 
 var _ Sorter = &Sort{}
 
 // Sort returns a slice of fields which have to be sorted
-func (f Sort) Sort() (sort primitive.M) {
+func (f Sort) Sort() bson.M {
-	return primitive.M(f)
+	return bson.M(f)
 }

mongox/query/update.go

@@ -1,20 +0,0 @@
-package query
-
-import (
-	"go.mongodb.org/mongo-driver/bson/primitive"
-)
-
-// Updater is a filter to update the data
-type Updater interface {
-	Update() (update primitive.M)
-}
-
-// Update is a simple implementations of the Updater filter
-type Update primitive.M
-
-var _ Updater = &Update{}
-
-// Update returns an update command
-func (u Update) Update() (update primitive.M) {
-	return primitive.M(u)
-}

mongox/query/validate.go

@@ -1,6 +0,0 @@
-package query
-
-// Validator is a filter to validate the filter
-type Validator interface {
-	Validate() (err error)
-}

mongox/tempdb/tempdb.go

@@ -0,0 +1,35 @@
+package tempdb
+
+import (
+	"context"
+	"math/rand"
+	"strconv"
+
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+
+	"github.com/mainnika/mongox-go-driver/v2/mongox"
+	"github.com/mainnika/mongox-go-driver/v2/mongox/database"
+)
+
+// TempDB is a temporary database connection that will be destroyed after close
+type TempDB struct {
+	mongox.Database
+}
+
+// NewTempDB creates new mongo connection
+func NewTempDB(URI string) (tempdb *TempDB, err error) {
+
+	name := strconv.Itoa(rand.Int())
+	opts := options.Client().ApplyURI(URI)
+	client, err := mongo.Connect(context.Background(), opts)
+
+	tempdb = &TempDB{Database: database.NewDatabase(client, name)}
+
+	return
+}
+
+// Close the connection and drop database
+func (tdb *TempDB) Close() {
+	_ = tdb.Client().Database(tdb.Name()).Drop(tdb.Context())
+}

testing.Dockerfile

@@ -1,33 +0,0 @@
-# syntax = docker/dockerfile:1.3-labs
-FROM registry.access.redhat.com/ubi8/ubi
-
-RUN <<EOF cat >> /etc/yum.repos.d/mongo.repo
-[mongodb-org]
-name=MongoDB Repository
-baseurl=https://repo.mongodb.org/yum/redhat/8/mongodb-org/4.4/x86_64/
-gpgcheck=1
-enabled=1
-gpgkey=https://www.mongodb.org/static/pgp/server-4.4.asc
-EOF
-
-RUN set -eux \
-    && dnf makecache \
-	&& dnf install -yq mongodb-org-server golang \
-    && dnf clean all
-
-WORKDIR /root/mongox
-
-ENV GOPATH=/root/go
-
-COPY go.mod .
-COPY go.sum .
-
-RUN set -eux \
-    && go mod download
-
-COPY mongox-testing mongox-testing
-COPY mongox mongox
-
-CMD set -eux \
-    && nohup mongod --dbpath $(mktemp -d) \
-    & go test -timeout 30s -v ./...