## text/plain MIME Type and Python

When you do echo "x" > my_file and then check its MIME type using file --mime-type my_file it would say text/plain. But, when you do the same in Python by

with open("my_file_2", "w") as fp:
fp.write("x")


and then check the MIME type it would say application/octet-stream. What’s the difference?

### For the impatient

echo adds a new line to file which tells the file utility it is a text file.

### For the curious

When I saw this question on StackOverflow, I was really stumped due to the following reasons:

1. I didn’t know the file utility can be used to get the mime-type of the file. I thought MIME Type is only relevant in the context of web server and clients. After all, MIME stands for Multipurpose Internet Mail Extensions
2. I thought operating systems usually use the file extension to decide the file type, by extension the mime type. Don’t the OSes warn when we touch the extension part of the files while renaming, all the time? So, how does file utility do this on a files without any extension?

$echo "x" > some_file.txt$ file --mime-type some_file.txt
some_file.txt: text/plain


Okay, that’s all good. Now to the Python side:

with open("some_file_2.txt", "w") as fp:
fp.write("x")

$file --mime-type some_file_2.txt some_file_2.txt: application/octet-stream  What? file doesn’t recognise file extensions? ### The OS conspiracy theory Maybe echo writes the mimetype as a metadata onto the disk because echo is a system utility and it knows to do that and in Python the user (me) doesn’t know how to? Clearly the operating system utilities are a cabal of some forbidden knowledge. And I am going to uncover that today, starting with the file utility which seems to have different answers to different programs. ### How does ‘file’ determine MIME Type? Answers to this question has some useful information: How do you change the MIME type of a file from the terminal? 1. MIME Type is a fictional value. There is no inherent metadata field that stores MIME Types of files. 2. Each operating system uses a different technique to decide file type. Windows uses file extension, Mac OS uses type creator & type codes and Unix uses magic numbers. 3. The file command guesses file type by reading the content and looking for magic numbers and strings. ### Time to reveal the magic Let us peer into the souls of these files in their purest forms where there is no magic but only 1s and 0s. So, I printed the binary representation of the two files. $ xxd -b my_file
00000000: 01111000 00001010 x.

$xxd -b my_file_2 00000000: 01111000 x  The file generated by echo has two bytes (notice the . after the x) whereas the file I created with Python only has one byte. What is that second byte? >>> number = int('00001010', 2) >>> chr(number) '\n'  And it turns out like every movie on magic, there is no such thing as magic. Just clever people putting new lines to tell file it is a text file. ### Creating a trick Now that the trick is revealed, lets create our own magic trick $ echo "<file></file>" > xml_file
$file --mime-type xml_file xml_file: text/plain$ echo "<?xml version="1.0"?><file></file>" > xml_file
$file --mime-type xml_file xml_file: text/xml  ### Useful Links ## Jupyter – Finding the point when a line graph crosses the threshold A friend of came up with the problem. There are a set of points [(x, y), (x1, y1), (x2, …]. He wanted to find the points at which this line would pass the value Z less than the peak. If the maximum value is 100 and Z = 20. He wanted to find the points where it would cross y = 80. Now there are multiple ways to solve this problem. I attempted a simple linear interpolation solution. I don’t the solution itself to be a big thing. What I am really impressed is, how neatly I was able to present the solution using Jupyter Notebook to him. I was able to document the solution in a step by step fashion, with visual representation of how I solved it. Take a look from IPython.display import display import matplotlib.pyplot as plt f = [100, 102, 103.5, 105.5, 106.5, 107.5, 108.5, 110] mag = [0, 30, 40, 145.3, 166.5, 164.5, 75.79, 65.3] fig, ax = plt.subplots() ax.plot(f, mag) for x,y in zip(f, mag): label = ax.text(x, y, y) fig.tight_layout()  gap = 30 # 1. Find the maximum value max_mag = max(mag) # 2. Set the threshold value y = max_mag - gap ax.hlines(y, f[0], f[-1], linewidth=0.5, color="cyan") display(fig)  max_idx = mag.index(max_mag) # 4. Find the left and right values which are lower than the "y" you are looking for left_start_idx = None left_end_idx = max_idx right_start_idx = max_idx right_end_idx = None for i in range(max_idx): left_idx = max_idx - i right_idx = max_idx + i # if left index is more than Zero (array left most is 0) and left is not yet set if left_idx >= 0 and not left_start_idx: value = mag[left_idx] # if the value is lower than our threshold then pickup the point # and the one next to it # that will form our segment to interoploate if value < y: left_start_idx = left_idx left_end_idx = left_idx + 1 # if the right index is less than our array size (0..N) and right is not yet set if right_idx < len(mag) and not right_end_idx: value = mag[right_idx] if value < y: right_end_idx = right_idx right_start_idx = right_idx - 1 if not right_end_idx: print("Cannot find point on the right lower than %d" % (y)) if not left_start_idx: print("Cannot find point on the left lower than %d" % (y)) # Plotting the lines we will be interpolating if left_mag and right_mag: ax.plot( [f[left_start_idx], f[left_end_idx]], [mag[left_start_idx], mag[left_end_idx]], color='red' ) ax.plot( [f[right_start_idx], f[right_end_idx]], [mag[right_start_idx], mag[right_end_idx]], color='red' ) display(fig)  #### Now Let us use the line equation $\frac{y - y1}{x - x1} = \frac{y2 - y1}{x2 - x1}$ Solving for x we get $x = x1 + (x2 - x1) \frac{y - y1}{y2 - y1}$ # Left point interpolation y1 = mag[left_start_idx] y2 = mag[left_end_idx] x1 = f[left_start_idx] x2 = f[left_end_idx] x = x1 + (x2 - x1) * (y - y1) / (y2 - y1) ax.scatter([x], [y], color="green") display(fig)  # Right point interpolation y1 = mag[right_start_idx] y2 = mag[right_end_idx] x1 = f[right_start_idx] x2 = f[right_end_idx] x = x1 + (x2 - x1) * (y - y1) / (y2 - y1) ax.scatter([x], [y], color="green") display(fig)  I was able to export the whole thing as a PDF and send it to him. ## Simplifying a Factory Pattern function that has grown complex This is a combination of the problem that I posted in Dev.to and StackExchange and the final solution that I adopted. ### The Problem I have a function which takes the incoming request, parses the data and performs an action and posts the results to a webhook. This is running as background as a Celery Task. This function is a common interface for about a dozen Processors, so can be said to follow the Factory Pattern. Here is the psuedo code: processors = { "action_1": ProcessorClass1, "action_2": ProcessorClass2, ... } def run_task(action, input_file, *args, **kwargs): # Get the input file from a URL log = create_logitem() try: file = get_input_file(input_file) except: log.status = "Failure" # process the input file try: processor = processors[action](file) results = processor.execute() except: log.status = "Failure" # upload the results to another location try: upload_result_file(results.file) except: log.status = "Failure" # Post the log about the entire process to a webhoook post_results_to_webhook(log)  This has been working well for most part as the the inputs were restricted to action and a single argument (input_file). As the software has grown, the processors have increased and the input arguments have started to vary. All the new arguments are passed as keyword arguments and the logic has become more like this. try: input_file = get_input_file(input_file) if action == "action_2": input_file_2 = get_input_file(kwargs.get("input_file_2")) except: log.status = "failure" try: processor = processors[action](file) if action == "action_1": extra_argument = kwargs.get("extra_argument") results = processor.execute(extra_argument) elif action == "action_2": extra_1 = kwargs.get("extra_1") extra_2 = kwargs.get("extra_2") results = processor.execute(input_file_2, extra_1, extra_2) else: results = processor.execute() except: log.status = "Failure"  Adding the if conditions for a couple of things didn’t make a difference, but now almost 6 of the 11 processors have extra inputs specific to them and the code is starting to look complex and I am not sure how to simplify it. Or if at all I should attempt at simplifying it. Something I have considered: 1. Create a separate task for the processors with extra inputs – But this would mean, I will be repeating the file fetching, logging, result upload and webhook code in each task. 2. Moving the file download and argument parsing into the BaseProcessor – This is not possible as the processor is used in other contexts without the file download and webhooks as well. ## The solution I solved it by making two important changes: 1. Normalised the processor’s by making the common arguments positional and everything else keyword based. This allows me to pass the kwargs as I receive them without unpacking. It is the processor’s job. 2. For the extra files, make a copy of the kwargs and replace the remote file url with the local file location. This way, the extra files are a part of the kwargs dict itself. def run_task(action, input_file, *args, **kwargs): params = kwargs.copy() # Get the input file from a URL log = create_logitem() try: file = get_input_file(input_file) if action == "action_2": params["extra_file"] = get_input_file(kwargs["extra_file"] # update the files in params except: log.status = "Failure" # process the input file try: processor = processors[action](file) results = processor.execute(**params) # Unpack and pass the params except: log.status = "Failure" # upload the results to another location try: upload_result_file(results.file) except: log.status = "Failure" # Post the log about the entire process to a webhoook post_results_to_webhook(log)  Now I have the same lean structure as I originally had. The only processor specific code is the file downloads which I think I can live with for now. ### Credits Kain0_0‘s answer pointed me in the right direction and helped me simplify it in a way that makes sense. ## Employing VueJS reactivity to update D3.js Visualisations – Part 2 In Part 1, I wrote about using Vue’s reactivity directly in the SVG DOM elements and also pointed out that it could become difficult to manage as the visualisation grew in complexity. We used D3 utilities for computation and Vue for the state management. In this post we are going to use D3 for both computation and state management with some help from Vue. Let us go back to our original inverted bar chart and the code where we put all the D3 stuff inside the mounted() callback. I am going to add a button to the interface so we can generate some interactivity. <template> <section> <h1>Simple Chart</h1> <button @click="updateValues()">Update Values</button> <div id="dia"></div> </section> </template>  … and define the updateValues() inside the methods in the script export default { name: 'VisualComponent data: function() { return { values: [1, 2, 3, 4, 5] } }, mounted() { // all the d3 code in here }, methods: { updateValues() { const count = Math.floor(Math.random() * 10) this.values = Array.from(Array(count).keys()) } }  Now, every time the button is clicked, a random number of elements (0 to 10) will be set to the values property of the component. Time to make the visualization update automatically. How do we do that? ### Using Vue Watchers Watchers in Vue provide us a way track changes on values and do custom things. We are going to combine that with our knowledge of D3’s joins to update out visualization. First I am going to make a couple of changes so we can access the visualization across all the functions in the component. We currently have this  mounted() { const data = [1, 2, 3, 4, 5] const svg = d3 .select('#dia') .append('svg') .attr('width', 400) .attr('height', 300) svg .selectAll('rect') .data(data) .enter() ... }  1. We are going to remove the data and replace it with this.values. This will allow us to access the data anywhere from the visualization 2. We are going to track the svg as a component data value instead of a local constant.  ... data: function() { return { values: [1, 2, 3, 4, 5], svg: null // property to reference the visualization } }, mounted() { this.svg = d3 .select('#dia') .append('svg') .attr('width', 400) .attr('height', 300) this.svg .selectAll('rect') .data(this.values) .enter() ...  Now we can access the data and the visualization from anywhere in the Vue Component. Let us add a watcher that will track the values and update the visualization export default { ... watch: { values() { // Bind the new values array to the rectangles const bars = this.svg.selectAll('rect').data(this.values) // Remove any extra bars that might be there // We will use D3's exit() selection for that bars.exit().remove() // Add any extra bars that we might need // We will use D3's enter() selection for that bars .enter() .append('rect') .attr('x', function(d, i) { return i * 50 }) .attr('y', 10) .attr('width', 25) .attr('fill', 'steelblue') // Let us set the height for both existing and new bars .merge(bars) .attr('height', function(d) { return d * 50 }) } } }  There we have it – a visualization that will update based on the user’s interaction. ### Notes 1. If we compare this technique to the previous one, it does seem like we are writing more verbose JavaScript than necessary. But if you had written D3 at all, you would find this verbose JS better to manage than the previous one. 2. Performance – One concern when switching from Vue’s direct component reactivity to DOM based updates using D3 is the performance. I don’t have a clear picture on that matter. But the good thing is, D3’s update mechanism changes only what is necessary similar to that of Vue’s update mechanism. So I don’t think we will be very far when it comes to performance. 3. One important advantage of this method is we can make using the animation capabilities that comes with D3js ## Employing VueJS reactivity to update D3.js Visualisations – Part 1 In the previous post I wrote about how we can add D3.js Visualizations to a Vue component. I took a plain HTML, JavaScript D3.js viz and converted it to a static visualization inside the Vue component. One of the important reasons why we use a modern framework like VueJS is to build dynamic interfaces that react to user inputs. Now in this post, let us see how we can leverage that to create dynamic visualisations that react to changes in the underlying data as well. ### Points to consider Before we begin let us consider these two points: 1. VueJS components are not DOM elements, they are JS objects that are rendered into DOM elements 2. D3.JS directly works with DOM elements. So what this means is that, we can manipulate the DOM (which the user is seeing) using either Vue or D3. If the DOM elements of our visualisation is created using Vue then any changes to the underlying data would update the DOM automatically because of Vue’s reactivity. On the other hand, if we created the DOM elements using D3, then we will have to update them with D3 as well. Let’s try both. ### Using Vue Directly Let us take our simple inverted bar chart example. Here the output SVG will be something like this: We have created one rectangle per data point, with its x position and the height calculated dynamically using D3. Let us replicate the same with Vue. I am going to change the template part of the component: <template> <section> <h1>Simple Chart</h1> <div id="dia"> <svg width="400" height="300"> <g v-for="(value, index) in values" :key="value"> <rect :x="index * 50" y="10" width="25" :height="value * 50" fill="steelblue" ></rect> </g> </svg> </div> </section> </template>  The important lines to note are the following: 1. <g v-for... – In this line we loop through the data points with g tag acting as the container (like a div) 2. :x="index * 50" – Here we are calculating the position of the rectangle based on the index of the value 3. :height="value * 50" – Here we calculate the height of the rectangle based on the value. With this we can write our script as: export default { name: 'VisualComponent', data: function() { return { values: [1, 2, 3, 4, 5] } } }  Now this would have created the same exact chart. If these values were ever to change by user interaction then the bar chart would update automatically. We don’t even need D3.js at this point. This also will allow us to do cool things like binding Vue’s event handlers (eg., @click) with SVG objects. But here is the catch, this works for simple charts and for examples. Or real visualization will be much more complex with Lines, Curves, Axis, Legends ..etc., trying to create these things manually will be tedious. We can make it easier to a certain degree by using D3 utilities inside computed properties like this: import * as d3 from 'd3' export default { ... computed: { paths() { const line = d3.line() .x(d => d.x) .y(d => d.y) .curve(d3.curveBasis) return values.map(v => line(v)) } } ... }  and use it like this: <template> ... <g v-for="path in paths"> <path :d="path" stroke-width="2px" stroke="blue></path> </g> ...  This way we are converting the values into SVG Path definitions using D3 and also using Vue’s reactivity to keep the paths updated according to the changes in data. This improvement will also become unusable beyond a certain limit, because: 1. We are not just thinking about the “what I need” of the visualization, we are also thinking about the “how do I” part for the “what I need” parts. This makes the process excessively hard. Almost negating the purpose D3. 2. This will soon become unmanageable because the binding between the data and the visual is spread between the DOM nodes inside “ and the computed properties and methods. This means any updates will need working in two places. For these reasons, I would like to keep the let everything be controlled by D3.js itself. How do I do that? Read it here in Part 2 ## Adding D3.js Visualisations to VueJS components D3.JS is an amazing library to create data visualizations. But it relies on manipulating the DOM Elements of the web page. When building a website with VueJS we are thinking in terms of reactive components and not in terms of static DOM elements. Successfully using D3.js in Vue components is dependent on our clear understanding of the the Vue life cycle. Because at some point the reactive component becomes a DOM element that we see in the browser. That is when we can start using D3.js to manipulate our DOM elements. Let us start with a simple example. <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Simple Example</title> <a href="https://d3js.org/d3.v5.min.js">https://d3js.org/d3.v5.min.js</a> </head> <body> <h1>Simple Example</h1> <div id="dia"></div> <script> const data = [1, 2, 3, 4, 5] var svg = d3.select('#dia') .append('svg') .attr('width', 400) .attr('height', 300) svg.selectAll('rect') .data(data) .enter() .append('rect') .attr('x', function(d, i) { return i * 50 }) .attr('y', 11) .attr('width', 25) .attr('height', function(d) { return d * 50 }) .attr('fill', 'steelblue') </script> </body> </html>  Now this will give us a inverted bar graph like this: ### Doing the same in a Vue Component The first step is to include the d3.js library into the project. yarn add d3 # or npm install d3  Then let us import it to our component and put our code in. The confusion starts with where do we put it the code in. Because we can’t just put it into the “ tag like in a HTML file. Since Vue components export an object, we will have to put the code inside one of the object’s methods. Vue has a number of lifestyle hooks that we can use for this purpose like beforeCreate, created, mounted..etc., Here is where the knowledge of Vue component life-cycle comes useful. If we see the the life-cycle diagram from the documentation, we can see that when the full DOM becomes available to us and the mounted() callback function is called. So, mounted() seems to be a good place to put out D3.js code. Let us do it. <template> <section> <h1>Simple Chart</h1> <div id="dia"></div> </section> </template> <script> import * as d3 from 'd3' export default { name: 'VisualComponent', mounted() { const data = [1, 2, 3, 4, 5] const svg = d3 .select('#dia') .append('svg') .attr('width', 400) .attr('height', 300) svg .selectAll('rect') .data(data) .enter() .append('rect') .attr('x', function(d, i) { return i * 50 }) .attr('y', 10) .attr('width', 25) .attr('height', function(d) { return d * 51 }) .attr('fill', 'steelblue') } } </script> <style></style>  Now this shows the same graph that we saw in the simple HTML page example. ### Next ## Lottie – Amazing Animations for the Web Modern websites come with some amazing animations. I remember Sentry.io used to have an animation that showed packets of information going through a system and it getting processed in a processor.etc., If you browse Dribble you will see a number of landing page animations that just blow our mind. The most mainstream brand that employs animations is Apple. Their web page was a playground when they launched Apple Arcade. Sidenote: Sadly all these animations vanish once the pages are updated. It would be cool if they could be saved in some gallery when we can view them at later points in time. We were left wondering how do they do it? I might have found the answer to this. The answer could be Lottie. What is Lottie? The website says A Lottie is a JSON-based animation file format that enables designers to ship animations on any platform as easily as shipping static assets. They are small files that work on any device and can scale up or down without pixelation. Go to their official page here to learn more. It is quite interesting. Take a peek at the gallery as well, there are some interesting animations that can be downloaded and used in websites for free as well. ## gitignore.io – Generating Complex Git Ignore Files Automatically My way of generating .gitignore files has evolved over time. First it was just adding files and folder names manually to a empty file called .gitignore. Then as more and more people started sharing their dotfiles, I started using copies of it. One most used resource for me is the Github gitignore Repository. I just grab the raw url of the gitignore that I want and use wget to save in my repository, like: wget https://raw.githubusercontent.com/github/gitignore/master/Python.gitignore -O .gitignore  ### gitignore.io Recently I have started using the online app gitignore.io. The cool thing about this is you can add a combination of things that define your environment and the gitignore is defined based on all of them. For example see the screenshot below: This generates a gitignore file that I can use for: • Python Django project • that I am going to develop using PyCharm • in a Linux Machine • under a virtual environment If you thought this was cool, there is also ..etc., In case you are not using it, give it a try. ## JSON.stringify – A versatile tool in your belt A common scenario that we run into when writing JavaScript for the browser is showing a variable as text on the screen. JS has an inbuilt function to achieve that quite easily. Just us the toString() function. Here is an example: var i = 10 i.toString() "10"  Where this falls short is when the variable is an object. Trying the same: var name = {"first": "Tom", "last": "Hardy"} name.toString() "[object Object]"  Here is where JSON.stringify comes in handy. var name2 = {"first": "Tom", "last": "Hardy"} JSON.stringify(name2) "{"first":"Tom","last":"Hardy"}"  ## Two Days with Python & GraphQL ## Background An web application needed to be built. An external API will give me a list of information packets as JSON. The JSON has the information and the user object. The application’s job is to store this data in a local database and provide an user interface to sort and filter this data. Simple enough. GraphQL kept coming up on on the internet. A number of tools were saying they support GraphQL in their home pages and was making me curious. The requirement also said: use the technology of your choice REST/GraphQL to build the backend Now, I had to see what’s it all about. So I sat down read the docs and got a basic understanding of it. It made total sense theoretically. It solved a major problem I face when building Single Page Applications and the Backed REST APIs independently. The opaqueness of incoming data and the right method to get them. ### Common Scenario I run into While building the frontend, we assume use the schema that the backend people give as the source of truth and build it based on that. But the schema becomes stale after a while and changes need to be made. There are many reasons to it: • adding/removal/renaming of an attribute • optimisations that come into play, which alter the structure • the backend API is a third party one and searching and sorting are involved • API version changes • access control which restricts the information contained..etc., And even when we have a stable API, there is the issue of information leak. When you working with user roles, it becomes very confusing very quickly because a request to /user/ returns different objects based on the role of the requester. Admin sees different set of information than a privileged user and a privileged user sees a different set of data than an unprivileged one. And more often than not, there is a lot of unwanted information that get dumped by APIs on to the frontend than what is required, which sometimes even lead to security issues. If you want to see API response overload take a look under the hood of Twitter web app for example, the API responses have a lot more information than what we see on screen. ### Enter GraphQL GraphQL basically said to me, let’s streamline this process a little bit. First we will stop maintaining resource specific URLs, we are going to just send all our requests to /graphql and that’s it. We won’t be at the mercy of the backend developers whim’s and fancies about how to construct the URL. No more confusing between /course/course_id/lesson/lesson_id/assignments and /assignments?course=course_id&amp;lesson=lesson_id. Next, no, we are not going to use HTTP verbs, everything is just a POST request. And finally no more information overload, you get only what you ask. If you want 3 attributes, then you ask 3, if you want 5 then you ask 5. Let us eliminate the ambiguity and describe what you want as a Graphql document and post it. I mean, I have been sick of seeing SomeObject.someAttribute is undefined errors. So I was willing to put in the effort to define my requests clearly even it meant a little book keeping. Now I will know the exact attributes that I am going to work with. I could filter, sort, paginate all just by defining a query. It was a breath of fresh air for me. After some hands on experiments I was hooked. This simple app with two types of objects were the perfect candidate to get some experience on the subject. ## Day/Iteration 1 – Getting the basic pipeline working The first iteration went pretty smooth. I found a library called Graphene – Python that implemented GraphQL for Python with support for SQLAlchemy, I added it to Flask with Flask-GraphQL and in almost no time I had a API up and running that will get me the objects, and it came with sorting and pagination. It was wonderful. I was a little confused initially, because, Graphene implements the Relay spec. So my queries looked a little over defined with edges and nodes than plain ones. I just worked with it. I read a quick intro about Connections and realised I didn’t need to worry about it, as I was going to be just querying one object. Whatever implications it had, it was for complex relations. For the frontend, I added Vue-Apollo the app and I wrote my basic query and the application was displaying data on the web page in no time. It has replaced both Vuex state management and Axios HTTP library in one swoop. And to help with query designing, there was a helpful auto completing UI called GraphIQL, which was wonderful. ## Day/Iteration 2 – Getting search working Graphene came with sorting and filtering inbuilt. But the filtering is only available if you use Django as it uses django-filter underneath. For SQLAlchemy and Flask, it only offers some tips. Thankfully there was a library called Graphene-SQLAlchemy-Filter which solved this exact problem. I added that and voila, we have a searchable API. When trying to implement searching in frontend is where things started going sideways. I have to query all the data when loading the page. So the query looked something like query queryName { objectINeeded { edges { nodes { id attribute_1 attribute_2 } } } }  And in order to search for something, I needed to do: query queryName { objectINeeded(filters: { attribute_1: "filter_value" }) { ... }  And to sort it would change to: query queryName { objectINeeded(sort: ATTRIBUTE_1_ASC, filters: { attribute_1: "filter_value" }) { ... }  That’s okay for predefined values of sorting and filtering, what if I wanted to do it based on the user input. ### 1. Sorting If you notice closely, the sort is not exactly a string I could get from user as an input and frankly it is not even one that I could generate. It is Enum. So I will have to define an ENUM with all the supportable sorts and use that. How do I do that? I will have to define them in a separate GraphQL schema document. I tried doing that and configured webpack to build them and failed miserably. For one, I couldn’t get it to compile the .graphql files. The webloader kept throwing the errors and I lost interest after a while. ### 2. Searching The filters is a complex JSON like object that could support OR, AND conditions and everything. I want the values to be based on user input. Apollo supports variables for that purpose. You can do something like this in the Vue script apollo: { myObject: { gql: query GetDataQuery($value1: String, $value2: Int) { objectINeed( filters: [{attr1:$value}, {attr2: \$value2}] {
...
}
},
variables() {
return { value1: this.userInputValue1, value2: this.userInputValue2 }
}


This is fine when I want to employ both the inputs for searching, what if I want to do only one? Well it turns out I have to define a different query altogether. There is no way to do an optional filter. See the docs on Reactive Queries.
Now that was a lot of Yak shaving I am not willing to do.

Even if I did the Yak Shaving, I ran into trouble on the backend with nested querying. For example what if I wanted to get the objects based on the associated user? Like my query is more like:

query getObjects {
myObject {
attr1
attr2
}
}
}
`

The Graphene SQLAlchemy documentation said I could do it, it even gave example documentation, but I couldn’t get it working. And when I wanted to implement it myself, the abstraction was too deep that I would have to spend too many hours just doing that.

### 3. The documentation

The most frustrating part through figuring out all this was the documentation. For some reason GraphQL docs think that if I used Apollo in the frontend, then I must be using Apollo Server in the backend. Turns out there is no strict definition on the semantics for searching/filtering, only on the definition of how to do it. So what the design on the backend should match the design on the frontend. (Now where have I heard that before?) And that’s the reason documentation usually shows both the client and server side implementations.

### 4. Managing state

An SPA has a state management library like Vuex, Redux to manage application state, but with GraphQL, local state is managed with a GraphQL cache. It improves efficiency by reducing the calls to the server. But here is the catch, you have to define the schema of the objects for that to work. That’s right, define the schema as in write the models in GraphQL documents. It is no big deal if your stack is fully NodeJS, you can just do it once and reference it in both places.

In my case, I will have defined my SQLAlchemy models in Python in the backend, and I will have to do it again in GQL for the frontend. So changes have to be synced between them if anything changes. And remember that each query is defined separately, so I will have to update any query that will be affected by the changes.

At this point I was crying. I has spent close to 8 hours figuring out all this.

I gave up and rewrote the entire freaking app using REST API and finished the project including the UI in the next 6-7 hours and went to bed at 4 in the morning.

## Learning

1. GraphQL is a complex solution for a complex problem. You can solve simple problems with it but the complexity will hit you at some point.
2. It provides a level of clarity in querying data that REST API doesn’t, but it comes with a cost. It is cheap for cheap work and costly for larger requirements. Almost like how AWS bills raise.
3. No it doesn’t provide the kind of independence between the backend and frontend as it seems like on the surface. This might by lack of understanding and not the goal of GraphQL at all, but if you like me made this assumption, then just know it is invalid.
4. Use low-level libraries to implement GraphQL, and try to keep it NodeJS. At least for the sake of sharing the schema documents if not for anything. If I has implemented the actions myself instead of depending on Graphene and adding a filter library on top of that, I would have fared better.