How to run embedded OrderService?

cds deploy excludes its definitions if `OrdersService` is marked
as external.  How would we tell it to include them in the embedded case?

.github/workflows/node.js.yml

@@ -5,9 +5,9 @@ name: CI
 
 on:
   push:
-    branches: [ main ]
+    branches: [ master ]
   pull_request:
-    branches: [ main ]
+    branches: [ master ]
 
 jobs:
   build:

.gitignore

@@ -17,4 +17,3 @@ reviews/msg-box
 reviews/db/test.db
 
 *.openapi3.json
-sqlite.db

.registry/server.js

@@ -1,22 +1,17 @@
 const { exec } = require ('child_process')
-const isWin = process.platform === 'win32'
 const express = require ('express')
 const fs = require ('fs')
 const app = express()
 
 const { PORT=4444 } = process.env
-const [,,port=PORT,scope='@capire'] = process.argv
+const [,,port=PORT] = process.argv
 const cwd = __dirname
 
-// clean up on start (exit handler might not complete on Windows)
-exec(isWin ? 'del *.tgz' : 'rm *.tgz', {cwd})
-
-
 app.use('/-/:tarball', (req,res,next) => {
   console.debug ('GET', req.params)
   try {
     const { tarball } = req.params
-    const [, pkg ] = /^\w+-(\w+)/.exec(tarball)
+    const [, pkg ] = /^capire-(\w+)/.exec(tarball)
     fs.lstat(tarball,(err => {
       if (err) exec(`npm pack ../${pkg}`,{cwd},next)
       else next()
@@ -30,14 +25,12 @@ app.use('/-/:tarball', (req,res,next) => {
 app.use('/-', express.static(__dirname))
 
 app.get('/*', (req,res)=>{
-  const urlRegex = /^\/(@\w+)\/(\w+)/
   const url = decodeURIComponent(req.url)
   console.debug ('GET',url)
   try {
-    if (!urlRegex.test(url))  return res.sendStatus(404)
+    const [, capire, pkg ] = /^\/(@capire)\/(\w+)/.exec(url)
-    const [, scpe, pkg ] = urlRegex.exec(url)
+    const package = require (`${capire}/${pkg}/package.json`)
-    const package = require (`${scpe}/${pkg}/package.json`)
+    const tarball = `capire-${pkg}-${package.version}.tgz`
-    const tarball = `${scpe.slice(1)}-${pkg}-${package.version}.tgz`
     // https://github.com/npm/registry/blob/master/docs/responses/package-metadata.md
     res.json({
       "name": package.name,
@@ -49,30 +42,29 @@ app.get('/*', (req,res)=>{
           "name": package.name,
           "version": package.version,
           "dist": {
-            "tarball": `/-/${tarball}`
+            "tarball": `http://localhost:${port}/-/${tarball}`
           },
         }
       },
     })
   } catch (e) {
-    if (e.code === 'MODULE_NOT_FOUND')  return res.sendStatus(404)
+    console.error(e)
-    console.error(e);  throw e
+    res.sendStatus(404)
   }
 })
 
-const server = app.listen(port, ()=>{
+app.listen(port, ()=>{
-  const url = `http://localhost:${server.address().port}`
+  console.log (`npm set @capire:registry=http://localhost:${port}`)
-  console.log (`npm set ${scope}:registry=${url}`)
+  console.log (`@capire registry listening on http://localhost:${port}`)
-  exec(`npm set ${scope}:registry=${url}`)
+  exec(`npm set @capire:registry=http://localhost:${port}`)
-  console.log (`${scope} registry listening on ${url}`)
 })
 
-
 const _exit = ()=>{
-  server.close()
+  console.log ('\nnpm conf rm @capire:registry')
-  exec(`npm conf rm "${scope}:registry"`, ()=> { process.exit() })
+  exec('npm conf rm @capire:registry')
+  exec('rm *.tgz')
+  process.exit()
 }
-
 process.on ('SIGTERM',_exit)
 process.on ('SIGHUP',_exit)
 process.on ('SIGINT',_exit)

.tours/db-native.tour

@@ -105,5 +105,5 @@
       "description": "### Summary\n\nThat's it!  You have seen: \n- How to integrate database-specific functions in a CDS model.\n- How to switch between the two implementations for SQLite and SAP HANA."
     }
   ],
-  "ref": "main"
+  "ref": "master"
 }

README.md

@@ -17,7 +17,7 @@ Find here a collection of samples for the [SAP Cloud Application Programming Mod
 
 ### Download
 
-If you've [Git](https://git-scm.com/downloads) installed, clone this repo as shown below, otherwise [download as ZIP file](archive/main.zip).
+If you've [Git](https://git-scm.com/downloads) installed, clone this repo as shown below, otherwise [download as ZIP file](archive/master.zip).
 
 ```sh
 git clone https://github.com/sap-samples/cloud-cap-samples samples

bookshop/app/vue/app.js

@@ -10,7 +10,7 @@ const books = new Vue ({
     data: {
         list: [],
         book: undefined,
-        order: { quantity:1, succeeded:'', failed:'' }
+        order: { amount:1, succeeded:'', failed:'' }
     },
 
     methods: {
@@ -26,18 +26,18 @@ const books = new Vue ({
             const book = books.book = books.list [eve.currentTarget.rowIndex-1]
             const res = await GET(`/Books/${book.ID}?$select=descr,stock,image`)
             Object.assign (book, res.data)
-            books.order = { quantity:1 }
+            books.order = { amount:1 }
             setTimeout (()=> $('form > input').focus(), 111)
         },
 
         async submitOrder () {
-            const {book,order} = books, quantity = parseInt (order.quantity) || 1 // REVISIT: Okra should be less strict
+            const {book,order} = books, amount = parseInt (order.amount) || 1 // REVISIT: Okra should be less strict
             try {
-                const res = await POST(`/submitOrder`, { quantity, book: book.ID })
+                const res = await POST(`/submitOrder`, { amount, book: book.ID })
                 book.stock = res.data.stock
-                books.order = { quantity, succeeded: `Successfully ordered ${quantity} item(s).` }
+                books.order = { amount, succeeded: `Successfully ordered ${amount} item(s).` }
             } catch (e) {
-                books.order = { quantity, failed: e.response.data.error.message }
+                books.order = { amount, failed: e.response.data.error.message }
             }
         }
 

bookshop/app/vue/index.html

@@ -34,7 +34,7 @@
             <td>{{ book.author }}</td>
             <td>{{ book.genre.name }}</td>
             <td class="rating-stars">
-                {{ ('★'.repeat(Math.round(book.rating))+'☆☆☆☆☆').slice(0,5) }} ({{ book.numberOfReviews }})
+                {{ ('★'.repeat(Math.round(book.rating))+'☆☆☆☆☆').slice(0,5) }}
             </td>
             <td>{{ book.currency && book.currency.symbol }} {{ book.price }}</td>
         </tr>
@@ -48,7 +48,7 @@
             &nbsp;&nbsp; {{ book.stock }} in stock
         </label>
         <form @submit.prevent="submitOrder" style="float:right; display:flex; flex-direction:row-reverse">
-            <input type="number" v-model="order.quantity" v-bind:class="{ failed: order.failed }" style="width:5em">
+            <input type="number" v-model="order.amount" v-bind:class="{ failed: order.failed }" style="width:5em">
             <input type="submit" value="Order:" class="muted-button">
         </form>
         <h4> {{ book.title }} </h4>

bookshop/db/schema.cds

@@ -1,7 +1,7 @@
-using { Currency, managed, sap, extensible } from '@sap/cds/common';
+using { Currency, managed, sap } from '@sap/cds/common';
 namespace sap.capire.bookshop;
 
-entity Books : managed, extensible {
+entity Books : managed {
   key ID : Integer;
   title  : localized String(111);
   descr  : localized String(1111);
@@ -13,7 +13,7 @@ entity Books : managed, extensible {
   image : LargeBinary @Core.MediaType : 'image/png';
 }
 
-entity Authors : managed, extensible {
+entity Authors : managed {
   key ID : Integer;
   name   : String(111);
   dateOfBirth  : Date;

bookshop/index.js

@@ -1,2 +1 @@
-const { CatalogService } = require('./srv/cat-service')
+exports.CatalogService = require('./srv/cat-service')
-module.exports = { CatalogService }

bookshop/srv/cat-service.cds

@@ -11,6 +11,6 @@ service CatalogService @(path:'/browse') {
   } excluding { createdBy, modifiedBy };
 
   @requires: 'authenticated-user'
-  action submitOrder ( book: Books:ID, quantity: Integer ) returns { stock: Integer };
+  action submitOrder ( book: Books:ID, amount: Integer ) returns { stock: Integer };
-  event OrderedBook : { book: Books:ID; quantity: Integer; buyer: String };
+  event OrderedBook : { book: Books:ID; amount: Integer; buyer: String };
 }

bookshop/srv/cat-service.js

@@ -5,14 +5,14 @@ class CatalogService extends cds.ApplicationService { init(){
 
   // Reduce stock of ordered books if available stock suffices
   this.on ('submitOrder', async req => {
-    const {book,quantity} = req.data
+    const {book,amount} = req.data
     let {stock} = await SELECT `stock` .from (Books,book)
-    if (stock >= quantity) {
+    if (stock >= amount) {
-      await UPDATE (Books,book) .with (`stock -=`, quantity)
+      await UPDATE (Books,book) .with (`stock -=`, amount)
-      await this.emit ('OrderedBook', { book, quantity, buyer:req.user.id })
+      await this.emit ('OrderedBook', { book, amount, buyer:req.user.id })
       return { stock }
     }
-    else return req.error (409,`${quantity} exceeds stock for book #${book}`)
+    else return req.error (409,`${amount} exceeds stock for book #${book}`)
   })
 
   // Add some discount for overstocked books

bookshop/test/requests.http

@@ -71,7 +71,7 @@ POST {{server}}/browse/submitOrder
 Content-Type: application/json
 {{me}}
 
-{ "book":201, "quantity":5 }
+{ "book":201, "amount":5 }
 
 
 ### ------------------------------------------------------------------------

fiori/app/admin-fiori.html

@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
-  <head>
+<head>
+
 	<meta http-equiv="X-UA-Compatible" content="IE=edge" />
 	<meta http-equiv="Content-Type" content="text/html;charset=UTF-8" />
 	<meta name="viewport" content="width=device-width, initial-scale=1.0" />
@@ -14,68 +15,41 @@
 					title: "Browse Books",
 					description: "w/ SAP Fiori Elements",
 					additionalInformation: "SAPUI5.Component=bookshop",
-            applicationType: "URL",
+					applicationType : "URL",
 					url: "/browse/webapp",
-            navigationMode: "embedded",
+					navigationMode: "embedded"
 				},
 				"manage-books": {
 					title: "Manage Books",
 					description: "w/ SAP Fiori Elements",
 					additionalInformation: "SAPUI5.Component=admin",
-            applicationType: "URL",
+					applicationType : "URL",
 					url: "/admin/webapp",
-            navigationMode: "embedded",
+					navigationMode: "embedded"
 				},
 				"manage-orders": {
 					title: "Manage Orders",
 					description: "w/ SAP Fiori Elements",
 					additionalInformation: "SAPUI5.Component=orders",
-            applicationType: "URL",
+					applicationType : "URL",
 					url: "/orders/webapp",
-            navigationMode: "embedded",
+					navigationMode: "embedded"
-          },
+				}
-        },
+			}
-        bootstrapPlugins: {
-          RuntimeAuthoringPlugin: {
-            component: "sap.ushell.plugins.rta",
-            config: {
-              validateAppVersion: false,
-            },
-          },
-          PersonalizePlugin: {
-            component: "sap.ushell.plugins.rta-personalize",
-            config: {
-              validateAppVersion: false,
-            },
-          },
-        },
 		};
 	</script>
 
-    <script
+	<script id="sap-ushell-bootstrap" src="https://sapui5.hana.ondemand.com/test-resources/sap/ushell/bootstrap/sandbox.js"></script>
-      id="sap-ushell-bootstrap"
+	<script id="sap-ui-bootstrap" src="https://sapui5.hana.ondemand.com/resources/sap-ui-core.js"
-      src="https://sapui5nightly.int.sap.eu2.hana.ondemand.com/test-resources/sap/ushell/bootstrap/sandbox.js"
-    ></script>
-    <script
-      id="sap-ui-bootstrap"
-      src="https://sapui5nightly.int.sap.eu2.hana.ondemand.com/resources/sap-ui-core.js"
     	data-sap-ui-libs="sap.m, sap.ushell, sap.collaboration, sap.ui.layout"
     	data-sap-ui-compatVersion="edge"
     	data-sap-ui-theme="sap_fiori_3"
     	data-sap-ui-frameOptions="allow"
-      data-sap-ui-bindingSyntax="complex"
 	></script>
 	<script>
-      sap.ui
+		sap.ui.getCore().attachInit(()=> sap.ushell.Container.createRenderer().placeAt("content"))
-        .getCore()
-        .attachInit(() =>
-          sap.ushell.Container.createRenderer().placeAt("content")
-        );
-      sap.ui
-        .getCore()
-        .getConfiguration()
-        .setFlexibilityServices([{ connector: "SessionStorageConnector" }]);
 	</script>
-  </head>
+
-  <body class="sapUiBody" id="content"></body>
+</head>
+<body class="sapUiBody" id="content"></body>
 </html>

fiori/app/admin/fiori-service.cds

@@ -1,5 +1,4 @@
-using { AdminService } from '../../db/schema';
+using { AdminService, sap.capire.bookshop } from '../../db/schema';
-using from '../common'; // to help UI linter get the complete annotations
 
 ////////////////////////////////////////////////////////////////////////////
 //
@@ -87,8 +86,9 @@ annotate AdminService.Books.texts with @(
 annotate AdminService.Books.texts {
 	locale @ValueList:{entity:'Languages',type:#fixed}
 }
-// In addition we need to expose Languages through AdminService as a target for ValueList
+// In addition we need to expose Languages and Books.texts through AdminService
 using { sap } from '@sap/cds/common';
 extend service AdminService {
-	@readonly entity Languages as projection on sap.common.Languages;
+	entity Languages as projection on sap.common.Languages;
+	entity Books.texts as projection on bookshop.Books.texts;
 }

fiori/app/admin/webapp/manifest.json

@@ -22,10 +22,6 @@
         }
     },
     "sap.ui5": {
-        "flexEnabled": true,
-        "config": {   
-            "experimentalCAPScenario": true
-        },
         "dependencies": {
             "libs": {
                 "sap.fe.templates": {}

fiori/app/browse/webapp/manifest.json

@@ -22,7 +22,6 @@
     }
   },
   "sap.ui5": {
-    "flexEnabled": true,
     "dependencies": {
       "libs": {
         "sap.fe.templates": {}

fiori/package.json

@@ -26,23 +26,18 @@
         "kind": "odata",
         "model": "@capire/reviews"
       },
-      "OrdersService": {
+      "--> OrdersService": {
         "kind": "odata",
         "model": "@capire/orders"
       },
-      "extensibility": {
-        "kind": "uiflex"
-      },
       "db": {
-        "kind": "sqlite",
+        "kind": "sql",
-        "credentials": {
+        "[development]": {
-          "database": "sqlite.db"
+          "model": "db/sqlite"
-        }
         },
-      "messaging": {
+        "[production]": {
-        "[development]": { "kind": "file-based-messaging" },
+          "model": "db/hana"
-        "[hybrid]": { "kind": "enterprise-messaging-shared" },
+        }
-        "kind": "enterprise-messaging"
       }
     }
   }

fiori/server.js

@@ -10,11 +10,9 @@ cds.once('bootstrap',(app)=>{
 cds.once('served', require('./srv/mashup'))
 
 // Swagger UI - see https://cap.cloud.sap/docs/advanced/openapi
-try {
+if (process.env.NODE_ENV !== 'production') {
   const cds_swagger = require ('cds-swagger-ui-express')
   cds.once ('bootstrap', app => app.use (cds_swagger()) )
-} catch (err) {
-  if (err.code !== 'MODULE_NOT_FOUND')  throw err
 }
 
 

fiori/srv/mashup.cds

@@ -12,7 +12,6 @@ using { sap.capire.bookshop.Books } from '@capire/bookshop';
 using { ReviewsService.Reviews } from '@capire/reviews';
 extend Books with {
   reviews : Composition of many Reviews on reviews.subject = $self.ID;
-  numberOfReviews : Integer;
   rating  : Decimal;
 }
 

fiori/srv/mashup.js

@@ -27,11 +27,11 @@ module.exports = async()=>{ // called by server.js
   // Create an order with the OrdersService when CatalogService signals a new order
   //
   CatalogService.on ('OrderedBook', async (msg) => {
-    const { book, quantity, buyer } = msg.data
+    const { book, amount, buyer } = msg.data
     const { title, price } = await db.tx(msg).read (Books, book, b => { b.title, b.price })
     return OrdersService.tx(msg).create ('Orders').entries({
       OrderNo: 'Order at '+ (new Date).toLocaleString(),
-      Items: [{ product:{ID:`${book}`}, title, price, quantity }],
+      Items: [{ product:{ID:`${book}`}, title, price, amount }],
       buyer, createdBy: buyer
     })
   })
@@ -41,8 +41,8 @@ module.exports = async()=>{ // called by server.js
   //
   ReviewsService.on ('reviewed', (msg) => {
     console.debug ('> received:', msg.event, msg.data)
-    const { subject, count, rating } = msg.data
+    const { subject, rating } = msg.data
-    return UPDATE(Books,subject).with({ numberOfReviews:count, rating })
+    return UPDATE(Books,subject).with({rating})
     // ^ Note: the framework will execute this and take care for db.tx
   })
 
@@ -51,9 +51,9 @@ module.exports = async()=>{ // called by server.js
   //
   OrdersService.on ('OrderChanged', (msg) => {
     console.debug ('> received:', msg.event, msg.data)
-    const { product, deltaQuantity } = msg.data
+    const { product, deltaAmount } = msg.data
     return UPDATE (Books) .where ('ID =', product)
-    .and ('stock >=', deltaQuantity)
+    .and ('stock >=', deltaAmount)
-    .set ('stock -=', deltaQuantity)
+    .set ('stock -=', deltaAmount)
   })
 }

fiori/test.http

@@ -1,14 +0,0 @@
-# Add integer extension field to Books
-POST http://localhost:4004/extensibility/addExtension
-Content-Type: application/json
-
-{
-  "extensions": [
-    "{\"extend\":\"AdminService.Books\",\"elements\":{\"neuesFeld2\":{\"type\":\"cds.String\", \"default\":\"hallo\"}}}"
-  ]
-}
-
-###
-    # { "extend": "AdminService.Books", "elements":{
-    #   "abc":{"type":"cds.Integer"}
-    # }},

hello/README.md

@@ -1,15 +0,0 @@
-# Hello World Getting Started Sample
-
-## Next Steps
-
-- To run the JavaScript implementation, open a new terminal and run `cds watch`.
-- To run the TypeScript implementation, open a new terminal and run `cds-ts watch`.
-
-Then call the service at: http://localhost:4004/say/hello(to='world')
-
-## Learn More
-
-Learn more about:
-
-- [Hello World!](https://cap.cloud.sap/docs/get-started/hello-world)
-- [Using TypeScript](https://cap.cloud.sap/docs/get-started/using-typescript)

hello/package.json

@@ -3,8 +3,8 @@
   "version": "1.0.0",
   "scripts": {
     "test": "npx jest --silent",
-    "start": "cds serve srv/world.cds",
+    "watch": "cds serve world.cds",
-    "start:ts": "cds-ts serve srv/world.cds"
+    "watch:ts": "cds-ts serve world.cds"
   },
   "devDependencies": {
     "@types/jest": "^26.0.23",
@@ -25,30 +25,5 @@
         }
       }
     }
-  },
-  "eslintConfig": {
-    "extends": "eslint:recommended",
-    "env": {
-      "es2020": true,
-      "node": true,
-      "jest": true,
-      "mocha": true
-    },
-    "globals": {
-      "SELECT": true,
-      "INSERT": true,
-      "UPDATE": true,
-      "DELETE": true,
-      "CREATE": true,
-      "DROP": true,
-      "CDL": true,
-      "CQL": true,
-      "CXL": true,
-      "cds": true
-    },
-    "rules": {
-      "no-console": "off",
-      "require-atomic-updates": "off"
-    }
   }
 }

hello/srv/world.ts

@@ -1,5 +0,0 @@
-module.exports = class say {
-    hello(req: any) {
-        return `Hello ${req.data.to} from a TypeScript file!`
-    }
-}

hello/test/hello-world-ts.test.ts

@@ -2,7 +2,7 @@ process.env.CDS_TYPESCRIPT = 'true';
 import * as cds from '@sap/cds';
 
 //@ts-ignore
-const {GET} = cds.test.in(__dirname,'../srv').run('serve', 'world.cds');
+const {GET} = cds.test.in(__dirname,'..').run('serve', 'world.cds');
 
 describe('Hello world!', () => {
     afterAll(() => { delete process.env.CDS_TYPESCRIPT; });

hello/world.ts

@@ -0,0 +1,5 @@
+module.exports = class say {
+    hello(req: any) {
+        return `Hello ${req.data.to} from a typescript file!`
+    }
+}

orders/app/fiori-app.html

@@ -19,38 +19,19 @@
 					url: "/orders/webapp",
 					navigationMode: "embedded"
 				}
-			},
+			}
-			bootstrapPlugins: {
-          RuntimeAuthoringPlugin: {
-            component: "sap.ushell.plugins.rta",
-            config: {
-              validateAppVersion: false,
-            },
-          },
-          PersonalizePlugin: {
-            component: "sap.ushell.plugins.rta-personalize",
-            config: {
-              validateAppVersion: false,
-            },
-          },
-        },
 		};
 	</script>
 
-<script id="sap-ushell-bootstrap" src="https://sapui5nightly.int.sap.eu2.hana.ondemand.com/test-resources/sap/ushell/bootstrap/sandbox.js"></script>
+	<script id="sap-ushell-bootstrap" src="https://sapui5.hana.ondemand.com/test-resources/sap/ushell/bootstrap/sandbox.js"></script>
-<script id="sap-ui-bootstrap" src="https://sapui5nightly.int.sap.eu2.hana.ondemand.com/resources/sap-ui-core.js"
+	<script id="sap-ui-bootstrap" src="https://sapui5.hana.ondemand.com/resources/sap-ui-core.js"
     	data-sap-ui-libs="sap.m, sap.ushell, sap.collaboration, sap.ui.layout"
     	data-sap-ui-compatVersion="edge"
     	data-sap-ui-theme="sap_fiori_3"
     	data-sap-ui-frameOptions="allow"
-		data-sap-ui-bindingSyntax="complex"
+	></script>
-></script>
 	<script>
-		sap.ui.getCore().attachInit(()=> sap.ushell.Container.createRenderer().placeAt("content"));
+		sap.ui.getCore().attachInit(()=> sap.ushell.Container.createRenderer().placeAt("content"))
-		sap.ui
-        .getCore()
-        .getConfiguration()
-        .setFlexibilityServices([{ connector: "SessionStorageConnector" }]);
 	</script>
 
 </head>

orders/app/orders/fiori-service.cds

@@ -74,10 +74,10 @@ annotate OrdersService.Orders_Items with @(
 			{Value: product_ID, Label:'Product ID'},
 			{Value: title, Label:'Product Title'},
 			{Value: price, Label:'Unit Price'},
-			{Value: quantity, Label:'Quantity'},
+			{Value: amount, Label:'Quantity'},
 		],
 		Identification: [ //Is the main field group
-			{Value: quantity, Label:'Quantity'},
+			{Value: amount, Label:'Amount'},
 			{Value: title, Label:'Product'},
 			{Value: price, Label:'Unit Price'},
 		],
@@ -86,7 +86,7 @@ annotate OrdersService.Orders_Items with @(
 		],
 	},
 ) {
-	quantity @(
+	amount @(
 		Common.FieldControl: #Mandatory
 	);
 };

orders/app/orders/webapp/manifest.json

@@ -22,10 +22,6 @@
 		}
 	},
 	"sap.ui5": {
-        "flexEnabled": true,
-        "config": {   
-            "experimentalCAPScenario": true
-        },
         "dependencies": {
             "libs": {
                 "sap.fe.templates": {}

orders/db/data/sap.capire.orders-Orders_Items.csv

@@ -1,4 +1,4 @@
-ID;up__ID;quantity;product_ID;title;price
+ID;up__ID;amount;product_ID;title;price
 58040e66-1dcd-4ffb-ab10-fdce32028b79;7e2f2640-6866-4dcf-8f4d-3027aa831cad;1;201;Wuthering Heights;11.11
 64e718c9-ff99-47f1-8ca3-950c850777d4;7e2f2640-6866-4dcf-8f4d-3027aa831cad;1;271;Catweazle;15
 e9641166-e050-4261-bfee-d1e797e6cb7f;64e718c9-ff99-47f1-8ca3-950c850777d4;2;252;Eleonora;28

orders/db/schema.cds

@@ -12,7 +12,7 @@ entity Orders_Items {
   key ID    : UUID;
   up_       : Association to Orders;
   product   : Association to Products @assert.integrity:false; // REVISIT: this is a temporary workaround for a glitch in cds-runtime
-  quantity  : Integer;
+  amount    : Integer;
   title     : String; //> intentionally replicated as snapshot from product.title
   price     : Double;
 }

orders/srv/orders-service.js

@@ -7,30 +7,30 @@ class OrdersService extends cds.ApplicationService {
 
     this.before ('UPDATE', 'Orders', async function(req) {
       const { ID, Items } = req.data
-      if (Items) for (let { product_ID, quantity } of Items) {
+      if (Items) for (let { product_ID, amount } of Items) {
-        const { quantity:before } = await cds.tx(req).run (
+        const { amount:before } = await cds.tx(req).run (
-          SELECT.one.from (OrderItems, oi => oi.quantity) .where ({up__ID:ID, product_ID})
+          SELECT.one.from (OrderItems, oi => oi.amount) .where ({up__ID:ID, product_ID})
         )
-        if (quantity != before) await this.orderChanged (product_ID, quantity-before)
+        if (amount != before) await this.orderChanged (product_ID, amount-before)
       }
     })
 
     this.before ('DELETE', 'Orders', async function(req) {
       const { ID } = req.data
       const Items = await cds.tx(req).run (
-        SELECT.from (OrderItems, oi => { oi.product_ID, oi.quantity }) .where ({up__ID:ID})
+        SELECT.from (OrderItems, oi => { oi.product_ID, oi.amount }) .where ({up__ID:ID})
       )
-      if (Items) await Promise.all (Items.map(it => this.orderChanged (it.product_ID, -it.quantity)))
+      if (Items) await Promise.all (Items.map(it => this.orderChanged (it.product_ID, -it.amount)))
     })
 
     return super.init()
   }
 
   /** order changed -> broadcast event */
-  orderChanged (product, deltaQuantity) {
+  orderChanged (product, deltaAmount) {
     // Emit events to inform subscribers about changes in orders
-    console.log ('> emitting:', 'OrderChanged', { product, deltaQuantity })
+    console.log ('> emitting:', 'OrderChanged', { product, deltaAmount })
-    return this.emit ('OrderChanged', { product, deltaQuantity })
+    return this.emit ('OrderChanged', { product, deltaAmount })
   }
 
 }

package.json

@@ -12,33 +12,30 @@
     "@capire/media": "./media",
     "@capire/orders": "./orders",
     "@capire/reviews": "./reviews",
-    "@sap/cds": "git+https://github.tools.sap/cap/cds.git",
+    "@sap/cds": "^5",
-    "@sap/cds-dk": "*"
+    "express": "^4"
   },
   "devDependencies": {
-    "chai": "^4.3.4",
+    "cds-swagger-ui-express": "^0.2.0",
+    "chai": "^4.2.0",
     "chai-as-promised": "^7.1.1",
     "chai-subset": "^1.6.0",
-    "sqlite3": "^5"
+    "sqlite3": "^5.0.0"
   },
   "scripts": {
     "cleanup": "rm -rf node_modules && rm -rf */node_modules && rm -rf */*/node_modules",
     "registry": "node .registry/server.js",
     "bookshop": "cds watch bookshop",
     "fiori": "cds watch fiori",
-    "hello": "cds watch hello",
     "media": "cds watch media",
     "mocha": "npx mocha || echo",
     "jest": "npx jest",
-    "test": "npm run jest -- --silent",
+    "test": "npm run jest --silent && npm run test:hello",
     "test:hello": "cd hello && npm test"
   },
   "jest": {
     "testEnvironment": "node",
-    "testTimeout": 20000,
+    "testMatch": ["**/*.test.js"]
-    "testMatch": [
-      "**/*.test.js"
-    ]
   },
   "mocha": {
     "parallel": true

reviews/srv/reviews-service.cds

@@ -9,9 +9,8 @@ service ReviewsService {
 
   // Async API
    event reviewed : {
-    subject : type of Reviews:subject;
+     subject: type of Reviews:subject;
-    count   : Integer;
+     rating: Decimal(2,1)
-    rating  : Decimal;
    }
 
   // Input validation

reviews/srv/reviews-service.js

@@ -12,11 +12,11 @@ module.exports = cds.service.impl (function(){
   // Emit an event to inform subscribers about new avg ratings for reviewed subjects
   this.after (['CREATE','UPDATE','DELETE'], 'Reviews', async function(_,req) {
     const {subject} = req.data
-    const { count, rating } = await cds.tx(req) .run (
+    const {rating} = await cds.tx(req) .run (
-      SELECT.one `round(avg(rating),2) as rating, count(*) as count` .from (Reviews) .where ({subject})
+      SELECT.one (['round(avg(rating),2) as rating']) .from (Reviews) .where ({subject})
     )
-    global.it || console.log ('< emitting:', 'reviewed', { subject, count, rating })
+    global.it || console.log ('< emitting:', 'reviewed', { subject, rating })
-    await this.emit ('reviewed', { subject, count, rating })
+    await this.emit ('reviewed', { subject, rating })
   })
 
   // Increment counter for reviews considered helpful

reviews/test/app/bookshop.html

@@ -1,3 +0,0 @@
-<head>
-  <meta http-equiv="refresh" content="0;url=app/bookshop/index.html">
-</head>

reviews/test/app/reviews.html

@@ -1,3 +0,0 @@
-<head>
-  <meta http-equiv="refresh" content="0;url=app/reviews/index.html">
-</head>

reviews/test/package.json

@@ -1,17 +0,0 @@
-{
-  "name": "@capire/bookshop-with-reviews",
-  "version": "1.0.0",
-  "dependencies": {
-    "@capire/bookshop": "*",
-    "@capire/reviews": "*",
-    "@sap/cds": "^5",
-    "express": "^4.17.1"
-  },
-  "cds": {
-    "requires": {
-      "db": {
-        "kind": "sql"
-      }
-    }
-  }
-}

reviews/test/srv/bookshop.cds

@@ -1,13 +0,0 @@
-// Use enhanced implementation for CatalogService
-using { CatalogService } from '@capire/bookshop';
-annotate CatalogService with @impl:'srv/bookshop.js';
-
-
-// Extend Books with access to Reviews and average ratings
-using { sap.capire.bookshop.Books } from '@capire/bookshop';
-using { ReviewsService.Reviews } from '@capire/reviews';
-extend Books with {
-  reviews : Composition of many Reviews on reviews.subject = $self.ID;
-  rating  : Decimal;
-  numberOfReviews : Integer;
-}

reviews/test/srv/bookshop.js

@@ -1,27 +0,0 @@
-const { CatalogService } = require('@capire/bookshop')
-const cds = require ('@sap/cds')
-
-module.exports = class extends CatalogService {async init(){
-
-  const { Books } = cds.entities('sap.capire.bookshop')
-
-  // Connect to ReviewsService to receive `reviewed` events from it
-  const ReviewsService = await cds.connect.to ('ReviewsService')
-  ReviewsService.on ('reviewed', (msg) => {
-    console.debug ('> received:', msg.event, msg.data)
-    const { subject, count, rating } = msg.data
-    return UPDATE(Books,subject).with({ numberOfReviews:count, rating })
-  })
-
-  return super.init()
-}}
-
-
-// -----------------------------------------------------------------------
-// Helper for serving static content from npm-installed packages
-const {dirname,resolve} = require('path')
-const {static} = require('express')
-cds.once('listening',()=>{
-  cds.app.use ('/app/bookshop', static (dirname (require.resolve('@capire/bookshop'))+'/app/vue'))
-  cds.app.use ('/app/reviews', static (resolve (__dirname, '../../app/vue')))
-})

test/cds.ql.test.js

@@ -1,159 +1,96 @@
+const { expect } = require('../test')
 const cds = require('@sap/cds/lib')
-const { expect } = cds.test
+const CQL = ([cql]) => cds.parse.cql(cql)
-const { cdr } = cds.ql
 const Foo = { name: 'Foo' }
 const Books = { name: 'capire.bookshop.Books' }
 
+const { parse:cdr } = cds.ql
 
-const STAR = cdr ? '*' : { ref: ['*'] }
+// while jest has 'test' as alias to 'it', mocha doesn't
-const skip = {to:{eql:()=>skip}}
+if (!global.test) global.test = it
-const srv = new cds.Service
-let cqn
-
-expect.plain = (cqn) => !cqn.SELECT.one && !cqn.SELECT.distinct ? expect(cqn) : skip
-expect.one = (cqn) => !cqn.SELECT.distinct ? expect(cqn) : skip
 
 describe('cds.ql → cqn', () => {
   //
+  let cqn
 
-  for (let each of ['SELECT', 'SELECT one', 'SELECT distinct']) {
+  describe.skip(`BUGS + GAPS...`, () => {
-    let SELECT; beforeEach(()=> SELECT = (
-      each === 'SELECT distinct' ? cds.ql.SELECT.distinct :
-      each === 'SELECT one' ? cds.ql.SELECT.one :
-      cds.ql.SELECT
-    ))
-  describe(`${each}...`, () => {
 
-    test(`from Foo`, () => {
+    it('should consistently handle *', () => {
-      expect(cqn = SELECT `from Foo`)
+      expect({
-      .to.eql(SELECT.from `Foo`)
+        SELECT: { from: { ref: ['Foo'] }, columns: ['*'] },
-      .to.eql(SELECT.from('Foo'))
+      })
-      .to.eql(SELECT.from(Foo))
+      .to.eql(CQL`SELECT * from Foo`)
-      .to.eql(SELECT`Foo`)
+      .to.eql(CQL`SELECT from Foo{*}`)
-      .to.eql(SELECT('Foo'))
+      .to.eql(SELECT('*').from(Foo))
-      .to.eql(SELECT(Foo))
+      .to.eql(SELECT.from(Foo,['*']))
-      expect.plain(cqn)
+    })
-      .to.eql(CQL`SELECT from Foo`)
+
-      .to.eql(srv.read `Foo`)
+
-      .to.eql(srv.read('Foo'))
+    it('should consistently handle lists', () => {
-      .to.eql(srv.read(Foo))
+      const ID = 11,  args = [`foo`, "'bar'", 3]
-      .to.eql({
+      const cqn = CQL`SELECT from Foo where ID=11 and x in (foo,'bar',3)`
+      expect(SELECT.from(Foo).where(`ID=${ID} and x in (${args})`)).to.eql(cqn)
+      expect(SELECT.from(Foo).where(`ID=`, ID, `and x in`, args)).to.eql(cqn)
+      expect(SELECT.from(Foo).where({ ID, x:args })).to.eql(cqn)
+    })
+
+  })
+
+
+  describe(`SELECT...`, () => {
+    test('from ( Foo )', () => {
+      expect({
         SELECT: { from: { ref: ['Foo'] } },
       })
+      .to.eql(CQL`SELECT from Foo`)
+      .to.eql(SELECT.from(Foo))
     })
 
-
+    test('from ( ..., <key>)', () => {
-    test('from Foo [<key>]', () => {
+      // Compiler
-
+      expect(CQL`SELECT from Foo[11]`).to.eql({
-      expect(cqn = SELECT`from Foo[11]`)
-      .to.eql(SELECT`from Foo[${11}]`)
-      .to.eql(SELECT.from `Foo[11]`)
-      .to.eql(SELECT.from `Foo[${11}]`)
-      .to.eql(SELECT`Foo[11]`)
-      expect.plain(cqn)
-      .to.eql(CQL`SELECT from Foo[11]`)
-      .to.eql(srv.read`Foo[11]`)
-      .to.eql({
-        SELECT: { from: {
-          ref: [{ id: 'Foo', where: [{ val: 11 }] }]
-        }},
-      })
-
-      if (cdr) expect.plain (cqn)
-      .to.eql(srv.read`Foo[${11}]`)
-      .to.eql(SELECT`Foo[${11}]`)
-
-      expect((cqn = SELECT`from Foo[ID=11]`))
-      .to.eql(SELECT`from Foo[ID=${11}]`)
-      .to.eql(SELECT.from `Foo[ID=11]`)
-      .to.eql(SELECT.from `Foo[ID=${11}]`)
-      .to.eql(SELECT`Foo[ID=11]`)
-      expect.plain(cqn)
-      .to.eql(CQL`SELECT from Foo[ID=11]`)
-      .to.eql(srv.read`Foo[ID=11]`)
-      .to.eql({
-        SELECT: { from: {
-          ref: [{ id: 'Foo', where: [{ ref: ['ID'] }, '=', { val: 11 }] }],
-        }},
-      })
-
-      if (cdr) expect.plain (cqn)
-      .to.eql(SELECT`Foo[ID=${11}]`)
-      .to.eql(srv.read`Foo[ID=${11}]`)
-
-      // Following implicitly resolve to SELECT.one
-      expect(cqn = SELECT.from(Foo,11))
-      .to.eql(SELECT.from(Foo,{ID:11}))
-      .to.eql(SELECT.from(Foo).byKey(11))
-      .to.eql(SELECT.from(Foo).byKey({ID:11}))
-      if (cds.version >= '5.6.0') {
-        expect.one(cqn)
-        .to.eql({
         SELECT: {
-            one: true,
+          // REVISIT: add one:true?
-            from: { ref: [{ id: 'Foo', where: [{ ref: ['ID'] }, '=', { val: 11 }] }] },
+          from: { ref: [{ id: 'Foo', where: [{ val: 11 }] }] },
         },
       })
-      } else {
+
-        expect.one(cqn)
+      expect(CQL`SELECT from Foo[ID=11]`).to.eql({
+        SELECT: {
+          // REVISIT: add one:true
+          from: {
+            ref: [{ id: 'Foo', where: [{ ref: ['ID'] }, '=', { val: 11 }] }],
+          },
+        },
+      })
+
+      // Runtime ds.ql
+      expect(SELECT.from(Foo, 11))
+        .to.eql(SELECT.from(Foo, { ID: 11 }))
+        .to.eql(SELECT.from(Foo).byKey(11))
+        .to.eql(SELECT.from(Foo).byKey({ ID: 11 }))
+        .to.eql(SELECT.one.from(Foo).where({ ID: 11 }))
         .to.eql({
+          // REVISIT: should produce CQN as the ones above?
           SELECT: {
             one: true,
             from: { ref: ['Foo'] },
             where: [{ ref: ['ID'] }, '=', { val: 11 }],
           },
         })
-      }
 
-    })
+      expect(CQL`SELECT from Foo[11]{a}`).to.eql({
-
-    test('from Foo {...}', () => {
-
-      expect(cqn = SELECT `*,a,b as c` .from `Foo`)
-      .to.eql(SELECT `*,a,b as c`. from(Foo))
-      .to.eql(SELECT('*','a',{b:'c'}).from`Foo`)
-      .to.eql(SELECT('*','a',{b:'c'}).from(Foo))
-      .to.eql(SELECT(['*','a',{b:'c'}]).from(Foo))
-      .to.eql(SELECT.columns('*','a',{b:'c'}).from(Foo))
-      .to.eql(SELECT.columns(['*','a',{b:'c'}]).from(Foo))
-      .to.eql(SELECT.columns((foo) => { foo`.*`, foo.a, foo.b`as c` }).from(Foo))
-      .to.eql(SELECT.columns((foo) => { foo('*'), foo.a, foo.b.as('c') }).from(Foo))
-      .to.eql(SELECT.from(Foo).columns('*','a',{b:'c'}))
-      .to.eql(SELECT.from(Foo).columns(['*','a',{b:'c'}]))
-      .to.eql(SELECT.from(Foo).columns((foo) => { foo`.*`, foo.a, foo.b`as c` }))
-      .to.eql(SELECT.from(Foo).columns((foo) => { foo('*'), foo.a, foo.b.as('c') }))
-      .to.eql(SELECT.from(Foo,['*','a',{b:'c'}]))
-      .to.eql(SELECT.from(Foo, (foo) => { foo`.*`, foo.a, foo.b`as c` }))
-      .to.eql(SELECT.from(Foo, (foo) => { foo('*'), foo.a, foo.b.as('c') }))
-
-      expect.plain(cqn)
-      .to.eql({
         SELECT: {
-          from: { ref: ['Foo'] },
+          // REVISIT: add one:true?
-          columns: [ STAR, { ref: ['a'] }, { ref: ['b'], as: 'c' }],
+          from: { ref: [{ id: 'Foo', where: [{ val: 11 }] }] },
+          columns: [{ ref: ['a'] }],
         },
       })
 
-      cdr && expect.plain(cqn)
+      expect(SELECT.from(Foo, 11, ['a']))
-      .to.eql(CQL`SELECT *,a,b as c from Foo`)
+        .to.eql(SELECT.from(Foo, 11, (foo) => foo.a))
-      .to.eql(CQL`SELECT from Foo {*,a,b as c}`)
-
-      // Test combination with key as second argument to .from
-      expect(cqn = SELECT.from(Foo, 11, ['a']))
-      .to.eql(SELECT.from(Foo, 11, foo => foo.a))
-
-      if (cds.version >= '5.6.0') {
-        expect.one(cqn)
-        .to.eql({
-          SELECT: {
-            one: true,
-            from: { ref: [{ id: 'Foo', where: [{ ref: ['ID'] }, '=', { val: 11 }]}] },
-            columns: [{ ref: ['a'] }]
-          },
-        })
-      } else {
-        expect.one(cqn)
         .to.eql({
+          // REVISIT: should produce CQN as the ones above?
           SELECT: {
             one: true,
             from: { ref: ['Foo'] },
@@ -161,56 +98,110 @@ describe('cds.ql → cqn', () => {
             where: [{ ref: ['ID'] }, '=', { val: 11 }],
           },
         })
-      }
-
     })
 
-    test('with nested expands', () => {
+    test('from ( ..., => {...})', () => {
-      // SELECT from Foo { *, x, bar.*, car{*}, boo { *, moo.zoo } }
+      // single *, prefix and postfix, as array and function
-      expect(cqn =
+      let parsed, fluid
-        SELECT.from (Foo, foo => {
+      expect((parsed = CQL`SELECT * from Foo`)).to.eql(CQL`SELECT from Foo{*}`)
-          foo`*`, foo.x, foo.car`*`, foo.boo (b => {
+      //> .to.eql... FIXME: see skipped 'should handle * correctly' below
-            b`*`, b.moo.zoo(
+      expect((fluid = SELECT('*').from(Foo)))
-              x => x.y.z
+        .to.eql(SELECT.from(Foo, ['*']))
-            )
+        .to.eql(SELECT.from(Foo, (foo) => foo('*')))
+        .to.eql(SELECT.from(Foo).columns('*'))
+        .to.eql(SELECT.from(Foo).columns((foo) => foo('*')))
+        .to.eql({
+          SELECT: { from: { ref: ['Foo'] }, columns: [cdr ? '*' : { ref: ['*'] }] },
         })
-        })
-      ).to.eql(
-        SELECT.from (Foo, foo => {
-          foo('*'), foo.x, foo.car('*'), foo.boo (b => {
-            b('*'), b.moo.zoo(
-              x => x.y.z
-            )
-          })
-        })
-      )
 
-      expect.plain(cqn)
+      if (cdr) expect(parsed).to.eql(fluid)
+
+      // single column, prefix and postfix, as array and function
+      expect(CQL`SELECT a from Foo`)
+      expect(CQL`SELECT from Foo {a}`)
+        .to.eql(SELECT.from(Foo, ['a']))
+        .to.eql(SELECT.from(Foo, (foo) => foo.a))
+        .to.eql({
+          SELECT: { from: { ref: ['Foo'] }, columns: [{ ref: ['a'] }] },
+        })
+
+      // multiple columns, prefix and postfix, as array and function
+      expect(CQL`SELECT a,b as c from Foo`)
+
+      expect (CQL`SELECT from Foo {a,b as c}`).to.eql(cqn = {
+        SELECT: {
+          from: { ref: ['Foo'] },
+          columns: [{ ref: ['a'] }, { ref: ['b'], as: 'c' }],
+        },
+      })
+      expect(SELECT.from(Foo, ['a', { b: 'c' }])).to.eql(cqn)
+      expect(
+        SELECT.from(Foo, (foo) => {
+          foo.a, foo.b.as('c')
+        })
+      ).to.eql(cqn)
+      expect(SELECT.from(Foo).columns('a', { b: 'c' })).to.eql(cqn)
+      expect(SELECT.from(Foo).columns(['a', { b: 'c' }])).to.eql(cqn)
+      expect(
+        SELECT.from(Foo).columns((foo) => {
+          foo.a, foo.b.as('c')
+        })
+      ).to.eql(cqn)
+
+      // multiple columns and *, prefix and postfix, as array and function
+      expect(CQL`SELECT *,a,b from Foo`).to.eql(CQL`SELECT from Foo{*,a,b}`)
+      //> .to.eql... FIXME: see skipped 'should handle * correctly' below
+      expect(SELECT.from(Foo, ['a', 'b', '*']))
+      .to.eql(SELECT.from(Foo).columns('a', 'b', '*'))
+      .to.eql(SELECT.from(Foo).columns(['a', 'b', '*']))
+      .to.eql(
+        SELECT.from(Foo, (foo) => {
+          foo.a, foo.b, foo('*')
+        })
+      )
       .to.eql({
+        SELECT: {
+          from: { ref: ['Foo'] },
+          columns: [{ ref: ['a'] }, { ref: ['b'] }, cdr ? '*' : { ref: ['*'] }],
+        },
+      })
+    })
+
+    test('from ( ..., => _.expand ( x=>{...}))', () => {
+      // SELECT from Foo { *, x, bar.*, car{*}, boo { *, moo.zoo } }
+      expect(
+        SELECT.from(Foo, (foo) => {
+          foo('*'),
+            foo.x,
+            foo.car('*'),
+            foo.boo((b) => {
+              b('*'), b.moo.zoo((x) => x.y.z)
+            })
+        })
+      ).to.eql({
         SELECT: {
           from: { ref: ['Foo'] },
           columns: [
-            STAR,
+            cdr ? '*' : { ref: ['*'] },
             { ref: ['x'] },
             { ref: ['car'], expand: ['*'] },
             {
               ref: ['boo'],
-              expand: [ '*', { ref: ['moo', 'zoo'], expand: [{ ref: ['y', 'z'] }] }],
+              expand: ['*', { ref: ['moo', 'zoo'], expand: [{ ref: ['y', 'z'] }] }],
             },
           ],
         },
       })
     })
 
-
+    test('from ( ..., => _.inline ( _=>{...}))', () => {
-    test('with nested inlines', () => {
       // SELECT from Foo { *, x, bar.*, car{*}, boo { *, moo.zoo } }
-      expect.plain(
+      expect(
-        SELECT.from (Foo, foo => {
+        SELECT.from(Foo, (foo) => {
-          foo.bar `*`,
+          foo.bar('*'),
-          foo.bar `.*`, //> leading dot indicates inline
+            foo.bar('.*'), //> leading dot indicates inline
-          foo.boo(_ => _.moo.zoo), //> underscore arg name indicates inline
+            foo.boo((x) => x.moo.zoo),
-          foo.boo(x => x.moo.zoo)
+            foo.boo((_) => _.moo.zoo) //> underscore arg name indicates inline
         })
       ).to.eql({
         SELECT: {
@@ -218,44 +209,49 @@ describe('cds.ql → cqn', () => {
           columns: [
             { ref: ['bar'], expand: ['*'] },
             { ref: ['bar'], inline: ['*'] },
-            { ref: ['boo'], inline: [{ ref: ['moo', 'zoo'] }] },
             { ref: ['boo'], expand: [{ ref: ['moo', 'zoo'] }] },
+            { ref: ['boo'], inline: [{ ref: ['moo', 'zoo'] }] },
           ],
         },
       })
     })
 
-  })}
+    test('one / distinct ...', () => {
+      expect(SELECT.distinct.from(Foo).SELECT)
+        // .to.eql(CQL(`SELECT distinct from Foo`).SELECT)
+        .to.eql(SELECT.distinct(Foo).SELECT)
+        .to.eql({ distinct: true, from: { ref: ['Foo'] } })
 
-  describe ('SELECT where...', ()=>{
+      expect(SELECT.one.from(Foo).SELECT)
+        // .to.eql(CQL(`SELECT one from Foo`).SELECT)
+        .to.eql(SELECT.one(Foo).SELECT)
+        .to.eql({ one: true, from: { ref: ['Foo'] } })
+
+      expect(SELECT.one('a').from(Foo).SELECT)
+        // .to.eql(CQL(`SELECT distinct a from Foo`).SELECT)
+        .to.eql(SELECT.one(['a']).from(Foo).SELECT)
+        .to.eql(SELECT.one(Foo, ['a']).SELECT)
+        .to.eql(SELECT.one(Foo, (foo) => foo.a).SELECT)
+        .to.eql(SELECT.one.from(Foo, (foo) => foo.a).SELECT)
+        .to.eql(SELECT.one.from(Foo, ['a']).SELECT)
+        .to.eql({
+          one: true,
+          from: { ref: ['Foo'] },
+          columns: [{ ref: ['a'] }],
+        })
+      // same for works distinct
+    })
 
     it('should correctly handle { ... and:{...} }', () => {
       expect(SELECT.from(Foo).where({ x: 1, and: { y: 2, or: { z: 3 } } })).to.eql({
         SELECT: {
           from: { ref: ['Foo'] },
-          where: cdr ? [
+          where: [
-            { ref: ['x'] },
-            '=',
-            { val: 1 },
-            'and',
-            // '(',
-            {xpr:[
-              { ref: ['y'] },
-              '=',
-              { val: 2 },
-              'or',
-              { ref: ['z'] },
-              '=',
-              { val: 3 },
-            ]},
-            // ')',
-          ] : [
             { ref: ['x'] },
             '=',
             { val: 1 },
             'and',
             '(',
-            // {xpr:[
             { ref: ['y'] },
             '=',
             { val: 2 },
@@ -263,97 +259,12 @@ describe('cds.ql → cqn', () => {
             { ref: ['z'] },
             '=',
             { val: 3 },
-            // ]},
             ')',
           ],
         },
       })
     })
 
-    test ("where x='*'", ()=>{
-      if (cdr)
-      expect (SELECT.from(Foo).where({x:'*'}))
-      .to.eql(SELECT.from(Foo).where("x='*'"))
-      .to.eql(SELECT.from(Foo).where("x=",'*'))
-      .to.eql(SELECT.from(Foo).where`x=${'*'}`)
-      .to.eql(
-        CQL`SELECT from Foo where x='*'`
-      )
-      if (cdr)
-      expect (SELECT.from(Foo).where({x:['*',1]}))
-      .to.eql(SELECT.from(Foo).where("x in ('*',1)"))
-      .to.eql(SELECT.from(Foo).where("x in",['*',1]))
-      .to.eql(SELECT.from(Foo).where`x in ${['*',1]}`)
-      .to.eql(
-        CQL`SELECT from Foo where x in ('*',1)`
-      )
-    })
-
-    test ('where, and, or', ()=>{
-      expect (
-        SELECT.from(Foo).where({x:1,and:{y:2}})
-      ).to.eql (
-        CQL`SELECT from Foo where x=1 and y=2`
-      ) .to.eql ({ SELECT: {
-        from: {ref:['Foo']},
-        where: [
-          {ref:['x']}, '=', {val:1},
-          'and',
-          {ref:['y']}, '=', {val:2}
-        ]
-      }})
-
-      expect (
-        SELECT.from(Foo).where({x:1,or:{y:2}})
-      ).to.eql (
-        CQL`SELECT from Foo where x=1 or y=2`
-      ).to.eql ({ SELECT: {
-        from: {ref:['Foo']},
-        where: [
-          {ref:['x']}, '=', {val:1},
-          'or',
-          {ref:['y']}, '=', {val:2}
-        ]
-      }})
-
-      expect (
-        SELECT.from(Foo).where({x:1,and:{y:2}}).or({z:3})
-      ).to.eql (
-        CQL`SELECT from Foo where x=1 and y=2 or z=3`
-      )
-
-      if (cdr) expect (
-        SELECT.from(Foo).where({x:1}).and({y:2,or:{z:3}})
-      ).to.eql (
-        CQL`SELECT from Foo where x=1 and ( y=2 or z=3 )`
-      )
-
-      if (cdr) expect (
-        SELECT.from(Foo).where({1:1}).and({x:1,or:{x:2}}).and({y:2,or:{z:3}})
-      ).to.eql (
-        CQL`SELECT from Foo where 1=1 and ( x=1 or x=2 ) and ( y=2 or z=3 )`
-      )
-
-      if (cdr) expect (
-        SELECT.from(Foo).where({x:1,or:{x:2}}).and({y:2,or:{z:3}})
-      ).to.eql (
-        CQL`SELECT from Foo where ( x=1 or x=2 ) and ( y=2 or z=3 )`
-      )
-    })
-
-    test('where ({x:[undefined]})', () => {
-      if (cdr) expect (
-        SELECT.from(Foo).where({x:[undefined]})
-      ).to.eql ({ SELECT: {
-        from: {ref:['Foo']},
-        where: [
-          {ref:['x']},
-          'in',
-          { list: [ {val:undefined} ] }
-        ]
-      }})
-    })
-
     test('where ( ... cql  |  {x:y} )', () => {
       const args = [`foo`, "'bar'", 3]
       const ID = 11
@@ -369,7 +280,9 @@ describe('cds.ql → cqn', () => {
       ).to.eql({
         SELECT: {
           from: { ref: ['Foo'] },
-          where: cdr ? [
+          where: cds.version >= '5.3.0'
+            ? [
+                // '(', //> this one is not required
                 { ref: ['ID'] },
                 '=',
                 { val: ID },
@@ -378,8 +291,7 @@ describe('cds.ql → cqn', () => {
                 'in',
                 { list: args.map(val => ({ val })) },
                 'and',
-            {
+                '(', //> this one is missing, and that's changing the logic -> that's a BUG
-              xpr: [
                 { ref: ['x'] },
                 'like',
                 { val: '%x%' },
@@ -387,18 +299,19 @@ describe('cds.ql → cqn', () => {
                 { ref: ['y'] },
                 '>=',
                 { val: 9 },
+                ')',
               ]
-            },
+            : [
-          ] : [
+                // '(', //> this one is not required
                 { ref: ['ID'] },
                 '=',
                 { val: ID },
                 'and',
                 { ref: ['args'] },
                 'in',
-            { list: args.map(val => ({ val })) },
+                { val: args },
                 'and',
-            '(',
+                '(',  //> this one is missing, and that's changing the logic -> that's a BUG
                 { ref: ['x'] },
                 'like',
                 { val: '%x%' },
@@ -408,7 +321,7 @@ describe('cds.ql → cqn', () => {
                 { val: 9 },
                 ')',
               ],
-        }
+        },
       })
 
       // using CQL fragments -> uses cds.parse.expr
@@ -493,32 +406,12 @@ describe('cds.ql → cqn', () => {
         ).to.eql(cqn)
     })
 
-    test('w/ plain SQL', () => {
+    it('w/ plain SQL', () => {
       expect(SELECT.from(Books) + 'WHERE ...').to.eql(
         'SELECT * FROM capire_bookshop_Books WHERE ...'
       )
     })
 
-    it('should consistently handle *', () => {
-      if (!cdr) return
-      expect({
-        SELECT: { from: { ref: ['Foo'] }, columns: ['*'] },
-      })
-      .to.eql(CQL`SELECT * from Foo`)
-      .to.eql(CQL`SELECT from Foo{*}`)
-      .to.eql(SELECT('*').from(Foo))
-      .to.eql(SELECT.from(Foo,['*']))
-    })
-
-    it('should consistently handle lists', () => {
-      if (!cdr) return
-      const ID = 11,  args = [{ref:['foo']}, "bar", 3]
-      const cqn = CQL`SELECT from Foo where ID=11 and x in (foo,'bar',3)`
-      expect(SELECT.from(Foo).where`ID=${ID} and x in ${args}`).to.eql(cqn)
-      expect(SELECT.from(Foo).where(`ID=`, ID, `and x in`, args)).to.eql(cqn)
-      expect(SELECT.from(Foo).where({ ID, x:args })).to.eql(cqn)
-    })
-
     //
   })
 
@@ -573,31 +466,21 @@ describe('cds.ql → cqn', () => {
 
   describe(`UPDATE...`, () => {
     test('entity (..., <key>)', () => {
-      const cqnWhere = {
-          UPDATE: {
-            entity: 'capire.bookshop.Books',
-            where: [{ ref: ['ID'] }, '=', { val: 4711 }],
-          },
-        }
-      expect(UPDATE(Books).where({ ID: 4711 }))
-        .to.eql(UPDATE(Books).where(`ID=`, 4711))
-        .to.eql(cqnWhere)
-
-      const cqnKey = (cds.version >= '5.6.0') ? 
-        {
-          UPDATE: {
-            entity: { ref: [{ id: 'capire.bookshop.Books', where: [{ ref: ['ID'] }, '=', { val: 4711 }] }] }
-          }
-        }
-        : cqnWhere
       expect(UPDATE(Books, 4711))
         .to.eql(UPDATE(Books, { ID: 4711 }))
         .to.eql(UPDATE(Books).byKey(4711))
         .to.eql(UPDATE(Books).byKey({ ID: 4711 }))
+        .to.eql(UPDATE(Books).where({ ID: 4711 }))
+        .to.eql(UPDATE(Books).where(`ID=`, 4711))
         .to.eql(UPDATE.entity(Books, 4711))
         .to.eql(UPDATE.entity(Books, { ID: 4711 }))
         // etc...
-        .to.eql(cqnKey)
+        .to.eql({
+          UPDATE: {
+            entity: 'capire.bookshop.Books',
+            where: [{ ref: ['ID'] }, '=', { val: 4711 }],
+          },
+        })
     })
 
     /*
@@ -648,29 +531,20 @@ describe('cds.ql → cqn', () => {
 
   describe(`DELETE...`, () => {
     test('from (..., <key>)', () => {
-      const cqnWhere = {
-          DELETE: {
-            from: 'capire.bookshop.Books',
-            where: [{ ref: ['ID'] }, '=', { val: 4711 }],
-          },
-        }
-      expect(DELETE.from(Books).where({ ID: 4711 }))
-        .to.eql(DELETE.from(Books).where(`ID=`, 4711))
-        .to.eql(cqnWhere)
-      const cqnKey = (cds.version >= '5.6.0') ? 
-        {
-          DELETE: {
-          from: { ref: [{ id: 'capire.bookshop.Books', where: [{ ref: ['ID'] }, '=', { val: 4711 }]}] }
-          },
-        } : cqnWhere
-
       expect(DELETE(Books, 4711))
         .to.eql(DELETE(Books, { ID: 4711 }))
         .to.eql(DELETE.from(Books, 4711))
         .to.eql(DELETE.from(Books, { ID: 4711 }))
         .to.eql(DELETE.from(Books).byKey(4711))
         .to.eql(DELETE.from(Books).byKey({ ID: 4711 }))
-        .to.eql(cqnKey)
+        .to.eql(DELETE.from(Books).where({ ID: 4711 }))
+        .to.eql(DELETE.from(Books).where(`ID=`, 4711))
+        .to.eql({
+          DELETE: {
+            from: 'capire.bookshop.Books',
+            where: [{ ref: ['ID'] }, '=', { val: 4711 }],
+          },
+        })
     })
 
     test('/w plain SQL', () => {

test/consuming-services.test.js

@@ -1,11 +1,11 @@
-const cds = require('@sap/cds/lib')
+const { expect } = require('../test') .run (
-const { expect } = cds.test (
   'serve', 'AdminService', '--from', '@capire/bookshop,@capire/common', '--in-memory'
 )
+const cds = require('@sap/cds/lib')
 
 describe('Consuming Services locally', () => {
   //
-  it('bootstrapped the database successfully', ()=>{
+  it('bootrapped the database successfully', ()=>{
     const { AdminService } = cds.services
     const { Authors } = AdminService.entities
     expect(AdminService).not.to.be.undefined
@@ -15,17 +15,17 @@ describe('Consuming Services locally', () => {
   it('supports targets as strings or reflected defs', async () => {
     const AdminService = await cds.connect.to('AdminService')
     const { Authors } = AdminService.entities
-    expect (await SELECT.from(Authors))
+    const _ = expect (await AdminService.read(Authors))
-    .to.eql(await SELECT.from('Authors'))
-    .to.eql(await AdminService.read(Authors))
     .to.eql(await AdminService.read('Authors'))
     .to.eql(await AdminService.run(SELECT.from(Authors)))
-    .to.eql(await AdminService.run(SELECT.from('Authors')))
+    // temporary workaround
+    if (cds.version >= '4.2.0')
+      _.to.eql(await AdminService.run(SELECT.from('Authors')))
   })
 
   it('allows reading from local services using cds.ql', async () => {
     const AdminService = await cds.connect.to('AdminService')
-    const authors = await AdminService.read (`Authors`, a => {
+    const query = SELECT.from('Authors', (a) => {
       a.name,
         a.books((b) => {
           b.title,
@@ -34,6 +34,10 @@ describe('Consuming Services locally', () => {
             })
         })
     }).where(`name like`, 'E%')
+    // temporary workaround
+    if (cds.version < '4.2.0')
+      query.SELECT.from.ref[0] = 'AdminService.Authors'
+    const authors = await AdminService.run(query)
     expect(authors).to.containSubset([
       {
         name: 'Emily Brontë',

test/custom-handlers.test.js

@@ -1,14 +1,14 @@
+const { GET, POST, expect } = require('../test') .run ('bookshop')
 const cds = require('@sap/cds/lib')
-const { GET, POST, expect } = cds.test(__dirname+'/../bookshop')
 if (cds.User.default) cds.User.default = cds.User.Privileged // hard core monkey patch
 else cds.User = cds.User.Privileged // hard core monkey patch for older cds releases
 
 describe('Custom Handlers', () => {
 
   it('should reject out-of-stock orders', async () => {
-    await POST `/browse/submitOrder ${{ book: 201, quantity: 5 }}`
+    await POST('/browse/submitOrder', { book: 201, amount: 5 })
-    await POST `/browse/submitOrder ${{ book: 201, quantity: 5 }}`
+    await POST('/browse/submitOrder', { book: 201, amount: 5 })
-    await expect(POST `/browse/submitOrder ${{ book: 201, quantity: 5 }}`).to.be.rejectedWith(/409 - 5 exceeds stock for book #201/)
+    await expect(POST('/browse/submitOrder', { book: 201, amount: 5 })).to.be.rejectedWith(/409 - 5 exceeds stock for book #201/)
     const { data } = await GET`/admin/Books/201/stock/$value`
     expect(data).to.equal(2)
   })

test/hello-world.test.js

@@ -1,5 +1,4 @@
-const cds = require('@sap/cds/lib')
+const { GET, expect } = require('../test') .run ('serve','hello/world.cds')
-const { GET, expect } = cds.test (__dirname+'/../hello')
 
 describe('Hello world!', () => {
 

test/hierarchical-data.test.js

@@ -1,5 +1,5 @@
+const {expect} = require('../test')
 const cds = require('@sap/cds/lib')
-const {expect} = cds.test
 
 const { parse:cdr } = cds.ql
 
@@ -76,9 +76,9 @@ describe('Hierarchical Data', ()=>{
 		const expected = [
       { ID:100, name:'Some Cats...' },
       { ID:101, name:'Cat' },
+        { ID:104, name:'Aristocat' },  // REVISIT: Should be deleted as well?
       { ID:108, name:'Catweazle' }
 		]
-    return 'skipped as this will be fixed in a newer cds version'
 		if (cdr) expect ( await SELECT.from(Cats) ).to.containSubset (expected)
 		else expect ( await SELECT.from(Cats) ).to.eql (expected)
 	})

test/index.js

@@ -0,0 +1,2 @@
+const cds = require('@sap/cds')
+module.exports = cds.test.in(__dirname,'..')

test/localized-data.test.js

@@ -1,5 +1,5 @@
+const { GET, expect } = require('../test') .run ('serve', 'test/localized-data.cds', '--in-memory')
 const cds = require('@sap/cds/lib')
-const { GET, expect } = cds.test.run ('serve', __dirname+'/localized-data.cds', '--in-memory')
 if (cds.User.default) cds.User.default = cds.User.Privileged // hard core monkey patch
 else cds.User = cds.User.Privileged // hard core monkey patch for older cds releases
 

test/messaging.test.js

@@ -1,5 +1,5 @@
+const { expect } = require('../test')
 const cds = require('@sap/cds/lib')
-const { expect } = cds.test
 const _model = '@capire/reviews'
 if (cds.User.default) cds.User.default = cds.User.Privileged // hard core monkey patch
 else cds.User = cds.User.Privileged // hard core monkey patch for older cds releases
@@ -60,11 +60,11 @@ describe('Messaging', ()=>{
         expect(M).equals(N)
         expect(received.length).equals(N)
         expect(received.map(m=>m.data)).to.deep.equal([
-            { count: 1, subject: '201', rating: 1 },
+            { subject: '201', rating: 1 },
-            { count: 2, subject: '201', rating: 1.5 },
+            { subject: '201', rating: 1.5 },
-            { count: 3, subject: '201', rating: 2 },
+            { subject: '201', rating: 2 },
-            { count: 4, subject: '201', rating: 2.5 },
+            { subject: '201', rating: 2.5 },
-            { count: 5, subject: '201', rating: 3 },
+            { subject: '201', rating: 3 },
         ])
     })
 })

test/odata.test.js

@@ -1,5 +1,5 @@
+const { GET, expect } = require('../test') .run ('bookshop')
 const cds = require('@sap/cds/lib')
-const { GET, expect } = cds.test ('@capire/bookshop')
 if (cds.User.default) cds.User.default = cds.User.Privileged // hard core monkey patch
 else cds.User = cds.User.Privileged // hard core monkey patch for older cds releases
 
@@ -18,9 +18,9 @@ describe('OData Protocol', () => {
   })
 
   it('supports $search in multiple fields', async () => {
-    const { data } = await GET `/browse/Books ${{
+    const { data } = await GET(`/browse/Books`, {
       params: { $search: 'Po', $select: `title,author` },
-    }}`
+    })
     expect(data.value).to.eql([
       { ID: 201, title: 'Wuthering Heights', author: 'Emily Brontë' },
       { ID: 207, title: 'Jane Eyre', author: 'Charlotte Brontë' },

test/registry.test.js

@@ -1,54 +0,0 @@
-
-const { fork } = require('child_process')
-const { resolve } = require('path')
-const Axios = require('axios')
-const verbose = process.env.CDS_TEST_VERBOSE
-// ||true
-
-describe('Local NPM registry', () => {
-  let registry
-  let axios
-  const cwd = resolve(__dirname, '..')
-
-  beforeAll(async ()=> {
-    const env = Object.assign(process.env, {PORT:'0'})
-    const res = await exec (resolve(cwd, '.registry/server.js'), {cwd, stdio: 'pipe', env})
-    registry = res.cp
-    axios = Axios.default.create ({ baseURL: res.url, validateStatus: (status)=>status<500 })
-  })
-
-  afterAll(() => { registry.kill() })
-
-  for (const mod of ['bookshop','fiori','orders','reviews']) {
-    it(`should serve ${mod}`, async () => {
-      const resp = await axios.get(`/@capire/${mod}`)
-      expect(resp.data).toMatchObject({name: `@capire/${mod}`, versions:{}})
-      const versions = Object.values(resp.data.versions)
-      await axios.get(versions[0].dist.tarball)
-    })
-  }
-  it(`should return 404 for unknown packages`, async () => {
-    let resp = await axios.get(`/@capire/foo`)
-    expect(resp.status).toEqual(404)
-    resp = await axios.get(`/foo`)
-    expect(resp.status).toEqual(404)
-  })
-
-})
-
-function exec (script, opts) {
-  return new Promise((resolve, reject)=> {
-    const cp = fork (script, [], opts)
-      .on('error', err => reject(new Error(err)))
-    cp.stdout.on('data', chunk => {
-      if (verbose) console.log(chunk.toString())
-      if (chunk.toString().match(/listening.*(http:.*:\d+)/i)) {
-         resolve({cp, url:RegExp.$1})
-      }
-    })
-    cp.stderr.on('data', chunk => {
-      if (verbose)  console.error(chunk.toString())
-    })
-  })
-
-}