Chapter 6. REST DSL

1. Click Rest in the top navigation, then Actions, and select + Add Service from the dropdown.
2. Add the book-summary-api.openapi.yaml file to your workspace at the same level as your route file.
3. Click the pencil icon next to Open Api and enter the path to your OpenAPI file (e.g., book-summary-api.openapi.yaml).

4. This adds the REST DSL block with the openApi.specification property:

   - rest:
       id: rest-1736
       openApi:
         specification: book-summary-api.openapi.yaml

1. Reads the OpenAPI file at runtime (the file must be present when running)
2. Creates all REST endpoints defined in the specification
3. Maps operations to direct routes using operationId
4. Builds the complete REST API structure from the specification

1. Replace the timer component: Click on the timer component and replace it with a Direct component.
2. Configure the direct endpoint: In Endpoint Properties > name, enter getBookFunExtract

3. Add removeHeaders processor: Insert a removeHeaders processor between the direct endpoint and the setBody processor.

   • Set the pattern to CamelHttp*
   • This removes all headers starting with CamelHttp that might interfere with the external API call

4. Add first setHeader processor: After removeHeaders, add a setHeader processor

   • Set name to x-rapidapi-host
   • Change the expression type from Simple to Constant
   • Set expression to project-gutenberg-free-books-api1.p.rapidapi.com
   • This sets the RapidAPI host header required by the Gutenberg API

5. Add second setHeader processor: Add another setHeader processor

   • Set name to x-rapidapi-key
   • Keep expression type as Simple
   • Set expression to {{gutenberg.api.key}}
   • Add your API key in the application.properties file in your workspace
   • This sets your API key using a property placeholder for security

6. Add toD processor: Add a toD (dynamic to) processor

   • Set the uri to: https://project-gutenberg-free-books-api1.p.rapidapi.com/books/${header.id}?bridgeEndpoint=true
   • This makes a dynamic HTTP call to the Gutenberg API using the book ID from the path parameter

7. Update setBody processor: Modify the setBody processor

   • Change expression type to JSONPath
   • Set expression to $.results[0].summary
   • This extracts the book summary from the JSON response

8. Update log processor: Modify the log processor

   • Set message to Book summary: ${body}
   • This logs the book summary for debugging and verification

Step 1: Open VS Code Settings

1. Open VS Code Settings:

   • macOS: Press Cmd + , or go to Code > Preferences > Settings
   • Windows/Linux: Press Ctrl + , or go to File > Preferences > Settings

2. Click on the Workspace tab at the top of the settings window (not "User").

   • This ensures settings only apply to this project.
   • Creates a .vscode/settings.json file in your project folder.

Step 2: Configure Kaoto Run Settings

1. In the search bar, type kaoto to filter Kaoto-related settings.

2. Find and configure Kaoto: Run Arguments and Kaoto: Run Folder:

   • Add: --management-port=8080

   • This sets a separate port for JBang management to avoid conflicts

     

Step 3: Reload and Run

1. Reload VS Code: Press Cmd/Ctrl + Shift + P, type "Reload Window", and press Enter.

   • This ensures VS Code picks up the new settings

2. Run the integration: In Kaoto, click the Run button in the folder.

   • Kaoto will start your integration using JBang.

   • You should see output in the terminal showing the integration starting up.

     

1. Open a terminal and run:

   curl http://localhost:8080/books/1342/fun-extract

2. You should receive a JSON response with the book summary for "Pride and Prejudice" (book ID 1342).

1. Frankenstein

   curl http://localhost:8080/books/84/fun-extract

2. The Adventures of Sherlock Holmes

   curl http://localhost:8080/books/1661/fun-extract

1. In the Kaoto extension, click in Import next to OpenAPI and it will open the REST Import Wizard.

   
2. In the Kaoto Import Wizard, select Upload file as the source.
3. Click Choose file and select the book-summary-api.openapi.yaml file you downloaded in the previous section.

4. The wizard will parse the file and show all discovered operations.

   
5. You should see the GET /books/{id}/fun-extract operation listed.

6. Configure the following options (both should be checked):

   • Create REST DSL operations - Generates REST endpoint definitions

   • Create routes with direct endpoints - Generates route stubs for each operation

     

7. Choose the folder to save the information and then give a name to the route.

   

1. REST DSL definition - Complete endpoint with parameters and responses
2. Direct route stub - A placeholder route ready for implementation

1. Open the route file from the API-first documentation example (e.g., book-api.camel.yaml)
2. In Kaoto’s Design view, locate the route-getBookFunExtract route

3. Right-click on the route (not on individual steps) and select Copy

   

1. Switch back to your code-first route file
2. In the Design view, find the route-getBookFunExtract route

3. Right-click on the Design canvas itself (not on the setBody step) and select Paste. This pastes the complete route from the API-first route.

   

1. In the Design view, locate the removeHeaders step
2. Click and drag the removeHeaders step
3. Drop it directly after the direct component (at the beginning of the route)
4. Do the same with the other components.

1. Delete the placeholder setBody step at the end (the one with "Operation getBookFunExtract not yet implemented")
2. Delete any remaining copied direct component

1. Hover over the arrow after the setBody step (the one that extracts $.results[0].summary)
2. Click the + button that appears
3. In the catalog search, type openai
4. Select OpenAI component

5. Configure in Kaoto’s form:

   Property	Value
   Operation	chat-completion
   Api Key	OLLAMA-LOCAL-KEY
   Base Url	http://localhost:11434/v1
   Model	granite4:tiny-h
   System Message	Summarize this text into a couple of short sentences and give it a funny twist

6. This sends the book summary to your local Ollama instance running the Granite 4 model for AI-powered fun extracts.

   Note
   1. For more details on configuring OpenAI in Kaoto, refer to the Quickstart guide.
7. The OpenAI component is now inserted between setBody and log, completing your route.

1. Make sure Ollama is running with the Granite 4 model
2. In Kaoto’s toolbar, click the Run button. Make sure your application.properties and the new route are in the same folder.
3. Kaoto will start your integration using JBang
4. Watch the Design view to see your routes activate

1. Frankenstein

   curl http://localhost:8080/books/84/fun-extract

2. The Adventures of Sherlock Holmes

   curl http://localhost:8080/books/1661/fun-extract

1. In VS Code, open the route file from Part 2 (e.g., rest-api.camel.yaml)
2. Kaoto will automatically open, showing the Canvas view

1. In the Kaoto toolbar, click the REST DSL button

2. Kaoto’s REST Editor will open, displaying your REST structure in a tree view

   

3. You should see in the tree:

   • Your REST service
   • The existing GET /books/{id}/fun-extract endpoint
   • The associated direct route

1. In the REST block in the tree, click Actions
2. Select Add Operation

3. In Kaoto’s modal dialog, configure:

   Property	Value
   HTTP Method	GET
   Path	/books/popular
   Operation ID	listBooks

4. Click Add to create the operation in the tree.

   

1. Click + next to Response Message

2. Configure the first response in the form:

   • Code: 200
   • Message: Books retrieved successfully
   • Content Type: application/json
3. Add a new response again

4. Configure the error response:

   • Code: 500
   • Message: Server error during processing

5. Current state of the route file:

   - rest:
       id: rest-1775038763756
       get:
         - id: getBookFunExtract
           path: /books/{id}/fun-extract
           routeId: route-getBookFunExtract
           to: direct:getBookFunExtract
           description: Fetches a book from Project Gutenberg and generates an AI extract
             using OpenAI
           produces: application/json
           param:
             - name: id
               type: path
               required: true
               description: Project Gutenberg book ID (e.g., 11 for Alice's Adventures in
                 Wonderland)
               dataType: integer
           responseMessage:
             - code: "200"
               message: Book fun extract generated successfully
               contentType: application/json
             - code: "404"
               message: Book not found in Project Gutenberg
             - code: "500"
               message: Server error during processing
         - id: listBooks
           path: /books/popular
           to:
             uri: direct
             parameters:
               name: direct-listBooks
           produces: application/json
           description: Lists popular books from Project Gutenberg
           responseMessage:
             - message: Server error during processing
               code: "500"
             - message: Books retrieved successfully
               code: "200"
               contentType: application/json
   - route:
       id: route-getBookFunExtract
       from:
         uri: direct:getBookFunExtract
         id: direct-from-getBookFunExtract
         steps:
           - removeHeaders:
               id: removeHeaders-4268-1881
               pattern: CamelHttp*
           - setHeader:
               id: setHeader-3265-3267
               name: x-rapidapi-host
               constant:
                 expression: project-gutenberg-free-books-api1.p.rapidapi.com
           - setHeader:
               id: setHeader-2139-3021
               simple:
                 expression: "{{gutenberg.api.key}}"
               name: x-rapidapi-key
           - toD:
               id: toD-4177-4046
               uri: https://project-gutenberg-free-books-api1.p.rapidapi.com/books/${header.id}?bridgeEndpoint=true
               parameters: {}
           - setBody:
               id: setBody-2130-2169
               jsonpath:
                 expression: $.results[0].summary
           - to:
               id: to-3162
               uri: openai
               parameters:
                 operation: chat-completion
                 apiKey: OLLAMA-LOCAL-KEY
                 baseUrl: http://localhost:11434/v1
                 model: granite4:tiny-h
                 systemMessage: Summarize this text into a couple of short sentences and give it
                   a funny twist
           - log:
               message: '"Book summary: ${body}"'

1. Next to Endpoint Name in Kaoto’s form, you’ll see a Create Route button
2. Click Create Route

3. Kaoto will generate a new direct route stub for direct:listBooks and show it in the Canvas

   

1. In Kaoto’s Canvas view, find the route-listBooks route
2. You’ll see it starts with a direct component

1. Navigate to the route-getBookFunExtract route in Canvas
2. Select the removeHeaders step

3. Right-click over the component and select Duplicate

   
4. Drag the duplicated step to the route-listBooks route and drop it after the direct component
5. Repeat for both setHeader steps (x-rapidapi-host and x-rapidapi-key)

1. Click Add step in the Canvas
2. Search for to in the catalog (not toD - we don’t need dynamic URI here)
3. Select To
4. Configure: URI = https://project-gutenberg-free-books-api1.p.rapidapi.com/books?bridgeEndpoint=true

1. Click Add step in the Canvas
2. Search for setBody in the catalog
3. Select Set Body

4. Configure:

   • Expression Type: JSONPath
   • Expression: $.results[*].['title', 'authors']

1. Click Add step in the Canvas
2. Search for marshal in the catalog
3. Select Marshal
4. Select JSON as the data format
5. Enable Pretty Print: true

1. Click Add step in the Canvas
2. Search for log in the catalog
3. Select Logger
4. Configure: Message = Books list: ${body}Complete Route

1. Ensure your application.properties file has your RapidAPI key
2. In Kaoto, click the Run: folder button in the folder
3. Kaoto will start your integration using JBang