Fix comments

go.mod

@@ -1,14 +1,11 @@
 module github.com/mainnika/mongox-go-driver/v2
 
-require (
-	github.com/google/go-cmp v0.3.0 // indirect
-	github.com/klauspost/compress v1.10.1 // indirect
-	github.com/pkg/errors v0.9.1 // indirect
-	github.com/stretchr/testify v1.5.1
-	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
+
+require (
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.1
+	github.com/stretchr/testify v1.6.1
+	github.com/valyala/bytebufferpool v1.0.0
+	go.mongodb.org/mongo-driver v1.4.3
+)

go.sum

@@ -1,7 +1,10 @@
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/aws/aws-sdk-go v1.34.28 h1:sscPpn/Ns3i0F4HPEWAVcwdIRaZZCuL7llJ2/60yPIk=
+github.com/aws/aws-sdk-go v1.34.28/go.mod h1:H7NKnBqNVzoTJpGfLrQkkD+ytBA93eiDYi/+8rV9s48=
 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-sql-driver/mysql v1.5.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
 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=
@@ -30,29 +33,34 @@ github.com/gobuffalo/packr/v2 v2.2.0/go.mod h1:CaAwI0GPIAv+5wKLtv8Afwl+Cm78K/I/V
 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.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/google/go-cmp v0.5.2 h1:X2ev0eStA3AbceY54o37/0PQ/UWqKEiiO2dKL5OPaFM=
-github.com/google/go-cmp v0.3.0 h1:crn/baboCvb5fXaQ0IJ1SGTsTVrWpDsCWC8EGETZijY=
+github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
+github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg=
+github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo=
+github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8=
+github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U=
 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 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 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/markbates/oncer v0.0.0-20181203154359-bf2de49a0be2/go.mod h1:Ld9puTsIW75CHf65OeIOkyKbteujpZVXDpWK6YGZbxE=
 github.com/markbates/safe v1.0.1/go.mod h1:nAqgmRi7cY2nqMc92/bSEeQA+R4OheNU2T1kNSCBdG0=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v1.0.1 h1:9f412s+6RmYXLWZSEzVVgPGK7C2PphHj5RJrvfx9AWI=
+github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 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/pelletier/go-toml v1.7.0/go.mod h1:vwGMzjaWMwyfHwgIBhI2YUM4fB6nL6lVAvS1LBMMhTE=
 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=
@@ -69,30 +77,30 @@ github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnIn
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.5.1 h1:nOGnQDM7FYENwehXlg/kFVnos3rEvtKTjRvOWSzb6H4=
+github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0=
-github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
+github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 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/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
 github.com/xdg/scram v0.0.0-20180814205039-7eeb5667e42c h1:u40Z8hqBAAQyv+vATcGgV0YCnDjqSL7/q/JyPhhJSPk=
 github.com/xdg/scram v0.0.0-20180814205039-7eeb5667e42c/go.mod h1:lB8K/P019DLNhemzwFU4jHLhdvlE6uDZjXFejJXr49I=
+github.com/xdg/stringprep v0.0.0-20180714160509-73f8eece6fdc h1:n+nNi93yXLkJvKwXNP9d55HC7lGK4H/SRcwB5IaUZLo=
 github.com/xdg/stringprep v0.0.0-20180714160509-73f8eece6fdc/go.mod h1:Jhud4/sHMO4oL310DaZAKk9ZaJ08SJfe+sJh0HrGL1Y=
-github.com/xdg/stringprep v1.0.0 h1:d9X0esnoa3dFsV0FG35rAT0RIhYFlPq7MiP+DW89La0=
+go.mongodb.org/mongo-driver v1.4.3 h1:moga+uhicpVshTyaqY9L23E6QqwcHRUv1sqyOsoyOO8=
-github.com/xdg/stringprep v1.0.0/go.mod h1:Jhud4/sHMO4oL310DaZAKk9ZaJ08SJfe+sJh0HrGL1Y=
+go.mongodb.org/mongo-driver v1.4.3/go.mod h1:WcMNYLx/IlOxLe6JRJiv2uXuCz6zBLndR4SoGjYphSc=
-go.mongodb.org/mongo-driver v1.3.0 h1:ew6uUIeJOo+qdUUv7LxFCUhtWmVv7ZV/Xuy4FAUsw2E=
-go.mongodb.org/mongo-driver v1.3.0/go.mod h1:MSWZXKOynuguX+JSvwP8i+58jYCXxbia8HS3gZBapIE=
 golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20190422162423-af44ce270edf/go.mod h1:WFFai1msRO1wXaEeE5yQxYXgSfI8pQAWXbQop6sCtWE=
+golang.org/x/crypto v0.0.0-20190530122614-20be4c3c3ed5 h1:8dUaAV7K4uHsF56JQWkprecIQKdPHtR9jCHF5nB8uzc=
 golang.org/x/crypto v0.0.0-20190530122614-20be4c3c3ed5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200221231518-2aa609cf4a9d h1:1ZiEyfaQIg3Qh0EoqpwAakHVhecoE5wlSg5GjnafJGw=
-golang.org/x/crypto v0.0.0-20200221231518-2aa609cf4a9d/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20200202094626-16171245cfb2 h1:CCH4IOTTfewWjGOlSp+zGcjutRKlBEZQ6wTn8ozI/nI=
+golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190412183630-56d357773e84/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58 h1:8gQV6CLnAEikrhgkHFbMAEhagSSnXWGV915qUMm9mrU=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e h1:vcxGaoTs7kV8m5Np9uUNQin4BrLOthgV7252N8V+FwY=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -104,16 +112,20 @@ golang.org/x/sys v0.0.0-20190419153524-e8e3143a4f4a/go.mod h1:h1NjWce9XRLGQEsW7w
 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.3 h1:cokOdA+Jmi5PJGXLlLllQSgYigAEfHXJAERHVMaCc2k=
-golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 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=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 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/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
-gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
+gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
-gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

mongox/base/getid.go

@@ -3,10 +3,10 @@ package base
 import (
 	"fmt"
 
+	"github.com/modern-go/reflect2"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 
 	"github.com/mainnika/mongox-go-driver/v2/mongox"
-	"github.com/mainnika/mongox-go-driver/v2/mongox/utils"
 )
 
 // GetID returns source document id
@@ -63,7 +63,7 @@ func getObjectOrPanic(source mongox.JSONBased) (id primitive.D) {
 func getInterfaceOrPanic(source mongox.InterfaceBased) (id interface{}) {
 
 	id = source.GetID()
-	if !utils.IsNil(id) {
+	if !reflect2.IsNil(id) {
 		return id
 	}
 

mongox/base/protection/key.go

@@ -1,6 +1,9 @@
 package protection
 
 import (
+	"time"
+
+	"github.com/modern-go/reflect2"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 )
 
@@ -9,3 +12,25 @@ type Key struct {
 	X primitive.ObjectID `bson:"_x" json:"_x" index:",hashed"`
 	V int64              `bson:"_v" json:"_v"`
 }
+
+// PutToDocument extends the doc with protection key values
+func (k *Key) PutToDocument(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()
+}

mongox/base/reset.go

@@ -6,7 +6,7 @@ import (
 )
 
 // Reset function creates new zero object for the target pointer
-func Reset(target interface{}) {
+func Reset(target interface{}) (created bool) {
 
 	type resetter interface {
 		Reset()
@@ -15,7 +15,7 @@ func Reset(target interface{}) {
 	resettable, canReset := target.(resetter)
 	if canReset {
 		resettable.Reset()
-		return
+		return false
 	}
 
 	v := reflect.ValueOf(target)
@@ -27,4 +27,6 @@ func Reset(target interface{}) {
 	zero := reflect.Zero(t)
 
 	v.Elem().Set(zero)
+
+	return true
 }

mongox/database/callbacks.go

@@ -1,19 +0,0 @@
-package database
-
-import (
-	"context"
-
-	"github.com/mainnika/mongox-go-driver/v2/mongox/query"
-)
-
-func onDecode(ctx context.Context, iter interface{}, callbacks ...query.OnDecode) (err error) {
-
-	for _, cb := range callbacks {
-		err = cb(ctx, iter)
-		if err != nil {
-			return
-		}
-	}
-
-	return
-}

mongox/database/count.go

@@ -10,14 +10,21 @@ import (
 // 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) {
 
-	collection := d.GetCollectionOf(target)
+	composed, err := query.Compose(filters...)
-	opts := options.Count()
+	if err != nil {
-	composed := query.Compose(filters...)
+		return
+	}
 
+	collection := d.GetCollectionOf(target)
+	ctx := query.WithContext(d.Context(), composed)
+
+	opts := options.Count()
 	opts.Limit = composed.Limiter()
 	opts.Skip = composed.Skipper()
 
-	result, err = collection.CountDocuments(d.Context(), composed.M(), opts)
+	result, err = collection.CountDocuments(ctx, composed.M(), opts)
+
+	_ = composed.OnClose().Invoke(ctx, target)
 
 	return
 }

mongox/database/database.go

@@ -129,7 +129,7 @@ func (d *Database) createAggregateLoad(target interface{}, composed *query.Query
 	el := reflect.ValueOf(target).Elem()
 	elType := el.Type()
 	numField := elType.NumField()
-	_, preloads := composed.Preloader()
+	preloads, _ := composed.Preloader()
 
 	for i := 0; i < numField; i++ {
 

mongox/database/deletearray.go

@@ -8,10 +8,11 @@ import (
 	"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{}) (err error) {
+func (d *Database) DeleteArray(target interface{}, filters ...interface{}) (err error) {
 
 	targetV := reflect.ValueOf(target)
 	targetT := targetV.Type()
@@ -34,20 +35,37 @@ func (d *Database) DeleteArray(target interface{}) (err error) {
 
 	zeroElem := reflect.Zero(targetSliceElemT)
 	targetLen := targetSliceV.Len()
+
+	composed, err := query.Compose(filters...)
+	if err != nil {
+		return
+	}
+
 	collection := d.GetCollectionOf(zeroElem.Interface())
-	opts := options.Delete()
 	ids := primitive.A{}
+	ctx := query.WithContext(d.Context(), composed)
 
 	for i := 0; i < targetLen; i++ {
 		elem := targetSliceV.Index(i)
 		ids = append(ids, base.GetID(elem.Interface()))
 	}
 
+	defer func() {
+		invokerr := composed.OnClose().Invoke(ctx, target)
+		if err == nil {
+			err = invokerr
+		}
+
+		return
+	}()
+
 	if len(ids) == 0 {
 		return fmt.Errorf("can't delete zero elements")
 	}
 
-	result, err := collection.DeleteMany(d.Context(), primitive.M{"_id": primitive.M{"$in": ids}}, opts)
+	composed.And(primitive.M{"_id": primitive.M{"$in": ids}})
+
+	result, err := collection.DeleteMany(ctx, composed.M(), options.Delete())
 	if err != nil {
 		return
 	}

mongox/database/deleteone.go

@@ -2,42 +2,62 @@ package database
 
 import (
 	"fmt"
-	"time"
 
+	"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"
-	"github.com/mainnika/mongox-go-driver/v2/mongox/utils"
 )
 
 // DeleteOne removes a document from a database and then returns it into target
 func (d *Database) DeleteOne(target interface{}, filters ...interface{}) (err error) {
 
-	collection := d.GetCollectionOf(target)
+	composed, err := query.Compose(filters...)
-	opts := &options.FindOneAndDeleteOptions{}
+	if err != nil {
-	composed := query.Compose(filters...)
+		return
-	protected := base.GetProtection(target)
+	}
 
+	collection := d.GetCollectionOf(target)
+	protected := base.GetProtection(target)
+	ctx := query.WithContext(d.Context(), composed)
+
+	opts := options.FindOneAndDelete()
 	opts.Sort = composed.Sorter()
 
-	if !utils.IsNil(target) {
+	if !reflect2.IsNil(target) {
 		composed.And(primitive.M{"_id": base.GetID(target)})
 	}
 
 	if protected != nil {
 		query.Push(composed, protected)
-		protected.X = primitive.NewObjectID()
+		protected.Restate()
-		protected.V = time.Now().Unix()
 	}
 
-	result := collection.FindOneAndDelete(d.Context(), composed.M(), opts)
+	defer func() {
+		invokerr := composed.OnClose().Invoke(ctx, target)
+		if err == nil {
+			err = invokerr
+		}
+
+		return
+	}()
+
+	result := collection.FindOneAndDelete(ctx, composed.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
+	}
+
+	err = composed.OnDecode().Invoke(ctx, target)
+	if err != nil {
+		return
+	}
 
 	return
 }

mongox/database/loadarray.go

@@ -31,13 +31,35 @@ func (d *Database) LoadArray(target interface{}, filters ...interface{}) (err er
 		panic(fmt.Errorf("target slice should contain ptrs"))
 	}
 
-	composed := query.Compose(filters...)
+	composed, err := query.Compose(filters...)
+	if err != nil {
+		return
+	}
+
 	zeroElem := reflect.Zero(targetSliceElemT)
-	hasPreloader, _ := composed.Preloader()
+	_, hasPreloader := composed.Preloader()
+	ctx := query.WithContext(d.Context(), composed)
 
 	var result *mongox.Cursor
 	var i int
 
+	defer func() {
+
+		if result != nil {
+			closerr := result.Close(ctx)
+			if err == nil {
+				err = closerr
+			}
+		}
+
+		invokerr := composed.OnClose().Invoke(ctx, target)
+		if err == nil {
+			err = invokerr
+		}
+
+		return
+	}()
+
 	if hasPreloader {
 		result, err = d.createAggregateLoad(zeroElem.Interface(), composed)
 	} else {
@@ -48,38 +70,49 @@ func (d *Database) LoadArray(target interface{}, filters ...interface{}) (err er
 		return
 	}
 
-	for i = 0; result.Next(d.Context()); {
+	for i = 0; result.Next(ctx); i++ {
 
 		var elem interface{}
 
-		if targetSliceV.Len() == i {
+		if i == targetSliceV.Len() {
 			value := reflect.New(targetSliceElemT.Elem())
-			err = result.Decode(value.Interface())
 			elem = value.Interface()
-			if err == nil {
+
-				targetSliceV = reflect.Append(targetSliceV, value)
+			err = composed.OnCreate().Invoke(ctx, elem)
+			if err != nil {
+				return
 			}
+
+			err = result.Decode(elem)
+			if err != nil {
+				return
+			}
+
+			targetSliceV = reflect.Append(targetSliceV, value)
 		} else {
 			elem = targetSliceV.Index(i).Interface()
-			base.Reset(elem)
+
+			if created := base.Reset(elem); created {
+				err = composed.OnCreate().Invoke(ctx, elem)
+			}
+			if err != nil {
+				return
+			}
+
 			err = result.Decode(elem)
-		}
+			if err != nil {
-		if err != nil {
+				return
-			_ = result.Close(d.Context())
+			}
-			return
 		}
 
-		err = onDecode(d.ctx, elem, composed.OnDecode()...)
+		err = composed.OnDecode().Invoke(ctx, elem)
 		if err != nil {
-			_ = result.Close(d.Context())
 			return
 		}
-
-		i++
 	}
 
 	targetSliceV = targetSliceV.Slice(0, i)
 	targetV.Elem().Set(targetSliceV)
 
-	return result.Close(d.Context())
+	return
 }

mongox/database/loadone.go

@@ -11,11 +11,33 @@ import (
 // LoadOne function loads a first single target document by a query
 func (d *Database) LoadOne(target interface{}, filters ...interface{}) (err error) {
 
-	composed := query.Compose(append(filters, query.Limit(1))...)
+	composed, err := query.Compose(append(filters, query.Limit(1))...)
-	hasPreloader, _ := composed.Preloader()
+	if err != nil {
+		return
+	}
+
+	_, hasPreloader := composed.Preloader()
+	ctx := query.WithContext(d.Context(), composed)
 
 	var result *mongox.Cursor
 
+	defer func() {
+
+		if result != nil {
+			closerr := result.Close(ctx)
+			if err == nil {
+				err = closerr
+			}
+		}
+
+		invokerr := composed.OnClose().Invoke(ctx, target)
+		if err == nil {
+			err = invokerr
+		}
+
+		return
+	}()
+
 	if hasPreloader {
 		result, err = d.createAggregateLoad(target, composed)
 	} else {
@@ -25,22 +47,28 @@ func (d *Database) LoadOne(target interface{}, filters ...interface{}) (err erro
 		return fmt.Errorf("can't create find result: %w", err)
 	}
 
-	hasNext := result.Next(d.Context())
+	hasNext := result.Next(ctx)
 	if result.Err() != nil {
-		return err
+		err = result.Err()
+		return
 	}
 	if !hasNext {
 		return mongox.ErrNoDocuments
 	}
 
-	base.Reset(target)
+	if created := base.Reset(target); created {
+		err = composed.OnCreate().Invoke(ctx, target)
+	}
+	if err != nil {
+		return
+	}
 
 	err = result.Decode(target)
 	if err != nil {
 		return
 	}
 
-	err = onDecode(d.ctx, target, composed.OnDecode()...)
+	err = composed.OnDecode().Invoke(ctx, target)
 	if err != nil {
 		return
 	}

mongox/database/loadstream.go

@@ -10,10 +10,15 @@ import (
 // LoadStream function loads documents one by one into a target channel
 func (d *Database) LoadStream(target interface{}, filters ...interface{}) (loader mongox.StreamLoader, err error) {
 
-	var cursor *mongox.Cursor
+	composed, err := query.Compose(filters...)
+	if err != nil {
+		return
+	}
 
-	composed := query.Compose(filters...)
+	_, hasPreloader := composed.Preloader()
-	hasPreloader, _ := composed.Preloader()
+	ctx := query.WithContext(d.Context(), composed)
+
+	var cursor *mongox.Cursor
 
 	if hasPreloader {
 		cursor, err = d.createAggregateLoad(target, composed)
@@ -25,7 +30,7 @@ func (d *Database) LoadStream(target interface{}, filters ...interface{}) (loade
 		return
 	}
 
-	loader = &StreamLoader{cur: cursor, ctx: d.Context(), target: target, query: composed}
+	loader = &StreamLoader{cur: cursor, ctx: ctx, ref: target, query: composed}
 
 	return
 }

mongox/database/saveone.go

@@ -1,9 +1,6 @@
 package database
 
 import (
-	"time"
-
-	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 	"go.mongodb.org/mongo-driver/mongo/options"
 
@@ -12,27 +9,52 @@ import (
 )
 
 // SaveOne saves a single source document to the database
-func (d *Database) SaveOne(source interface{}) (err error) {
+func (d *Database) SaveOne(source interface{}, filters ...interface{}) (err error) {
+
+	composed, err := query.Compose(filters...)
+	if err != nil {
+		return
+	}
 
 	collection := d.GetCollectionOf(source)
-	opts := options.FindOneAndReplace()
 	id := base.GetID(source)
 	protected := base.GetProtection(source)
-	composed := query.Compose(bson.M{"_id": id})
+	ctx := query.WithContext(d.Context(), composed)
 
+	composed.And(primitive.M{"_id": id})
+
+	opts := options.FindOneAndReplace()
 	opts.SetUpsert(true)
 	opts.SetReturnDocument(options.After)
 
 	if protected != nil {
 		query.Push(composed, protected)
-		protected.X = primitive.NewObjectID()
+		protected.Restate()
-		protected.V = time.Now().Unix()
 	}
 
-	result := collection.FindOneAndReplace(d.Context(), composed.M(), source, opts)
+	defer func() {
+		invokerr := composed.OnClose().Invoke(ctx, source)
+		if err == nil {
+			err = invokerr
+		}
+
+		return
+	}()
+
+	result := collection.FindOneAndReplace(ctx, composed.M(), source, opts)
 	if result.Err() != nil {
 		return result.Err()
 	}
 
-	return result.Decode(source)
+	err = result.Decode(source)
+	if err != nil {
+		return
+	}
+
+	err = composed.OnDecode().Invoke(ctx, source)
+	if err != nil {
+		return
+	}
+
+	return
 }

mongox/database/streamloader.go

@@ -10,21 +10,21 @@ import (
 
 // StreamLoader is a controller for a database cursor
 type StreamLoader struct {
-	cur    *mongox.Cursor
+	cur   *mongox.Cursor
-	query  *query.Query
+	query *query.Query
-	ctx    context.Context
+	ctx   context.Context
-	target interface{}
+	ref   interface{}
 }
 
-// DecodeNext loads next documents to a target or returns an error
+// DecodeNextMsg decodes the next document to an interface or returns an error
-func (l *StreamLoader) DecodeNext() (err error) {
+func (l *StreamLoader) DecodeNextMsg(i interface{}) (err error) {
 
 	err = l.Next()
 	if err != nil {
 		return
 	}
 
-	err = l.Decode()
+	err = l.DecodeMsg(i)
 	if err != nil {
 		return
 	}
@@ -32,17 +32,22 @@ func (l *StreamLoader) DecodeNext() (err error) {
 	return
 }
 
-// Decode function decodes the current cursor document into the target
+// DecodeMsg decodes the current cursor document into an interface
-func (l *StreamLoader) Decode() (err error) {
+func (l *StreamLoader) DecodeMsg(i interface{}) (err error) {
 
-	base.Reset(l.target)
+	if created := base.Reset(i); created {
-
+		err = l.query.OnDecode().Invoke(l.ctx, i)
-	err = l.cur.Decode(l.target)
+	}
 	if err != nil {
 		return
 	}
 
-	err = onDecode(l.ctx, l.target, l.query.OnDecode()...)
+	err = l.cur.Decode(i)
+	if err != nil {
+		return
+	}
+
+	err = l.query.OnDecode().Invoke(l.ctx, i)
 	if err != nil {
 		return
 	}
@@ -66,15 +71,31 @@ func (l *StreamLoader) Next() (err error) {
 	return
 }
 
+// Cursor returns the underlying cursor
 func (l *StreamLoader) Cursor() (cursor *mongox.Cursor) {
 	return l.cur
 }
 
-// Close cursor
+// Close stream loader and the underlying cursor
 func (l *StreamLoader) Close() (err error) {
-	return l.cur.Close(l.ctx)
+
+	closerr := l.cur.Close(l.ctx)
+	invokerr := l.query.OnClose().Invoke(l.ctx, l.ref)
+
+	if closerr != nil {
+		err = closerr
+		return
+	}
+
+	if invokerr != nil {
+		err = invokerr
+		return
+	}
+
+	return
 }
 
+// Err returns the last error
 func (l *StreamLoader) Err() (err error) {
 	return l.cur.Err()
 }

mongox/database/updateone.go

@@ -0,0 +1,72 @@
+package database
+
+import (
+	"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"
+)
+
+// 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
+	}
+
+	updaterDoc, err := composed.Updater()
+	if err != nil {
+		return
+	}
+
+	collection := d.GetCollectionOf(target)
+	protected := base.GetProtection(target)
+	ctx := query.WithContext(d.Context(), composed)
+
+	opts := options.FindOneAndUpdate()
+	opts.SetReturnDocument(options.After)
+
+	if protected != nil {
+		if !protected.X.IsZero() {
+			query.Push(composed, protected)
+		}
+
+		protected.Restate()
+
+		setCmd, _ := updaterDoc["$set"].(primitive.M)
+		if reflect2.IsNil(setCmd) {
+			setCmd = primitive.M{}
+		}
+		protected.PutToDocument(setCmd)
+		updaterDoc["$set"] = setCmd
+	}
+
+	defer func() {
+		invokerr := composed.OnClose().Invoke(ctx, target)
+		if err == nil {
+			err = invokerr
+		}
+
+		return
+	}()
+
+	result := collection.FindOneAndUpdate(ctx, composed.M(), updaterDoc, opts)
+	if result.Err() != nil {
+		return result.Err()
+	}
+
+	err = result.Decode(target)
+	if err != nil {
+		return
+	}
+
+	err = composed.OnDecode().Invoke(ctx, target)
+	if err != nil {
+		return
+	}
+
+	return
+}

mongox/mongox.go

@@ -22,20 +22,21 @@ type Database interface {
 	New(ctx context.Context) (db Database)
 	GetCollectionOf(document interface{}) (collection *Collection)
 	Count(target interface{}, filters ...interface{}) (count int64, err error)
-	DeleteArray(target interface{}) (err error)
+	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{}) (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
 type StreamLoader interface {
 	Cursor() (cursor *Cursor)
-	DecodeNext() (err error)
+	DecodeNextMsg(i interface{}) (err error)
-	Decode() (err error)
+	DecodeMsg(i interface{}) (err error)
 	Next() (err error)
 	Close() (err error)
 	Err() (err error)

mongox/query/callbacks.go

@@ -4,4 +4,23 @@ import (
 	"context"
 )
 
-type OnDecode func(ctx context.Context, iter interface{}) (err error)
+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
+		}
+	}
+
+	return
+}

mongox/query/compose.go

@@ -3,21 +3,26 @@ 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/utils"
 )
 
+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) {
+func Compose(filters ...interface{}) (query *Query, err error) {
 
 	query = &Query{}
 
-	for _, f := range filters {
+	for _, filter := range filters {
-		if !Push(query, f) {
+		ok, err := Push(query, filter)
-			panic(fmt.Errorf("unknown filter %v", f))
+		if err != nil {
+			return nil, fmt.Errorf("invalid filter %v, %w", filter, err)
+		}
+		if !ok {
+			panic(fmt.Errorf("unknown filter %v", filter))
 		}
 	}
 
@@ -25,29 +30,42 @@ func Compose(filters ...interface{}) (query *Query) {
 }
 
 // Push applies single filter to a query
-func Push(q *Query, f interface{}) (ok bool) {
+func Push(query *Query, filter interface{}) (ok bool, err error) {
 
-	if utils.IsNil(f) {
+	ok = reflect2.IsNil(filter)
-		return true
+	if ok {
+		return
 	}
 
-	ok = false
+	validator, hasValidator := filter.(Validator)
-	ok = ok || applyBson(q, f)
+	if hasValidator {
-	ok = ok || applyLimit(q, f)
+		err = validator.Validate()
-	ok = ok || applySort(q, f)
+	}
-	ok = ok || applySkip(q, f)
+	if err != nil {
-	ok = ok || applyProtection(q, f)
+		return
-	ok = ok || applyPreloader(q, f)
+	}
-	ok = ok || applyCallbacks(q, f)
 
-	return ok
+	for _, applier := range []applyFilterFunc{
+		applyBson,
+		applyLimit,
+		applySort,
+		applySkip,
+		applyProtection,
+		applyPreloader,
+		applyUpdater,
+		applyCallbacks,
+	} {
+		ok = applier(query, filter) || ok
+	}
+
+	return
 }
 
-// applyBson is a fallback for a custom bson.M
+// applyBson is a fallback for a custom primitive.M
-func applyBson(q *Query, f interface{}) (ok bool) {
+func applyBson(query *Query, filter interface{}) (ok bool) {
 
-	if f, ok := f.(bson.M); ok {
+	if filter, ok := filter.(primitive.M); ok {
-		q.And(f)
+		query.And(filter)
 		return true
 	}
 
@@ -55,10 +73,10 @@ func applyBson(q *Query, f interface{}) (ok bool) {
 }
 
 // applyLimits extends query with a limiter
-func applyLimit(q *Query, f interface{}) (ok bool) {
+func applyLimit(query *Query, filter interface{}) (ok bool) {
 
-	if f, ok := f.(Limiter); ok {
+	if filter, ok := filter.(Limiter); ok {
-		q.limiter = f
+		query.limiter = filter
 		return true
 	}
 
@@ -66,10 +84,10 @@ func applyLimit(q *Query, f interface{}) (ok bool) {
 }
 
 // applySort extends query with a sort rule
-func applySort(q *Query, f interface{}) (ok bool) {
+func applySort(query *Query, filter interface{}) (ok bool) {
 
-	if f, ok := f.(Sorter); ok {
+	if filter, ok := filter.(Sorter); ok {
-		q.sorter = f
+		query.sorter = filter
 		return true
 	}
 
@@ -77,61 +95,65 @@ func applySort(q *Query, f interface{}) (ok bool) {
 }
 
 // applySkip extends query with a skip number
-func applySkip(q *Query, f interface{}) (ok bool) {
+func applySkip(query *Query, filter interface{}) (ok bool) {
 
-	if f, ok := f.(Skipper); ok {
+	if filter, ok := filter.(Skipper); ok {
-		q.skipper = f
+		query.skipper = filter
 		return true
 	}
 
 	return false
 }
 
-func applyProtection(q *Query, f interface{}) (ok bool) {
+func applyProtection(query *Query, filter interface{}) (ok bool) {
 
-	var x *primitive.ObjectID
+	var keyDoc = primitive.M{}
-	var v *int64
 
-	switch f := f.(type) {
+	switch filter := filter.(type) {
 	case protection.Key:
-		x = &f.X
+		filter.PutToDocument(keyDoc)
-		v = &f.V
 	case *protection.Key:
-		x = &f.X
+		filter.PutToDocument(keyDoc)
-		v = &f.V
 
 	default:
 		return false
 	}
 
-	if x.IsZero() {
+	query.And(keyDoc)
-		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(q *Query, f interface{}) (ok bool) {
+func applyPreloader(query *Query, filter interface{}) (ok bool) {
 
-	if f, ok := f.(Preloader); ok {
+	if filter, ok := filter.(Preloader); ok {
-		q.preloader = f
+		query.preloader = filter
 		return true
 	}
 
 	return false
 }
 
-func applyCallbacks(q *Query, f interface{}) (ok bool) {
+func applyUpdater(query *Query, filter interface{}) (ok bool) {
 
-	switch cb := f.(type) {
+	if filter, ok := filter.(Updater); ok {
-	case OnDecode:
+		query.updater = filter
-		q.ondecode = append(q.ondecode, cb)
+		return true
-		ok = true
 	}
 
-	return
+	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/context.go

@@ -0,0 +1,19 @@
+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)
+	return
+}
+
+// WithContext function creates the new context with request data
+func WithContext(ctx context.Context, q *Query) (withQuery context.Context) {
+	withQuery = context.WithValue(ctx, ctxQueryKey{}, q)
+	return
+}

mongox/query/query.go

@@ -1,30 +1,36 @@
 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"
 )
 
-// Query is an enchanched bson.M map
+// Query is an enchanched primitive.M map
 type Query struct {
-	m         bson.M
+	m         primitive.M
 	limiter   Limiter
 	sorter    Sorter
 	skipper   Skipper
 	preloader Preloader
-	ondecode  []OnDecode
+	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 bson.M) (query *Query) {
+func (q *Query) And(elem primitive.M) (query *Query) {
 
 	if q.m == nil {
-		q.m = bson.M{}
+		q.m = primitive.M{}
 	}
 
-	queries, exists := q.m["$and"].(bson.A)
+	queries, exists := q.m["$and"].(primitive.A)
 
 	if !exists {
-		q.m["$and"] = bson.A{elem}
+		q.m["$and"] = primitive.A{elem}
 		return q
 	}
 
@@ -63,11 +69,43 @@ 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 {
+		update = primitive.M{}
+		return
+	}
+
+	update = q.updater.Update()
+
+	if reflect2.IsNil(update) {
+		update = primitive.M{}
+		return
+	}
+
+	buffer := bytebufferpool.Get()
+	defer bytebufferpool.Put(buffer)
+
+	// convert update document to bson map values
+	bsonBytes, err := bson.MarshalAppend(buffer.B, update)
+	if err != nil {
+		return
+	}
+	update = primitive.M{}
+	err = bson.Unmarshal(bsonBytes, update)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
 // Preloader is a preloader list for a query
-func (q *Query) Preloader() (ok bool, preloads []string) {
+func (q *Query) Preloader() (preloads []string, ok bool) {
 
 	if q.preloader == nil {
-		return false, nil
+		return nil, false
 	}
 
 	preloads = q.preloader.Preload()
@@ -77,16 +115,26 @@ func (q *Query) Preloader() (ok bool, preloads []string) {
 }
 
 // OnDecode callback is called after the mongo decode function
-func (q *Query) OnDecode() (callbacks []OnDecode) {
+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) {
 	return len(q.m) == 0
 }
 
 // M returns underlying query map
-func (q *Query) M() (m bson.M) {
+func (q *Query) M() (m primitive.M) {
 	return q.m
 }

mongox/query/sort.go

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

mongox/query/update.go

@@ -0,0 +1,20 @@
+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

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

mongox/utils/isnil.go

@@ -1,23 +0,0 @@
-package utils
-
-import (
-	"unsafe"
-)
-
-// IsNil function evaluates the interface value to nil
-func IsNil(i interface{}) (isNil bool) {
-
-	type iface struct {
-		_   unsafe.Pointer
-		ptr unsafe.Pointer
-	}
-
-	unpacked := (*iface)(unsafe.Pointer(&i))
-	if unpacked.ptr == nil {
-		isNil = true
-		return
-	}
-
-	isNil = *(*unsafe.Pointer)(unpacked.ptr) == nil
-	return
-}

mongox/utils/isnil_test.go

@@ -1,32 +0,0 @@
-package utils
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestIsNil(t *testing.T) {
-
-	testvalues := []struct {
-		i     interface{}
-		isnil bool
-	}{
-		{nil, true},
-		{(*string)(nil), true},
-		{([]string)(nil), true},
-		{(map[string]string)(nil), true},
-		{(func() bool)(nil), true},
-		{(chan func() bool)(nil), true},
-		{"", true},
-		{0, true},
-		{append(([]string)(nil), ""), false},
-		{[]string{}, false},
-		{1, false},
-		{"1", false},
-	}
-
-	for _, tt := range testvalues {
-		assert.Equal(t, tt.isnil, IsNil(tt.i))
-	}
-}