From e09e0ff5b357782c8470060521cfb8399fb3c25a Mon Sep 17 00:00:00 2001 From: Masaaki Goshima Date: Wed, 24 Mar 2021 18:50:01 +0900 Subject: [PATCH] add draft design --- _example/draft-query.go | 89 +++++++++++++++++++++++++++++++++++++++++ encode.go | 21 ++++++++++ json.go | 8 ++++ query.go | 71 ++++++++++++++++++++++++++++++++ 4 files changed, 189 insertions(+) create mode 100644 _example/draft-query.go create mode 100644 query.go diff --git a/_example/draft-query.go b/_example/draft-query.go new file mode 100644 index 0000000..2db94b2 --- /dev/null +++ b/_example/draft-query.go @@ -0,0 +1,89 @@ +package main + +import ( + "fmt" + + "github.com/goccy/go-json" +) + +type User struct { + ID int64 + Name string + Age int + Address UserAddressResolver +} + +type UserAddress struct { + UserID int64 + PostCode string + City string + Address1 string + Address2 string +} + +type UserAddressResolver func() (*UserAddress, error) + +func (resolver UserAddressResolver) MarshalJSON() ([]byte, error) { + address, err := resolver() + if err != nil { + return nil, err + } + return json.Marshal(address) +} + +func (resolver UserAddressResolver) ResolveQueryJSON(q *json.Query) (interface{}, error) { + // validate or rewrite json.Query + // + address, err := resolver() + if err != nil { + return nil, err + } + return address, nil +} + +type UserRepository struct{} + +func (r UserRepository) FindByID(id int64) (*User, error) { + v := User{ID: id, Name: "Ken", Age: 20} + // resolve relation from User to UserAddress + uaRepo := new(UserAddressRepository) + v.Address = func() (*UserAddress, error) { + return uaRepo.FindByUserID(v.ID) + } + return v, nil +} + +type UserAddressRepository struct{} + +func (r UserAddressRepository) FindByUserID(id int64) (*UserAddress, error) { + return &UserAddress{UserID: id, City: "A", Address1: "hoge", Address2: "fuga"}, nil +} + +func main() { + user, err := new(UserRepository).FindByID(1) + if err != nil { + panic(err) + } + { + b, err := json.Marshal(user) + if err != nil { + panic(err) + } + fmt.Println(string(b)) + } + { + //json.QueryFromJSON(`["Name", "Age", { "Address": [ "City" ] }]`) + q := json.NewQuery().Fields( + "Name", + "Age", + json.NewQuery("Address").Fields( + "City", + ), + ) + b, err := json.MarshalWithQuery(user, q) + if err != nil { + panic(err) + } + fmt.Println(string(b)) + } +} diff --git a/encode.go b/encode.go index 4dfdd2c..7e1afd0 100644 --- a/encode.go +++ b/encode.go @@ -148,6 +148,27 @@ func marshal(v interface{}, opt EncodeOption) ([]byte, error) { return copied, nil } +func marshalQuery(v interface{}, q *Query) ([]byte, error) { + ctx := takeEncodeRuntimeContext() + + buf, err := encode(ctx, v, EncodeOptionHTMLEscape) + if err != nil { + releaseEncodeRuntimeContext(ctx) + return nil, err + } + + // this line exists to escape call of `runtime.makeslicecopy` . + // if use `make([]byte, len(buf)-1)` and `copy(copied, buf)`, + // dst buffer size and src buffer size are differrent. + // in this case, compiler uses `runtime.makeslicecopy`, but it is slow. + buf = buf[:len(buf)-1] + copied := make([]byte, len(buf)) + copy(copied, buf) + + releaseEncodeRuntimeContext(ctx) + return copied, nil +} + func marshalNoEscape(v interface{}, opt EncodeOption) ([]byte, error) { ctx := takeEncodeRuntimeContext() diff --git a/json.go b/json.go index 3d879d0..c753500 100644 --- a/json.go +++ b/json.go @@ -13,6 +13,10 @@ type Marshaler interface { MarshalJSON() ([]byte, error) } +type QueryResolver interface { + ResolveQueryJSON(*Query) (interface{}, error) +} + // Unmarshaler is the interface implemented by types // that can unmarshal a JSON description of themselves. // The input can be assumed to be a valid encoding of @@ -172,6 +176,10 @@ func MarshalWithOption(v interface{}, optFuncs ...EncodeOptionFunc) ([]byte, err return marshal(v, opt) } +func MarshalWithQuery(v interface{}, q *Query) ([]byte, error) { + return marshalQuery(v, q) +} + // MarshalIndent is like Marshal but applies Indent to format the output. // Each JSON element in the output will begin on a new line beginning with prefix // followed by one or more copies of indent according to the indentation nesting. diff --git a/query.go b/query.go new file mode 100644 index 0000000..fd80bfd --- /dev/null +++ b/query.go @@ -0,0 +1,71 @@ +package json + +import "fmt" + +type Query struct { + query *subQuery + err error +} + +func (q *Query) String() string { + if q.err != nil { + return "" + } + if q.query == nil { + return "" + } + b, err := Marshal(q.query.dump()) + if err != nil { + return "" + } + return string(b) +} + +func (q *Query) Error() error { + return q.err +} + +func (q *Query) Fields(fieldNameOrQueryList ...interface{}) *Query { + for _, fieldNameOrQuery := range fieldNameOrQueryList { + switch v := fieldNameOrQuery.(type) { + case string: + q.fields = append(q.fields, &subQuery{name: v}) + case *Query: + q.fields = append(q.fields, v.query) + q.err = v.err + default: + q.err = fmt.Errorf("children types must be string or *Query but found %T", fieldNameOrQuery) + } + if q.err != nil { + break + } + } + return q +} + +func NewQuery(name ...string) *Query { + if len(name) > 1 { + return &Query{err: fmt.Errorf( + "NewQuery's argument allow empty or single name only, but passed %v", name, + )} + } + return &Query{query: &subQuery{name: name}} +} + +type subQuery struct { + name string + fields []*subQuery +} + +func (q *subQuery) dump() interface{} { + fields := []interface{}{} + for _, field := range q.fields { + fields = append(fields, field.dump()) + } + if q.name != "" { + return map[string][]interface{}{ + q.name: fields, + } + } + return interface{}(fields) +}