Create a Reusable Service

In the previous tutorial, you defined a service, which defined its own entity. When modeling with CDS the best practice is to separate services from the domain model.

Therefore, you will now define the complete domain model that is used by the products service. The domain model is stored in the db folder of your CAP application.

1. Go to your db folder and create a file called schema.cds.

   

2. Add the following code to your newly created schema.cds file and make sure you Save the file:

       namespace sap.capire.products;
   
       using { Currency, cuid, managed, sap.common.CodeList } from '@sap/cds/common';
   
       entity Products : cuid, managed {
           title    : localized String(111);
           descr    : localized String(1111);
           stock    : Integer;
           price    : Decimal(9,2);
           currency : Currency;
           category : Association to Categories;
       }
   
       entity Categories : CodeList {
           key ID   : Integer;
           parent   : Association to Categories;
           children : Composition of many Categories on children.parent = $self;
       }
   

In the first tutorial, you defined a simple service, called AdminService, which directly defined the entity Products. As you now have defined the Products entity in your domain model, the AdminService just needs to expose it. In addition, you defined the Categories entity, which should also be part of your service.

This can be achieved by using projections. Services expose projections of the entities defined in the domain model. These projections can be used to include (and also exclude) only certain elements of an entity or to rename the entity’s elements.

In this example you will use the most simple projection, which exposes the domain model entity without any changes.

1. Go to your srv folder and open the admin-service.cds file.

2. Replace the content with the following code and make sure you Save the file:

   using { sap.capire.products as db } from '../db/schema';
   
   service AdminService {
       entity Products   as projection on db.Products;
       entity Categories as projection on db.Categories;
   }
   

Let’s deploy the domain model to a database. Now, you will use SQLite, a light-weight file-based database, which fits the needs for local development perfectly.

1. First, install SQLite to the project. Go to the terminal where your application is running and use CTRL+C to stop the application.

   Execute the following command in the terminal:

   npm install --save-dev sqlite3
   

2. To initialize the database with the defined domain model, execute the following command in the terminal:

   cds deploy --to sqlite
   

   

   This will create a file called sqlite.db in your project root. The name of this database is defined by an entry in your package.json.

Right now, the Java application itself isn’t aware of the SQLite database.

Configure your Java application to use the sqlite.db database file.

1. Go to srv/src/main/resources, locate, and open the application.yaml file. This file was created when you initialized the application.

2. For the field url, replace the string "jdbc:sqlite::memory:?cache=shared" with a reference to your local database file "jdbc:sqlite:/home/user/projects/products-service/sqlite.db"

3. Set the value of initialization-mode from always to never, because you’ve already initialized the database when running cds deploy --to sqlite.

Your application.yaml file should look like this:

---
spring:
  profiles: default
  datasource:
    url: "jdbc:sqlite:/home/user/projects/products-service/sqlite.db"
    driver-class-name: org.sqlite.JDBC
    initialization-mode: never
    hikari:
      maximum-pool-size: 1

1. Start your application by running mvn spring-boot:run in the terminal and open it in a new tab.

2. Test your application by using Curl from the terminal.

   You can open additional terminals by choosing Terminal > New Terminal from the main menu.

   This request will create multiple, nested categories, at once through a deep insert:

   curl -X POST http://localhost:8080/odata/v4/AdminService/Categories \
   -H "Content-Type: application/json" \
   -d '{"ID": 1, "name": "TechEd", "descr": "TechEd related topics", "children": [{"ID": 10, "name": "CAP Java", "descr": "Run on Java"}, {"ID": 11, "name": "CAP Node.js", "descr": "Run on Node.js"}]}'
   

3. Try to query individual categories, for example by adding the following to the end of your app URL:

   /odata/v4/AdminService/Categories(10)

4. Restart your application by switching to the terminal, using CTRL+C, and running mvn spring-boot:run again.

5. Query the categories again using the URL from step 3. You’ll see that the categories are stored in a persistent database.

6. You can also expand the nested structures. Add the following to the end of your app URL:

   • /odata/v4/AdminService/Categories?$expand=children
   • /odata/v4/AdminService/Categories(10)?$expand=parent
   • /odata/v4/AdminService/Categories(1)?$expand=children

7. Make sure to stop your application after testing it by using CTRL+C.

In the following tutorial, the application will be reused by a bookstore application. The reuse of models can be achieved by publishing NPM modules with the models and defining dependencies to these NPM modules in other applications. There are a two steps we need to perform to prepare the products-service application for reuse.

1. The name of the products-service reuse module, should be @sap/capire-products. Therefore, open the package.json file within the ~/projects/products-service folder and change the value of name field from products-service-cds to @sap/capire-products. If you want to you can also provide a meaningful description in the description field.

   

2. To make it easier to reuse the module, an index.cds file can be added to the products-service. This ensures a better decoupling from other applications.

   Create a new file index.cds in the ~/projects/products-service folder and place the following content inside this file, making sure you Save the file:

   using from './db/schema';
   using from './srv/admin-service';