🥗 Recipe Book rollup ​

func (k msgServer) CreateRecipe(goCtx context.Context, msg *types.MsgCreateRecipe) (*types.MsgCreateRecipeResponse, error) {
  // Get the context
  ctx := sdk.UnwrapSDKContext(goCtx)

  // Create variable of type Recipe
  var recipe = types.Recipe{
     Creator: msg.Creator,
     Dish: msg.Dish,
     Ingredients: msg.Ingredients,
  }

  // Add a recipe to the store and get back the ID
  id := k.AppendRecipe(ctx, recipe)

  // Return the ID of the recipe
  return &types.MsgCreateRecipeResponse{Id: id}, nil
}

syntax = "proto3";

package recipes.recipes;

option go_package = "recipes/x/recipes/types";

message Recipe {
  string creator = 1;
  uint64 id = 2;
  string dish = 3; 
  string ingredients = 4; 
}

package keeper

import (
  "encoding/binary"

  "cosmossdk.io/store/prefix"
  "github.com/cosmos/cosmos-sdk/runtime"
  sdk "github.com/cosmos/cosmos-sdk/types"

  "recipes/x/recipes/types"
)

// func (k Keeper) AppendRecipe() uint64 {
//    count := k.GetRecipeCount()
//    store.Set()
//    k.SetRecipeCount()
//    return count
// }

const (
  //...

  // Keep track of the index of recipes  
  RecipeKey      = "Recipe-value-"
  RecipeCountKey = "Recipe-count-"
)

func (k Keeper) GetRecipeCount(ctx sdk.Context) uint64 {
  // Get the store using storeKey (which is "recipes") and RecipeCountKey (which is "Recipe-count-")
  storeAdapter := runtime.KVStoreAdapter(k.storeService.OpenKVStore(ctx))
  store := prefix.NewStore(storeAdapter, []byte(types.RecipeCountKey))
  
  // Convert the RecipeCountKey to bytes
  byteKey := []byte(types.RecipeCountKey)
  
  // Get the value of the count
  bz := store.Get(byteKey)
  
  // Return zero if the count value is not found (for example, it's the first recipe)
  if bz == nil {
    return 0
  }
  
  // Convert the count into a uint64
  return binary.BigEndian.Uint64(bz)
}

func (k Keeper) SetRecipeCount(ctx sdk.Context, count uint64) {
  // Get the store using storeKey (which is "recipes") and RecipeCountKey (which is "Recipe-count-")
  storeAdapter := runtime.KVStoreAdapter(k.storeService.OpenKVStore(ctx))
  store := prefix.NewStore(storeAdapter, []byte(types.RecipeCountKey))
  
  // Convert the RecipeCountKey to bytes
  byteKey := []byte(types.RecipeCountKey)
  
  // Convert count from uint64 to string and get bytes
  bz := make([]byte, 8)
  binary.BigEndian.PutUint64(bz, count)
  
  // Set the value of Recipe-count- to count
  store.Set(byteKey, bz)
}

func (k Keeper) AppendRecipe (ctx sdk.Context, recipe types.Recipe) uint64 {
  // Get the current number of recipes in the store
  count := k.GetRecipeCount(ctx)
  
  // Assign an ID to the recipe based on the number of recipes in the store
  recipe.Id = count
  
  // Get the store
  storeAdapter := runtime.KVStoreAdapter(k.storeService.OpenKVStore(ctx))
  store := prefix.NewStore(storeAdapter, []byte(types.RecipeKey))
  
  // Convert the recipe ID into bytes
  byteKey := make([]byte, 8)
  binary.BigEndian.PutUint64(byteKey, recipe.Id)
  
  // Marshal the recipe into bytes
  appendedValue := k.cdc.MustMarshal(&recipe)
  
  // Insert the recipe bytes using recipe ID as a key
  store.Set(byteKey, appendedValue)
  
  // Update the recipe count
  k.SetRecipeCount(ctx, count+1)
  return count
}

package keeper

import (
  "context"
  "github.com/cosmos/cosmos-sdk/store/prefix"
  sdk "github.com/cosmos/cosmos-sdk/types"
  "github.com/cosmos/cosmos-sdk/types/query"
  "google.golang.org/grpc/codes"
  "google.golang.org/grpc/status"

  "recipes/x/recipes/types"
)

func (k Keeper) Dishes(c context.Context, req *types.QueryDishesRequest) (*types.QueryDishesResponse, error) {
  // Throw an error if request is nil
  if req == nil {
    return nil, status.Error(codes.InvalidArgument, "invalid request")
  }

  // Define a variable that will store a list of recipes
  var dishes []*types.Recipe

  // Get context with the information about the environment
  ctx := sdk.UnwrapSDKContext(c)

  // Get the key-value module store using the store key (in our case store key is "chain")
  storeAdapter := runtime.KVStoreAdapter(k.storeService.OpenKVStore(ctx))

  // Get the part of the store that keeps recipes (using recipe key, which is "Recipe-value-")
  recipeStore := prefix.NewStore(storeAdapter, []byte(types.RecipeKey))

  // Paginate the recipes store based on PageRequest
  pageRes, err := query.Paginate(recipeStore, req.Pagination, func(key []byte, value []byte) error {
    var dish types.Recipe
    if err := k.cdc.Unmarshal(value, &dish); err != nil {
      return err
    }

    dishes = append(dishes, &dish)

    return nil
  })

  // Throw an error if pagination failed
  if err != nil {
    return nil, status.Error(codes.Internal, err.Error())
  }

  // Return a struct containing a list of recipes and pagination info
  return &types.QueryDishesResponse{Recipe: dishes, Pagination: pageRes}, nil
}