The comments attribute serves as an aggregator on the vertices. Suppose we need information about the child comments on both the Post and Comment vertex in the metadata. Depending on the scale, it would be more efficient to store an aggregator and use it to find the information about the number of child comments. However, we must increment comments of the parent by 1 whenever a new child comment is created.

User:

I did not place any attributes on the edges for now. You are free to add attributes that are beneficial to your case. Now that we have our schema ready to go, let’s save our changes and move onto writing the queries.

Let’s write a query to create a new post based on the incoming post id (post) and by the author (user). Let’s also do the same for comments. If a new comment is created as either a response to a Post (createCommentsOnPost) or as a response to a Comment(createReplyToComment), we must increment the attribute comments of the parent by 1.

CREATE QUERY createPost(Vertex<User> user, String post) FOR GRAPH MyGraph { 
  Insert Into Post(PRIMARY_ID, comments) Values(post, 0);
  Insert Into CREATES_POST(From, To) Values(user User, post Post);
}
CREATE QUERY createCommentOnPost(Vertex<User> user, Vertex<Post> parent, String comment) FOR GRAPH MyGraph { 
  parent.comments = parent.comments + 1;
  Insert Into Comment(PRIMARY_ID, comments) Values(comment, 0);
  Insert Into IS_CHILD_OF_POST(From, To) Values(comment Comment,      parent Post);
  Insert Into CREATES_COMMENT(From, To) Values(user User, comment Comment);
}
CREATE QUERY createReplyOnComment(Vertex<User> user, Vertex<Comment> parent, String comment) FOR GRAPH MyGraph { 
  parent.comments = parent.comments + 1;
  Insert Into Comment(PRIMARY_ID, comments) Values(comment, 0);
  Insert Into IS_CHILD_OF_COMMENT(From, To) Values(comment Comment, parent Comment);
  Insert Into CREATES_COMMENT(From, To) Values(user User, comment Comment);
}

const express = require("express");
const app = express();
const config = require("./config");


app.use(express.json()); 

/*
All the parameters to the endpoints below will simply be passed as a object in the body.
This is easily customizable.
*/
app.get("/comments", async (req, res)=>{
    try{
        let body = req.body;
        let url = config.url + "getCommentMetadata";
        let response = await _makeCall(url, body);
        res.status(200).send(response);
    }
    catch(error){
        handleError(res, error.message);
    }
});

app.get("/posts", async (req, res) => {
    try{
        let body = req.body;
        let url = config.url + "getPostMetadata";
        let response = await _makeCall(url, body);
        res.status(200).send(response);
    }   
    catch(error){
        handleError(res, error.message);
    }
});

app.post("/toggle-like-post", async (req, res) => {
    try{
        let body = req.body;
        let url = config.url + "toggleLikesOnPost";
        let response = await _makeCall(url, body);
        res.status(200).send(response);
    }
    catch(error){
        handleError(res, error.message);
    }
});

app.post("/toggle-like-comment", async (req, res) =>{
    try{
        let body = req.body;
        let url = config.url + "toggleLikesOnComment";
        let response = await _makeCall(url, body);
        res.status(200).send(response);
    }
    catch(error){
        handleError(res, error.message);
    }
});

app.post("/create-child", async (req, res) => {
    try{    
        let body = req.body;
        let url = config.url;
        if("post" in body){
            url += "createCommentOnPost";
        }
        else{
            url += "createReplyOnComment";
        }
        let response = await _makeCall(url, body);
        res.status(200).send(response);
    }   
    catch(error){
        handleError(res, error.message);
    }
});

app.post("/create-post", async (req, res)=>{
    try{
        let body = req.body;
        let url = config.url + "createPost";
        let response = await _makeCall(url, body);
        res.status(200).send(response);
    }
    catch(error){
        handleError(res, error.message);
    }

});

/*
This is where the magic happens. Each of the end points will pass in a query url
with an object of parameters. This function will construct the url and make the call.
*/
async function _makeCall(url, params){
    try{
        const keys = Object.keys(params);
        if (keys.length > 0) {
          url += "?"
          for (let index = 0; index < keys.length; index++) {
            const key = keys[index];
            if (Array.isArray(params[key])) { //It was an array of values
              let heading = `${key}=`;
              if (index > 0) {
                heading = `&${key}=`;
              }
              url += heading;
              url += (params[key]).join(`&${key}=`);
            } else { //It was just a single value
              if (index === 0) {
                url += key + "=" + params[key]
              } else {
                url += "&" + key + "=" + params[key]
              }
            }
          }
        }
        const token = config.token;
        const response = await fetch(url, {
                method: 'GET',
                headers: {
                    'Authorization': 'Bearer ' + token,
                    'Accept': 'application/json',
                    'Content-Type': 'application/json',
                }
        });
        const json = await response.json();
        if(json.error){
            throw Error("TigerGraphError:" + json.message);
        }
        return json;  
    }
    catch(error){
        throw Error(error.message);
    }
}

function handleError(res, errorMessage){
    if(errorMessage.indexOf("TigerGraphError") > 0){
        res.status(500).send({error:true, message:errorMessage})
    }
    else{
        res.status(400).send({error:true, message:errorMessage})
    }
}

Disadvantages

Maintenance: If a new TigerGraph instance is spun up, then an another database must be maintained.In my case, calls must be made to both Firestore when retrieving comments or posts, creating comments or posts as well deleting.

Advantages

Insights: The core relationship data between the entities will already be stored on the Graph itself, making various algorithms for perhaps finding Community groups between users or Influencers readily available.

Conclusion

More edges, vertices, and attributes can be added to schema to improve its design. What I have showed you today is simply a starting point. Please let me know if you liked or disliked some part of the article and how I can improve. Thank you very much for reading!