This post describes the process of developing an API Service in Backendless with JavaScript. You will learn:

• how configure your development environment
• include NPM dependencies
• run the service in the debug mode and test it using the Backendless console
• deploy the service to Backendless

The service you will develop in this guide will provide APIs for controlling a LIFX wi-fi enabled light bulb. This very service is used in the article describing how to integrate Amazon Alexa with an IoT device using Backendless. This article references IntelliJ IDEA as the IDE, however, it is not required, you can use any code editor. Make sure to create a Backendless account and create an app in Backendless Cloud (the free tier or the trial option will be plenty to proceed).

Performing a calculation on a group of database objects may be a complex task. For example, to calculate the sum of all orders for a customer would require retrieving all customer’s orders, iterating over them to calculate the mathematical sum of all amounts. This was yesterday! As of Backendless 4.4.0, you can use aggregate functions to calculate the average, sum, maximum and minimum values for a collection of objects without retrieving them from the server. Additionally, the system supports calculating object count for all records in the database or a record subset.

To use an aggregate function, simply request a property in a data retrieval request in the following format (the example below is for calculating the sum for the orderAmount  column):

The returned object includes the sum  property with the calculated value:

The name of the property can be modified by assigning an alias (using %20  to replace the spaces in the URL):

The result contains a value for the property named after the alias:

Grouping Results

Results can be grouped by a column. The column could be either in the same table or a related one. For example, the following request retrieves the sum of all orders grouped by related country:

Unlike the response above, the result for this query includes a collection of objects, each containing the sum for a related country:

It is also possible to apply a filter on the grouped values. This can be done using the having  clause. For example, the request below retrieves only the groups of countries where the total order amount is greater than 10000:

For more information about aggregate functions see the Backendless API documentation:

• Android: https://backendless.com/docs/android/doc.html#data_aggregating_functions
• iOS: https://backendless.com/docs/ios/doc.html#data_aggregating_functions
• JS: https://backendless.com/docs/js/doc.html#data_aggregating_functions
• REST: https://backendless.com/docs/rest/doc.html#data_aggregating_functions

For anyone developing business logic in JS, we have put together some suggestions for troubleshooting your deployment. The page is added to the product documentation. One of the new features described in the doc is the ability to redirect console.log  messages to Backendless logging. Once your JS code is deployed to production, messages from the console.log  calls will be routed to the log file wit the SERVER_CODE  logging category.

One of the goals we have at Backendless is to make the platform uniformly available for different types of client technologies. The platform is truly cross-platform and it is a matter of time/effort to make it available to a new client environment.

Since we already have a super powerful SDK for JavaScript, creating a bridging technology for TypeScript was rather straight-forward. I am happy to announce that if you are building TypeScript apps, you can start taking advantage of everything Backendless has to offer. We put together a Quick Start Guide for integrating TypeScript with Backendless to make it easier for you to get started. Please give it a try and let us know how you liked it.

If you have been waiting for Angular 2 support in Backendless, the wait is over. We have finished the integration of the Backendless SDK for JS and now it is available for TypeScript. An important side effect of this integration is support for the Angular 2 framework. The integration enables complete support of all Backendless APIs from an Angular 2 application. To help you get started with Backendless and Angular 2, we put together a Quick Start guide. Please let us know what you think. If you run into any problems, please post to the Backendless support forum.

We just pushed a new release to our production servers. The release includes multiple new features and a ton of improvements. Below is a summary of what went into the release. There will be a blog post with a video providing an in-depth review of each new feature:

Tizen is an open source platform residing within the Linux Foundation. It includes an operating system which can run smartphones, tablets, netbooks, onboard devices in smart cars as well as smart TVs. We wanted to see what it would take to integrate a Tizen app with Backendless because the benefits of such integration would be huge. For instance, data can be easily shared between different implementations of an app: a Tizen version of the app can easily communicate with the one running on Android or iOS by the means of Backendless service APIs.

In this write-up we review a JavaScript application we recently ported to Backendless. The application is an “editable invoice” which automatically saves its data including invoice line items, customer address, your own address, invoice number, etc. It is a good example demonstrating how to work with “related persistent data”, which means you can save a hierarchy or objects containing other objects (the “Invoice” object, contains a collection of “Line Items”). The application also demonstrates the functionality of user registration and login, although we stopped short of connecting the invoices with the user accounts (which would be fairly simple to add).

The Editable Invoice application is an effort by noBackend.org which helps educating the developers about the advantages of BaaS. The vision is to provide a reference implementation with various backends.

The source code for the application has been push to our Github account.

Follow the steps below to setup and see the application in action:

1. Register/login to the Backendless console. An application is created during the registration process or you can create one later at any time.
2. Select an application once you login to console.
3. Click the Manage icon. The App Settings screen will open up. The screen contains many useful settings and properties, but for now you will need only the Application ID and the Secret Key for the JavaScript clients.
   
4. Keep the browser window open (you will need to copy/paste the ID and the Key from that screen) and open /editable-invoice/backendless/applogic.js in a text editor.
5. Copy/paste the Application ID and Secret Key into the code on line 1:
   
   JavaScript

   Backendless.initApp("PUT-YOUR-APP-ID-HERE", "PUT-YOUR-JS-SECRET-KEY-HERE", "v1");

   1	Backendless.initApp("PUT-YOUR-APP-ID-HERE", "PUT-YOUR-JS-SECRET-KEY-HERE", "v1");

6. There is only one additional configuration step needed before you can run the application. Click the Users icon in the Backendless Console. The “User Properties” screen will open by default. Using this screen you can define the user properties which will be used by the Editable Invoice app. Click the “Add Custom Property” button and add the “login” property.
   
7. Click “Save”. Make sure to select the “login” property as “Identity” by selecting the radio button for that property. The User Properties screen should look as shown below:
   
8. Run the example. You can open the editable-invoice/index.html in a browser directly from the file system. Alternatively, you can deploy the entire application to a web server and load editable-invoice/index.html through a URL.

Try the following once you run the application:

• Modify the invoice name by changing the main header at the top.
• Modify the “Your Address” field.
• Modify the “Your client’s address” field.
• Add a new item to the invoice – enter item code, description, unit price and quantity. Click the “Add item” button.
• Reload the application – you should see the invoice you just modified.
• Check out the Sign Up/Sign In forms.
• Login to Backendless Console and check the registered users in Data > Users, as well as data stored by the application in the “invoice” and “item” tables – the tables will be created automatically once you start using the example.

Reviewing Code

Below you will find some of the examples of using the Backendless API in the application:

• Loading all invoices upon the start of the application. (/backendless/applogic.js, lines 3-15)
  
  JavaScript

  $('document').ready( function() { // bootstrap & render App App.store = {}; App.store.invoices = Backendless.Persistence.of(function invoice(){}); try { renderApp(App.store.invoices.find( { options: { related: ["items"] } }).data ); } catch(e) { renderApp( [] ); } ...

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

  $('document').ready( function() {   // bootstrap & render App   App.store = {};   App.store.invoices = Backendless.Persistence.of(function invoice(){});   try   {     renderApp(App.store.invoices.find(     {       options:       {          related: ["items"]       }     }).data );   }   catch(e)   {     renderApp( [] );   } ...

  
  Line 5 obtains a reference to the “invoices” data store in Backendless. The returned object provides access to the CRUD (Create, Retrieve, Update, Delete) operations for that table.
  Line 8 (find) sends a request to load all the previously saved invoice objects.
  Lines 10-13 request that the invoice objects returned by Backendless included references to the related “items” objects (an Invoice contains line items or just “items”).

• Saving/Updating an Invoice. (/backendless/applogic.js, lines 39-62)
  
  JavaScript

  var handleInvoiceSave = function(properties) { try{ var obj = App.store.invoices.find({ options:{ related: ["items"] }, condition: "id='" + properties.id +"'" }).data[0]; if(obj){ properties.objectId = obj["__updated__objectId"] || obj.objectId; for(var i = 0; i < obj.items.length; i++){ for(var j = 0; j < properties.items.length; j++){ if(properties.items[j].id == obj.items[i].id){ properties.items[j].objectId = obj.items[i].objectId; } } } } } catch(e){ }finally{ App.store.invoices.save(properties); } }

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

  var handleInvoiceSave = function(properties) {     try{         var obj = App.store.invoices.find({             options:{                 related: ["items"]             },             condition: "id='" + properties.id +"'"         }).data[0];           if(obj){             properties.objectId = obj["__updated__objectId"] || obj.objectId;             for(var i = 0; i < obj.items.length; i++){                 for(var j = 0; j < properties.items.length; j++){                     if(properties.items[j].id == obj.items[i].id){                         properties.items[j].objectId = obj.items[i].objectId;                     }                 }             }         }     } catch(e){     }finally{         App.store.invoices.save(properties);     } }

  
  Lines 3-7: check if the invoice has been previously saved. Uses the “condition” parameter where it specifies to search for the invoice by the “id” property.
  Lines 10-19: if the invoice is found (i.e. it has been previously saved), iterate through the items and assign the item’s “objectId”. In this example each “item” has an “id” assigned on the client-side (/shared/js/invoice.js, lines 14 and 28). On top of this, Backendless assigns its own ID to each saved object. That ID is stored in the “objectId” property. It is important to maintain consistency between the objects by correlating the IDs. This block of code accomplishes it for the save operation.
  Line 22: once the IDs are assigned, the entire invoice (with all the items) is saved.
• Deleting an Invoice. (/backendless/applogic.js, lines 64-68)
  
  JavaScript

  var handleInvoiceDelete = function(properties) { console.log("delete invoice"); App.store.invoices.remove( properties, new Backendless.Async(function(){ })); }

  1 2 3 4 5

  var handleInvoiceDelete = function(properties) {     console.log("delete invoice");     App.store.invoices.remove( properties, new Backendless.Async(function(){     })); }

• User Registration. (/backendless/applogic.js, lines 82-93)
  
  JavaScript

  var handleSignUp = function(inputs) { var user = new Backendless.User(); user.login = inputs.username; user.email = inputs.email; user.password = inputs.password; Backendless.UserService.register( user, new Backendless.Async( function(){ App.hideModalForm() }, function(data){ App.renderModalFormError({error: data.message}); })); };

  1 2 3 4 5 6 7 8 9 10 11 12

  var handleSignUp = function(inputs) {     var user = new Backendless.User();     user.login = inputs.username;     user.email = inputs.email;     user.password = inputs.password;     Backendless.UserService.register( user,         new Backendless.Async( function(){             App.hideModalForm()         }, function(data){             App.renderModalFormError({error: data.message});         })); };

  
  Lines 2-5: Create a Backendless.User object which contains the values for all the user properties defined in step 7 above.
  Lines 6-11: Send a request to Backendless to register the user. The request is asynchronous with the Backendless.Async object handling the callbacks for success and error functions.
• User Login. (/backendless/applogic.js, lines 94-104)
  
  JavaScript

  var handleSignIn = function(inputs) { Backendless.UserService.login( inputs.username, inputs.password, new Backendless.Async( function(data){ App.user = new Backendless.User(data); App.hideModalForm(); App.renderUserSignedIn(data); },function(data){ App.renderUserAuthenticationError(); App.renderModalFormError({error: data.message}); }) ); };

  1 2 3 4 5 6 7 8 9 10 11

  var handleSignIn = function(inputs) {     Backendless.UserService.login( inputs.username, inputs.password,         new Backendless.Async( function(data){             App.user = new Backendless.User(data);             App.hideModalForm();             App.renderUserSignedIn(data);         },function(data){             App.renderUserAuthenticationError();             App.renderModalFormError({error: data.message});         }) ); };

  
  Line 2: Send a login request to Backendless. The first argument must be a value for the property defined as “Identity” (see step 7 above).

The Backendless API for JavaScript can be used not only from the browser-based JavaScript applications, but also from a Node.js program. Using the API is very straight-forward. The instructions below describe the steps for setting up and running a basic Node.js example with Backendless. The example demonstrates registering a user with your Backendless application. It gathers email address and password and uses the User Registration API call to create an account.

1. Just like with the browser JavaScript, an application must be identified using the application ID and a secret key. To get the ID and the key, login to the Backendless console, create/select your application and click the Manage icon. The default subsection is App Settings:
   
2. Save the code shown below into a file. Name the file example.js.
3. Use the “Copy” buttons to copy the application id value and the secret key for JavaScript. The copied values must be assigned to the “appId” and “secretKey” variables accordingly.
4. Download the Backendless JavaScript library file and save it in the same directory where you created example.js (step 2).
5. Open a command prompt window and run the example using the following command:

   node example.js

The source code of the example is below (double-click the code to remove the highlighting, or click the <> button to toggle it):

Have fun and please let us know if you run into any problems!

Developing JavaScript applications with a backend-as-a-service platform like Backendless significantly simplifies and speeds up the development process. With the latest release of our SDK for JavaScript, this equally applies to both mobile and browser-based apps as well as Node.js applications. The video below reviews the available APIs and demonstrates sample applications showing the simplicity, ease-of-use and the power of Backendless services. Enjoy!