From 69cf8f7b5639bc27d96113da10e71d9410f45294 Mon Sep 17 00:00:00 2001 From: Roy Crihfield Date: Thu, 19 Oct 2023 08:47:21 -0500 Subject: [PATCH] encoding of query attrs --- x/registry/keeper/grpc_query_test.go | 5 +- x/registry/keeper/keeper.go | 87 +++++++++++++++++++++------- x/registry/types/types.go | 13 ++++- 3 files changed, 80 insertions(+), 25 deletions(-) diff --git a/x/registry/keeper/grpc_query_test.go b/x/registry/keeper/grpc_query_test.go index c28c6a72..6c20e1c8 100644 --- a/x/registry/keeper/grpc_query_test.go +++ b/x/registry/keeper/grpc_query_test.go @@ -3,12 +3,13 @@ package keeper_test import ( "context" "fmt" + "os" + "reflect" + "github.com/cerc-io/laconicd/x/registry/client/cli" "github.com/cerc-io/laconicd/x/registry/helpers" "github.com/cerc-io/laconicd/x/registry/keeper" registrytypes "github.com/cerc-io/laconicd/x/registry/types" - "os" - "reflect" ) func (suite *KeeperTestSuite) TestGrpcQueryParams() { diff --git a/x/registry/keeper/keeper.go b/x/registry/keeper/keeper.go index bfc94166..fc3f2d60 100644 --- a/x/registry/keeper/keeper.go +++ b/x/registry/keeper/keeper.go @@ -22,7 +22,10 @@ import ( paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" "github.com/tendermint/tendermint/libs/log" + cid "github.com/ipfs/go-cid" + "github.com/ipld/go-ipld-prime" "github.com/ipld/go-ipld-prime/codec/dagjson" + cidlink "github.com/ipld/go-ipld-prime/linking/cid" basicnode "github.com/ipld/go-ipld-prime/node/basic" ) @@ -147,10 +150,20 @@ func (k Keeper) ListRecords(ctx sdk.Context) []types.Record { // RecordsFromAttributes gets a list of records whose attributes match all provided values func (k Keeper) RecordsFromAttributes(ctx sdk.Context, attributes []*types.QueryListRecordsRequest_KeyValueInput, all bool) ([]types.Record, error) { + log := logger(ctx).With("function", "RecordsFromAttributes") + resultRecordIds := []string{} for i, attr := range attributes { - val := GetAttributeValue(attr.Value) + val, err := EncodeAttributeValue2(attr.Value) + if err != nil { + return nil, err + } attributeIndex := GetAttributesIndexKey(attr.Key, val) + log.Debug("attribute index", + "key", attr.Key, + "value", val, + "value_type", fmt.Sprintf("%T", val), + "index", attributeIndex) recordIds, err := k.GetAttributeMapping(ctx, attributeIndex) if err != nil { return nil, err @@ -178,27 +191,38 @@ func (k Keeper) RecordsFromAttributes(ctx sdk.Context, attributes []*types.Query return records, nil } -func GetAttributeValue(input *types.QueryListRecordsRequest_ValueInput) interface{} { +// TODO non recursive +func EncodeAttributeValue2(input *types.QueryListRecordsRequest_ValueInput) ([]byte, error) { + np := basicnode.Prototype.Any + nb := np.NewBuilder() + switch value := input.GetValue().(type) { case *types.QueryListRecordsRequest_ValueInput_String_: - return value.String_ + nb.AssignString(value.String_) case *types.QueryListRecordsRequest_ValueInput_Int: - return value.Int + nb.AssignInt(value.Int) case *types.QueryListRecordsRequest_ValueInput_Float: - return value.Float + nb.AssignFloat(value.Float) case *types.QueryListRecordsRequest_ValueInput_Boolean: - return value.Boolean + nb.AssignBool(value.Boolean) case *types.QueryListRecordsRequest_ValueInput_Link: - return value.Link + link := cidlink.Link{Cid: cid.MustParse(value.Link)} + nb.AssignLink(link) case *types.QueryListRecordsRequest_ValueInput_Array: - return value.Array + // TODO case *types.QueryListRecordsRequest_ValueInput_Map: - return value.Map - case nil: - return nil + // TODO default: - return fmt.Errorf("Value has unepxpected type %T", value) + return nil, fmt.Errorf("Value has unepxpected type %T", value) } + + n := nb.Build() + var buf bytes.Buffer + if err := dagjson.Encode(n, &buf); err != nil { + return nil, err + } + value := buf.Bytes() + return value, nil } func getIntersection(a []string, b []string) []string { @@ -341,22 +365,43 @@ func (k Keeper) PutRecord(ctx sdk.Context, record types.Record) { k.updateBlockChangeSetForRecord(ctx, record.Id) } -func (k Keeper) processAttributes(ctx sdk.Context, attrs map[string]any, id string, prefix string) error { - np := basicnode.Prototype.Any // Pick a stle for the in-memory data. - nb := np.NewBuilder() // Create a builder. - err := dagjson.Decode(nb, bytes.NewReader(content)) // Hand the builder to decoding -- decoding will fill it in! +func (k Keeper) processAttributes(ctx sdk.Context, attrs []byte, id string, prefix string) error { + np := basicnode.Prototype.Map + nb := np.NewBuilder() + err := dagjson.Decode(nb, bytes.NewReader(attrs)) if err != nil { - return "", err + return err } - n := nb.Build() // Call 'Build' to get the resulting Node. (It's immutable!) + n := nb.Build() + if n.Kind() != ipld.Kind_Map { + return fmt.Errorf("Record attributes must be a map, not %T", n.Kind()) + } + return k.processAttributeMap(ctx, n, id, prefix) +} - for key, value := range attrs { - if subRecord, ok := value.(map[string]any); ok { - err := k.processAttributes(ctx, subRecord, id, key) +func (k Keeper) processAttributeMap(ctx sdk.Context, n ipld.Node, id string, prefix string) error { + for it := n.MapIterator(); !it.Done(); { + keynode, valuenode, err := it.Next() + if err != nil { + return err + } + key, err := keynode.AsString() + if err != nil { + return err + } + + // for key, value := range attrs { + if valuenode.Kind() == ipld.Kind_Map { + err := k.processAttributeMap(ctx, valuenode, id, key) if err != nil { return err } } else { + var buf bytes.Buffer + if err := dagjson.Encode(valuenode, &buf); err != nil { + return err + } + value := buf.Bytes() indexKey := GetAttributesIndexKey(prefix+key, value) if err := k.SetAttributeMapping(ctx, indexKey, id); err != nil { return err diff --git a/x/registry/types/types.go b/x/registry/types/types.go index a9e31815..f737a5a1 100644 --- a/x/registry/types/types.go +++ b/x/registry/types/types.go @@ -13,6 +13,16 @@ const ( AuthorityUnderAuction = "auction" ) +// TODO if schema records are to be more permissive than allowing a map of fields, this type will +// become specific to content records. schema records will either occupy a new message or have new +// more general purpose helper types. + +type DagJsonBlob []byte + +func (b DagJsonBlob) MarshalJSON() ([]byte, error) { + return b, nil +} + // ReadablePayload represents a signed record payload that can be serialized from/to YAML. type ReadablePayload struct { Record map[string]interface{} `json:"record"` @@ -44,7 +54,6 @@ func (payloadObj *ReadablePayload) ToPayload() Payload { }, Signatures: payloadObj.Signatures, } - // TODO rm error return payload } @@ -96,7 +105,7 @@ func (r *ReadableRecord) ToRecordObj() (Record, error) { func (r *ReadableRecord) CanonicalJSON() []byte { bytes, err := canonicalJson.Marshal(r.Attributes) if err != nil { - panic("Record marshal error.") + panic("Record marshal error: " + err.Error()) } return bytes