Skip to main content

Creating a CRUD App in Minutes with Angular’s $resource

By Sandeep Panda

Most Single Page Applications involve CRUD operations. If you are building CRUD operations using AngularJS, then you can leverage the power of the $resource service. Built on the top of the $http service, Angular’s $resource is a factory that lets you interact with RESTful backends easily. So, let’s explore $resource and use it to implement CRUD operations in Angular.


The $resource service doesn’t come bundled with the main Angular script. You need to download a separate file called angular-resource.js and include it in your HTML page. The script can be downloaded from

Also, your main app module should declare a dependency on the ngResource module in order to use $resource. The following example demonstrates how to do it:

angular.module('mainApp',['ngResource']); //mainApp is our main module

Getting Started

$resource expects a classic RESTful backend. This means you should have REST endpoints in the following format:

REST Endpoints

You can create the endpoints using the server side language of your choice. However, I have used Node + Express + MongoDB to design the RESTful API for the demo app. Once you have the URLs ready you can take help of $resource for interacting with these URLs. So, let’s see how exactly $resource works.

How Does $resource Work?

To use $resource inside your controller/service you need to declare a dependency on $resource. The next step is calling the $resource() function with your REST endpoint, as shown in the following example. This function call returns a $resource class representation which can be used to interact with the REST backend.

angular.module('').factory('Entry', function($resource) {
  return $resource('/api/entries/:id'); // Note the full endpoint address

The result of the function call is a resource class object which has the following five methods by default:

  1. get()
  2. query()
  3. save()
  4. remove()
  5. delete()

Now, let’s see how we can use the get(), query() and save() methods in a controller:


angular.module('myApp.controllers').controller('ResourceController',function($scope, Entry) {
  var entry = Entry.get({ id: $ }, function() {
  }); // get() returns a single entry

  var entries = Entry.query(function() {
  }); //query() returns all the entries

  $scope.entry = new Entry(); //You can instantiate resource class

  $ = 'some data';$scope.entry, function() {
    //data saved. do something here.
  }); //saves an entry. Assuming $scope.entry is the Entry object  

The get() function in the above snippet issues a GET request to /api/entries/:id. The parameter :id in the URL is replaced with $ You should also note that the function get() returns an empty object which is populated automatically when the actual data comes from server. The second argument to get() is a callback which is executed when the data arrives from server. This is a useful trick because you can set the empty object returned by get() to the $scope and refer to it in the view. When the actual data arrives and the object is populated, the data binding kicks in and your view is also updated.

The function query() issues a GET request to /api/entries (notice there is no :id) and returns an empty array. This array is populated when the data arrives from server. Again you can set this array as a $scope model and refer to it in the view using ng-repeat. You can also pass a callback to query() which is called once the data comes from server.

The save() function issues a POST request to /api/entries with the first argument as the post body. The second argument is a callback which is called when the data is saved. You might recall that the return value of the $resource() function is a resource class. So, in our case we can call new Entry() to instantiate an actual object out of this class, set various properties on it and finally save the object to backend.

Ideally, you will only use get() and query() on the resource class (Entry in our case). All the non GET methods like save() and delete() are also available in the instance obtained by calling new Entry() (call this a $resource instance). But the difference is that these methods are prefixed with a $. So, the methods available in the $resource instance (as opposed to $resource class) are:

  1. $save()
  2. $delete()
  3. $remove()

For instance, the method $save() is used as following:

$scope.entry = new Entry(); //this object now has a $save() method
$scope.entry.$save(function() {
  //data saved. $scope.entry is sent as the post body.

We have explored the create, read and delete parts of CRUD. The only thing left is update. To support an update operation we need to modify our custom factory Entity as shown below.

angular.module('').factory('Entry', function($resource) {
  return $resource('/api/entries/:id', { id: '@_id' }, {
    update: {
      method: 'PUT' // this method issues a PUT request

The second argument to $resource() is a hash indicating what should be the value of the parameter :id in the URL. Setting it to @_id means whenever we will call methods like $update() and $delete() on the resource instance, the value of :id will be set to the _id property of the instance. This is useful for PUT and DELETE requests. Also note the third argument. This is a hash that allows us to add any custom methods to the resource class. If the method issues a non-GET request it’s made available to the $resource instance with a $ prefix. So, let’s see how to use our $update method. Assuming we are in a controller:

$scope.entry = Movie.get({ id: $ }, function() {
  // $scope.entry is fetched from server and is an instance of Entry
  $ = 'something else';
  $scope.entry.$update(function() {
    //updated in the backend

When the $update() function is called, it does the following:

  1. AngularJS knows that $update() function will trigger a PUT request to the URL /api/entries/:id.
  2. It reads the value of $scope.entry._id, assigns the value to :id and generates the URL.
  3. Sends a PUT request to the URL with $scope.entry as the post body.

Similarly, if you want to delete an entry it can be done as following:

$scope.entry = Movie.get({ id: $ }, function() {
  // $scope.entry is fetched from server and is an instance of Entry
  $ = 'something else';
  $scope.entry.$delete(function() {
    //gone forever!

It follows the same steps as above, except the request type is DELETE instead of PUT.

We have covered all the operations in a CRUD, but left with a small thing. The $resource function also has an optional fourth parameter. This is a hash with custom settings. Currently, there is only one setting available which is stripTrailingSlashes. By default this is set to true, which means trailing slashes will be removed from the URL you pass to $resource(). If you want to turn this off you can do so like this:

angular.module('').factory('Entry', function($resource) {
  return $resource('/api/entries/:id', { id: '@_id' }, {
    update: {
      method: 'PUT' // this method issues a PUT request
  }, {
    stripTrailingSlashes: false

By the way, I didn’t cover each and every thing about $resource. What we covered here are the basics that will help you get started with CRUD apps easily. If you want to explore $resource in detail, you can go through the documentation.

Building a Movie App

To reinforce the concepts of $resource let’s build an app for movie lovers. This is going to be a SPA where users can add a new movie to our database, update an existing movie, and finally delete one. We will use $resource to interact with the REST API. You can check out a live demo of what we are going to build here.

Just note that the API I have built is CORS enabled, so it is possible for you to create an Angular app separately and use the URL as the API. You can develop the Angular app and play around with it without worrying about the backend.


I have created a RESTful backend using Node and Express. Take a look at the following screenshot to get to know the API.


Directory Structure

Let’s start with the following directory structure for our AngularJS app:


Just note that we will be using Angular UI Router for routing.

Creating Our Service to Interact with REST Endpoints

As discussed in previous sections we will create a custom service that will use $resource internally to interact with the REST API. The service is defined in js/services.js.


angular.module('', []).factory('Movie', function($resource) {
  return $resource('', { id: '@_id' }, {
    update: {
      method: 'PUT'

The name of our factory is Movie. As we are using MongoDB, each movie instance has a property called _id. The rest is simple and straightforward.

Now that we have our service ready let’s build views and controllers.

index.html : Building the App Entry Page

The index.html is our app entry point. To start we need to include all the required scripts and stylesheets in this page. We will use Bootstrap to quickly create the layout. Here is the content of index.html.

<!DOCTYPE html>
  <html data-ng-app="movieApp">
  <head lang="en">
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <base href="/"/>
    <title>The Movie App</title>
    <link rel="stylesheet" type="text/css" href="css/bootstrap.min.css"/>
    <link rel="stylesheet" type="text/css" href="css/app.css"/>
    <nav class="navbar navbar-default" role="navigation">
      <div class="container-fluid">
        <div class="navbar-header">
          <a class="navbar-brand" ui-sref="movies">The Movie App</a>
        <div class="collapse navbar-collapse">
          <ul class="nav navbar-nav">
            <li class="active"><a ui-sref="movies">Home</a></li>
    <div class="container">
      <div class="row top-buffer">
        <div class="col-xs-8 col-xs-offset-2">
          <div ui-view></div> <!-- This is where our views will load -->
    <script type="text/javascript" src="lib/angular.min.js"></script>
    <script type="text/javascript" src="js/app.js"></script>
    <script type="text/javascript" src="js/controllers.js"></script>
    <script type="text/javascript" src="js/services.js"></script>
    <script type="text/javascript" src="lib/angular-ui-router.min.js"></script>
    <script type="text/javascript" src="lib/angular-resource.min.js"></script>

The markup is pretty self explanatory. Just pay special attention to <div ui-view></div>. The ui-view directive comes from UI Router module and acts as a container for our views.

Creating Main Module and States

Our main module and states are defined in js/app.js:


angular.module('movieApp', ['ui.router', 'ngResource', 'movieApp.controllers', '']);

angular.module('movieApp').config(function($stateProvider) {
  $stateProvider.state('movies', { // state for showing all movies
    url: '/movies',
    templateUrl: 'partials/movies.html',
    controller: 'MovieListController'
  }).state('viewMovie', { //state for showing single movie
    url: '/movies/:id/view',
    templateUrl: 'partials/movie-view.html',
    controller: 'MovieViewController'
  }).state('newMovie', { //state for adding a new movie
    url: '/movies/new',
    templateUrl: 'partials/movie-add.html',
    controller: 'MovieCreateController'
  }).state('editMovie', { //state for updating a movie
    url: '/movies/:id/edit',
    templateUrl: 'partials/movie-edit.html',
    controller: 'MovieEditController'
}).run(function($state) {
  $state.go('movies'); //make a transition to movies state when app starts

So, our application has the following four states:

  1. movies
  2. viewMovie
  3. newMovie
  4. editMovie

Each state is composed of a url, templateUrl and controller. Also note that when our main module is loaded we make a transition to state movies showing all the movies in our system. Take a look at the following screenshot to know which state corresponds to what URL.

State to Resource Mapping

Creating Templates

All of our templates are inside partials. Let’s see what each of them does!


_form.html contains a simple form which allows users to enter data. Note that this form will be included by movie-add.html and movie-edit.html because both of them accept inputs from users.

Here is the content of _form.html:

<div class="form-group">
  <label for="title" class="col-sm-2 control-label">Title</label>
  <div class="col-sm-10">
    <input type="text" ng-model="movie.title" class="form-control" id="title" placeholder="Movie Title Here"/>
<div class="form-group">
  <label for="year" class="col-sm-2 control-label">Release Year</label>
  <div class="col-sm-10">
    <input type="text" ng-model="movie.releaseYear" class="form-control" id="year" placeholder="When was the movie released?"/>
<div class="form-group">
  <label for="director" class="col-sm-2 control-label">Director</label>
  <div class="col-sm-10">
    <input type="text" ng-model="movie.director" class="form-control" id="director" placeholder="Who directed the movie?"/>
<div class="form-group">
  <label for="plot" class="col-sm-2 control-label">Movie Genre</label>
  <div class="col-sm-10">
    <input type="text" ng-model="movie.genre" class="form-control" id="plot" placeholder="Movie genre here"/>
<div class="form-group">
  <div class="col-sm-offset-2 col-sm-10">
    <input type="submit" class="btn btn-primary" value="Save"/>

The template uses ng-model to bind various movie details to different properties of scope model movie.


This template is used to accept user inputs and add a new movie to our system. Here is the content:

<form class="form-horizontal" role="form" ng-submit="addMovie()">
  <div ng-include="'partials/_form.html'"></div>

When the form is submitted the function addMovie() of the scope is called which in turn sends a POST request to server to create a new movie.


This template is used to accept user inputs and update an existing movie in our system.

<form class="form-horizontal" role="form" ng-submit="updateMovie()">
  <div ng-include="'partials/_form.html'"></div>

Once the form is submitted the scope function updateMovie() is called which issues a PUT request to server to update a movie.


This template is used to show details about a single movie. The content looks like following:

<table class="table movietable">
    <td><h3>Details for {{movie.title}}</h3></td>
    <td>Movie Title</td>
    <td>Release Year</td>
    <td>Movie Genre</td>
  <a class="btn btn-primary" ui-sref="editMovie({id:movie._id})">Edit</a>

In the end there is an edit button. Once clicked it changes the state to editMovie with the movie id in the $stateParams.


This template displays all the movies in the system.

<a ui-sref="newMovie" class="btn-primary btn-lg nodecoration">Add New Movie</a>

<table class="table movietable">
    <td><h3>All Movies</h3></td>
  <tr ng-repeat="movie in movies">
      <a class="btn btn-primary" ui-sref="viewMovie({id:movie._id})">View</a>
      <a class="btn btn-danger"  ng-click="deleteMovie(movie)">Delete</a>

It loops through all the movie objects obtained from the API and displays the details. There is also a button Add New Movie which changes the state to newMovie. As a result a new route loads and we can create a new movie entry.

For each movie there are two buttons, View and Delete. View triggers a state transition so that the details for the movie are displayed. Delete button deletes the movie permanently.

Creating Controllers

Each state has a controller. So, in total we have four controllers for four states. All the controllers go into js/controllers.js. The controllers just utilize our custom service Movie and work the way we have discussed above. So, here is how our controllers look.


angular.module('movieApp.controllers', []).controller('MovieListController', function($scope, $state, popupService, $window, Movie) {
  $scope.movies = Movie.query(); //fetch all movies. Issues a GET to /api/movies

  $scope.deleteMovie = function(movie) { // Delete a movie. Issues a DELETE to /api/movies/:id
    if (popupService.showPopup('Really delete this?')) {
      movie.$delete(function() {
        $window.location.href = ''; //redirect to home
}).controller('MovieViewController', function($scope, $stateParams, Movie) {
  $ = Movie.get({ id: $ }); //Get a single movie.Issues a GET to /api/movies/:id
}).controller('MovieCreateController', function($scope, $state, $stateParams, Movie) {
  $ = new Movie();  //create new movie instance. Properties will be set via ng-model on UI

  $scope.addMovie = function() { //create a new movie. Issues a POST to /api/movies
    $$save(function() {
      $state.go('movies'); // on success go back to home i.e. movies state.
}).controller('MovieEditController', function($scope, $state, $stateParams, Movie) {
  $scope.updateMovie = function() { //Update the edited movie. Issues a PUT to /api/movies/:id
    $$update(function() {
      $state.go('movies'); // on success go back to home i.e. movies state.

  $scope.loadMovie = function() { //Issues a GET request to /api/movies/:id to get a movie to update
    $ = Movie.get({ id: $ });

  $scope.loadMovie(); // Load a movie which can be edited on UI


Assuming the app is deployed under localhost/movieApp, you can access it at http://localhost/movieApp/index.html. If you are a movie lover, you can start adding your favorite movies too! The source code for the app developd in this article is available on GitHub for download.

I hope you enjoyed this tutorial! Feel free to comment if you’d like to add something.

Sandeep is the Co-Founder of Hashnode. He loves startups and web technologies.

Integromat Tower Ad