What is the proper way to create entities?

[nicolasguasca1]

I want to setup the list of entities I need for my project. My contracts have events for multiple actions that occur inside the functions. Some of these events index the values that belong to structs and the events are used as a way to keep a record on when, what and by who are these struct values updated.

I have designed my entire set of contracts in this way so please let me know if this approach is not correct and why.

Then, take the following example of my project:

struct Admin {
    uint256 identifier;
    bytes32 adminName;
    address registry; // The contract address that the admin is associated with
    State organizerProxyState; // Defaults to "created"
}

event AdminCreation(
    uint256 indexed identifier,
    address indexed modifierAccount,
    bytes32 indexed adminName,
    uint256 blockTimeStamp
  ); 

I see from The Graph docs that a bad example for entity setting is:

type GravatarAccepted @entity {
id: Bytes!
owner: Bytes
displayName: String
imageUrl: String
}

type GravatarDeclined @entity {
id: Bytes!
owner: Bytes
displayName: String
imageUrl: String
}

Docs also say that creating entities for every single event is not a good practice. This means that having a "type AdminCreation @entity..." is not a good idea and instead it should be "type Admin @entity..." Correct?

However, when talking about the mappings, this example is presented as valid:

import { NewGravatar, UpdatedGravatar } from '../generated/Gravity/Gravity'
import { Gravatar } from '../generated/schema'

export function handleNewGravatar(event: NewGravatar): void {
  let gravatar = new Gravatar(event.params.id)
  gravatar.owner = event.params.owner
  gravatar.displayName = event.params.displayName
  gravatar.imageUrl = event.params.imageUrl
  gravatar.save()
}

export function handleUpdatedGravatar(event: UpdatedGravatar): void {
  let id = event.params.id
  let gravatar = Gravatar.load(id)
  if (gravatar == null) {
    gravatar = new Gravatar(id)
  }
  gravatar.owner = event.params.owner
  gravatar.displayName = event.params.displayName
  gravatar.imageUrl = event.params.imageUrl
  gravatar.save()
}

This means that the schema.ts should indeed export the object class that contains the info of the struct (Gravatar) and is mapped taking into account the what the events typed (NewGravatar, UpdatedGravatar) bring.

My questions:

1. Should I have on my schema.graphql ONLY information about the structs that the events will eventually be modifying?
2. How do I track the events that report information on changes that don't affect struct but information of variables inside the contract e.g:

address managerAccount
event managerChange( adress indexed walletExecuting, address indexed newManager)

[azf20]

Hey @nicolasguasca1, thanks for trying out subgraphs! Your schema should reflect whatever data it is that you need from your subgraph. If you need to track variables inside the contract, you can create corresponding entities in the schema.graphql, and if you want to track the events which changed entities (which is indeed a valid use case in some cases!) then you should do that.