Using a DataStore instance, you can manually store and retrieve data. But, in its current form, DataStore is just a roundabout way of creating an object literal, and any module that will use a DataStore instance has to be coded to use the data property directly.

This is not good software design. It would be better if DataStore provided a public interface for adding, removing, and retrieving data – all while keeping the details of how it works a secret.

The second part of creating your custom DataStore type is to provide these methods for interacting with the data. The goal is for these methods to serve as the interface that other modules use when they interact with a DataStore instance. To accomplish this, you will make use of a very cool feature of JavaScript functions, the prototype property.

Functions in JavaScript are also objects. This means that they can have properties. In JavaScript, all instances created by a constructor have access to a shared storehouse of properties and methods: the prototype property of the constructor.

To create these instances, you used the new keyword when you called the constructor. The new keyword not only creates your instance and returns it but also creates a special link from the instance to the constructor’s prototype property. This link exists for any instance created when the constructor is created with the new keyword.

When you add a property to the prototype and assign it a function, every instance you create with the constructor will have access to that function. You can use the keyword this inside of the function body, and it will refer to the instance.

To see this in action, create the add function in datastore.js as a property of the prototype. You can also delete the call to console.log.

(function (window) {
  'use strict';
  var App = window.App || {};

  function DataStore() {
    console.log('running the DataStore function');
    this.data = {};
  }

  DataStore.prototype.add = function (key, val) {
    this.data[key] = val;
  };

  App.DataStore = DataStore;
  window.App = App;
})(window);

You gave DataStore.prototype the property add and you assigned a function to it. That function takes two arguments, key and val. Inside the function body, you used those arguments to make changes to the instance’s data property.

In terms of how DataStore works with coffee orders, it will store the order information (the val), using the customer’s email address (the key).

You are not setting up a true database, but DataStore works well enough for CoffeeRun. It is able to save some information, val, under the unique identifier specified by key. Because you are using a JavaScript object for storage, each key is guaranteed to be a unique entry in the database. (In a JavaScript object, a property name is always unique, like function names within a namespace. If you tried to store different values using the same key, you would just overwrite any previous values for that key.)

This aspect of JavaScript objects fulfills the one major requirement of any database: keeping the individual pieces of data separate.

Save your code and switch back to the browser. Create an instance of DataStore in the console and use its add method to store some information.

var ds = new App.DataStore();
ds.add('email', '[email protected]');
ds.add('order', 'triple espresso');
ds.data;

Inspect the data property to confirm that it works (Figure 8.9).

Figure 8.9  Calling a prototype method

The next thing to do is to create methods for accessing the data. In datastore.js, add a method to look up a value based on a given key and one to look up all keys and values.

...
  DataStore.prototype.add = function (key, val) {
    this.data[key] = val;
  };

  DataStore.prototype.get = function (key) {
    return this.data[key];
  };

  DataStore.prototype.getAll = function () {
    return this.data;
  };

  App.DataStore = DataStore;
  window.App = App;
})(window);

You created a get method that accepts a key, looks up the value for it in the instance’s data property, and returns it. You also created a getAll method. It is almost the same, but instead of looking up the value for a single key, it returns a reference to the data property.

You can now add and retrieve information from a DataStore instance. To complete the cycle, you need to add a method for removing information. Add that to datastore.js now.

...
  DataStore.prototype.getAll = function () {
    return this.data;
  };

  DataStore.prototype.remove = function (key) {
    delete this.data[key];
  };

  App.DataStore = DataStore;
  window.App = App;
})(window);

The delete operator removes a key/value pair from an object when your new remove method is called.

With that, you have completed the DataStore module, which provides the most important part of the CoffeeRun application. It can store data, provide stored data in response to queries, and delete unnecessary data on command.

To see all of your methods in action, save your code and go to the console after browser-sync has reloaded your browser. Enter the following code, which exercises all of the methods of DataStore:

var ds = new App.DataStore();
ds.add('[email protected]', 'tea');
ds.add('[email protected]', 'eshpressho');
ds.getAll();
ds.remove('[email protected]');
ds.getAll();
ds.get('[email protected]');
ds.get('[email protected]');

As shown in Figure 8.10, DataStore’s instance methods should now work as expected. These methods are exactly the way that other modules will interact with your application’s database.

Figure 8.10  Working with DataStore using only its prototype methods

Your next module will use the same structure: an IIFE with a parameter for the namespace to modify. But it will provide completely different functionality from DataStore.