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?
2021-07-13 17:02:43 +02:00
54 changed files with 30340 additions and 1307 deletions
--- a/.github/workflows/node.js.yml
+++ b/.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:
--- a/.gitignore
+++ b/.gitignore
@@ -17,4 +17,3 @@ reviews/msg-box
 reviews/db/test.db

 *.openapi3.json
-sqlite.db
--- a/.registry/server.js
+++ b/.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 [, scpe, pkg ] = urlRegex.exec(url)
-    const package = require (`${scpe}/${pkg}/package.json`)
-    const tarball = `${scpe.slice(1)}-${pkg}-${package.version}.tgz`
+    const [, capire, pkg ] = /^\/(@capire)\/(\w+)/.exec(url)
+    const package = require (`${capire}/${pkg}/package.json`)
+    const tarball = `capire-${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);  throw e
+    console.error(e)
+    res.sendStatus(404)
  }
 })

-const server = app.listen(port, ()=>{
-  const url = `http://localhost:${server.address().port}`
-  console.log (`npm set ${scope}:registry=${url}`)
-  exec(`npm set ${scope}:registry=${url}`)
-  console.log (`${scope} registry listening on ${url}`)
+app.listen(port, ()=>{
+  console.log (`npm set @capire:registry=http://localhost:${port}`)
+  console.log (`@capire registry listening on http://localhost:${port}`)
+  exec(`npm set @capire:registry=http://localhost:${port}`)
 })

-
 const _exit = ()=>{
-  server.close()
-  exec(`npm conf rm "${scope}:registry"`, ()=> { process.exit() })
+  console.log ('\nnpm conf rm @capire:registry')
+  exec('npm conf rm @capire:registry')
+  exec('rm *.tgz')
+  process.exit()
 }
-
 process.on ('SIGTERM',_exit)
 process.on ('SIGHUP',_exit)
 process.on ('SIGINT',_exit)
--- a/.tours/db-native.tour
+++ b/.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"
 }
--- a/README.md
+++ b/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
--- a/bookshop/app/vue/app.js
+++ b/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 }
            }
        }

--- a/bookshop/app/vue/index.html
+++ b/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>
--- a/bookshop/db/schema.cds
+++ b/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;
--- a/bookshop/index.js
+++ b/bookshop/index.js
@@ -1,2 +1 @@
-const { CatalogService } = require('./srv/cat-service')
-module.exports = { CatalogService }
+exports.CatalogService = require('./srv/cat-service')
--- a/bookshop/srv/cat-service.cds
+++ b/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 };
-  event OrderedBook : { book: Books:ID; quantity: Integer; buyer: String };
+  action submitOrder ( book: Books:ID, amount: Integer ) returns { stock: Integer };
+  event OrderedBook : { book: Books:ID; amount: Integer; buyer: String };
 }
--- a/bookshop/srv/cat-service.js
+++ b/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) {
-      await UPDATE (Books,book) .with (`stock -=`, quantity)
-      await this.emit ('OrderedBook', { book, quantity, buyer:req.user.id })
+    if (stock >= amount) {
+      await UPDATE (Books,book) .with (`stock -=`, amount)
+      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
--- a/bookshop/test/requests.http
+++ b/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 }


 ### ------------------------------------------------------------------------
--- a/fiori/app/admin-fiori.html
+++ b/fiori/app/admin-fiori.html
@@ -1,81 +1,55 @@
 <!DOCTYPE html>
 <html>
-  <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" />
-    <title>Bookshop</title>
+<head>

-    <script>
-      window["sap-ushell-config"] = {
-        defaultRenderer: "fiori2",
-        applications: {
-          "browse-books": {
-            title: "Browse Books",
-            description: "w/ SAP Fiori Elements",
-            additionalInformation: "SAPUI5.Component=bookshop",
-            applicationType: "URL",
-            url: "/browse/webapp",
-            navigationMode: "embedded",
-          },
-          "manage-books": {
-            title: "Manage Books",
-            description: "w/ SAP Fiori Elements",
-            additionalInformation: "SAPUI5.Component=admin",
-            applicationType: "URL",
-            url: "/admin/webapp",
-            navigationMode: "embedded",
-          },
-          "manage-orders": {
-            title: "Manage Orders",
-            description: "w/ SAP Fiori Elements",
-            additionalInformation: "SAPUI5.Component=orders",
-            applicationType: "URL",
-            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>
+	<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" />
+	<title>Bookshop</title>

-    <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-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
-        .getCore()
-        .attachInit(() =>
-          sap.ushell.Container.createRenderer().placeAt("content")
-        );
-      sap.ui
-        .getCore()
-        .getConfiguration()
-        .setFlexibilityServices([{ connector: "SessionStorageConnector" }]);
-    </script>
-  </head>
-  <body class="sapUiBody" id="content"></body>
+	<script>
+		window["sap-ushell-config"] = {
+			defaultRenderer: "fiori2",
+			applications: {
+				"browse-books": {
+					title: "Browse Books",
+					description: "w/ SAP Fiori Elements",
+					additionalInformation: "SAPUI5.Component=bookshop",
+					applicationType : "URL",
+					url: "/browse/webapp",
+					navigationMode: "embedded"
+				},
+				"manage-books": {
+					title: "Manage Books",
+					description: "w/ SAP Fiori Elements",
+					additionalInformation: "SAPUI5.Component=admin",
+					applicationType : "URL",
+					url: "/admin/webapp",
+					navigationMode: "embedded"
+				},
+				"manage-orders": {
+					title: "Manage Orders",
+					description: "w/ SAP Fiori Elements",
+					additionalInformation: "SAPUI5.Component=orders",
+					applicationType : "URL",
+					url: "/orders/webapp",
+					navigationMode: "embedded"
+				}
+			}
+		};
+	</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://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"
+	></script>
+	<script>
+		sap.ui.getCore().attachInit(()=> sap.ushell.Container.createRenderer().placeAt("content"))
+	</script>
+
+</head>
+<body class="sapUiBody" id="content"></body>
 </html>
--- a/fiori/app/admin/fiori-service.cds
+++ b/fiori/app/admin/fiori-service.cds
@@ -1,5 +1,4 @@
-using { AdminService } from '../../db/schema';
-using from '../common'; // to help UI linter get the complete annotations
+using { AdminService, sap.capire.bookshop } from '../../db/schema';

 ////////////////////////////////////////////////////////////////////////////
 //
@@ -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;
 }
--- a/fiori/app/admin/webapp/manifest.json
+++ b/fiori/app/admin/webapp/manifest.json
@@ -22,10 +22,6 @@
        }
    },
    "sap.ui5": {
-        "flexEnabled": true,
-        "config": {   
-            "experimentalCAPScenario": true
-        },
        "dependencies": {
            "libs": {
                "sap.fe.templates": {}
--- a/fiori/app/browse/fiori-service.cds
+++ b/fiori/app/browse/fiori-service.cds
@@ -6,11 +6,11 @@ using CatalogService from '@capire/bookshop';
 //
 annotate CatalogService.Books with @(
 	UI: {
-		HeaderInfo: {
+  	HeaderInfo: {
 			TypeName: 'Book',
 			TypeNamePlural: 'Books',
-			Description: {Value: author}
-		},
+  		Description: {Value: author}
+  	},
 		HeaderFacets: [
 			{$Type: 'UI.ReferenceFacet', Label: '{i18n>Description}', Target: '@UI.FieldGroup#Descr'},
 		],
@@ -38,7 +38,7 @@ annotate CatalogService.Books with @(
 //
 annotate CatalogService.Books with @(
 	UI: {
-		SelectionFields: [ ID, price, currency_code ],
+	  SelectionFields: [ ID, price, currency_code ],
 		LineItem: [
 			{Value: title},
 			{Value: author, Label:'{i18n>Author}'},
--- a/fiori/app/browse/webapp/manifest.json
+++ b/fiori/app/browse/webapp/manifest.json
@@ -22,7 +22,6 @@
    }
  },
  "sap.ui5": {
-    "flexEnabled": true,
    "dependencies": {
      "libs": {
        "sap.fe.templates": {}
--- a/fiori/package.json
+++ b/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",
-        "credentials": {
-          "database": "sqlite.db"
+        "kind": "sql",
+        "[development]": {
+          "model": "db/sqlite"
+        },
+        "[production]": {
+          "model": "db/hana"
        }
-      },
-      "messaging": {
-        "[development]": { "kind": "file-based-messaging" },
-        "[hybrid]": { "kind": "enterprise-messaging-shared" },
-        "kind": "enterprise-messaging"
      }
    }
  }
--- a/fiori/server.js
+++ b/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
 }


--- a/fiori/srv/mashup.cds
+++ b/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;
 }

--- a/fiori/srv/mashup.js
+++ b/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
-    return UPDATE(Books,subject).with({ numberOfReviews:count, rating })
+    const { subject, rating } = msg.data
+    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)
-    .set ('stock -=', deltaQuantity)
+    .and ('stock >=', deltaAmount)
+    .set ('stock -=', deltaAmount)
  })
 }
--- a/fiori/test.http
+++ b/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"}
-    # }},
--- a/hello/README.md
+++ b/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)
--- a/hello/package.json
+++ b/hello/package.json
@@ -3,8 +3,8 @@
  "version": "1.0.0",
  "scripts": {
    "test": "npx jest --silent",
-    "start": "cds serve srv/world.cds",
-    "start:ts": "cds-ts serve srv/world.cds"
+    "watch": "cds serve 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"
-    }
  }
 }
--- a/hello/srv/world.ts
+++ b/hello/srv/world.ts
@@ -1,5 +0,0 @@
-module.exports = class say {
-    hello(req: any) {
-        return `Hello ${req.data.to} from a TypeScript file!`
-    }
-}
--- a/hello/test/hello-world-ts.test.ts
+++ b/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; });
--- a/hello/srv/world.cds
+++ b/hello/srv/world.cds
--- a/hello/srv/world.js
+++ b/hello/srv/world.js
--- a/hello/world.ts
+++ b/hello/world.ts
@@ -0,0 +1,5 @@
+module.exports = class say {
+    hello(req: any) {
+        return `Hello ${req.data.to} from a typescript file!`
+    }
+}
--- a/orders/app/fiori-app.html
+++ b/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-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 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://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"
+	></script>
 	<script>
-		sap.ui.getCore().attachInit(()=> sap.ushell.Container.createRenderer().placeAt("content"));
-		sap.ui
-        .getCore()
-        .getConfiguration()
-        .setFlexibilityServices([{ connector: "SessionStorageConnector" }]);
+		sap.ui.getCore().attachInit(()=> sap.ushell.Container.createRenderer().placeAt("content"))
 	</script>

 </head>
--- a/orders/app/orders/fiori-service.cds
+++ b/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
 	);
 };
--- a/orders/app/orders/webapp/manifest.json
+++ b/orders/app/orders/webapp/manifest.json
@@ -22,10 +22,6 @@
 		}
 	},
 	"sap.ui5": {
-        "flexEnabled": true,
-        "config": {   
-            "experimentalCAPScenario": true
-        },
        "dependencies": {
            "libs": {
                "sap.fe.templates": {}
--- a/orders/db/data/sap.capire.orders-Orders_Items.csv
+++ b/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
--- a/orders/db/schema.cds
+++ b/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;
 }
--- a/orders/srv/orders-service.js
+++ b/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) {
-        const { quantity:before } = await cds.tx(req).run (
-          SELECT.one.from (OrderItems, oi => oi.quantity) .where ({up__ID:ID, product_ID})
+      if (Items) for (let { product_ID, amount } of Items) {
+        const { amount:before } = await cds.tx(req).run (
+          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 })
-    return this.emit ('OrderChanged', { product, deltaQuantity })
+    console.log ('> emitting:', 'OrderChanged', { product, deltaAmount })
+    return this.emit ('OrderChanged', { product, deltaAmount })
  }

 }
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/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-dk": "*"
+    "@sap/cds": "^5",
+    "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
--- a/reviews/srv/reviews-service.cds
+++ b/reviews/srv/reviews-service.cds
@@ -8,11 +8,10 @@ service ReviewsService {
  action unlike (review: type of Reviews:ID);

  // Async API
-  event reviewed : {
-    subject : type of Reviews:subject;
-    count   : Integer;
-    rating  : Decimal;
-  }
+   event reviewed : {
+     subject: type of Reviews:subject;
+     rating: Decimal(2,1)
+   }

  // Input validation
  annotate Reviews with {
--- a/reviews/srv/reviews-service.js
+++ b/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 (
-      SELECT.one `round(avg(rating),2) as rating, count(*) as count` .from (Reviews) .where ({subject})
+    const {rating} = await cds.tx(req) .run (
+      SELECT.one (['round(avg(rating),2) as rating']) .from (Reviews) .where ({subject})
    )
-    global.it || console.log ('< emitting:', 'reviewed', { subject, count, rating })
-    await this.emit ('reviewed', { subject, count, rating })
+    global.it || console.log ('< emitting:', 'reviewed', { subject, rating })
+    await this.emit ('reviewed', { subject, rating })
  })

  // Increment counter for reviews considered helpful
--- a/reviews/test/app/bookshop.html
+++ b/reviews/test/app/bookshop.html
@@ -1,3 +0,0 @@
-<head>
-  <meta http-equiv="refresh" content="0;url=app/bookshop/index.html">
-</head>
--- a/reviews/test/app/reviews.html
+++ b/reviews/test/app/reviews.html
@@ -1,3 +0,0 @@
-<head>
-  <meta http-equiv="refresh" content="0;url=app/reviews/index.html">
-</head>
--- a/reviews/test/package.json
+++ b/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"
-      }
-    }
-  }
-}
--- a/reviews/test/srv/bookshop.cds
+++ b/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;
-}
--- a/reviews/test/srv/bookshop.js
+++ b/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')))
-})
--- a/test/cds.ql.test.js
+++ b/test/cds.ql.test.js
@@ -1,159 +1,96 @@
+const { expect } = require('../test')
 const cds = require('@sap/cds/lib')
-const { expect } = cds.test
-const { cdr } = cds.ql
+const CQL = ([cql]) => cds.parse.cql(cql)
 const Foo = { name: 'Foo' }
 const Books = { name: 'capire.bookshop.Books' }

+const { parse:cdr } = cds.ql

-const STAR = cdr ? '*' : { ref: ['*'] }
-const skip = {to:{eql:()=>skip}}
-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
+// while jest has 'test' as alias to 'it', mocha doesn't
+if (!global.test) global.test = it

 describe('cds.ql → cqn', () => {
  //
+  let cqn

-  for (let each of ['SELECT', 'SELECT one', 'SELECT distinct']) {
-    let SELECT; beforeEach(()=> SELECT = (
-      each === 'SELECT distinct' ? cds.ql.SELECT.distinct :
-      each === 'SELECT one' ? cds.ql.SELECT.one :
-      cds.ql.SELECT
-    ))
-  describe(`${each}...`, () => {
+  describe.skip(`BUGS + GAPS...`, () => {

-    test(`from Foo`, () => {
-      expect(cqn = SELECT `from Foo`)
-      .to.eql(SELECT.from `Foo`)
-      .to.eql(SELECT.from('Foo'))
-      .to.eql(SELECT.from(Foo))
-      .to.eql(SELECT`Foo`)
-      .to.eql(SELECT('Foo'))
-      .to.eql(SELECT(Foo))
-      expect.plain(cqn)
-      .to.eql(CQL`SELECT from Foo`)
-      .to.eql(srv.read `Foo`)
-      .to.eql(srv.read('Foo'))
-      .to.eql(srv.read(Foo))
-      .to.eql({
-        SELECT: { from: { ref: ['Foo'] } },
+    it('should consistently handle *', () => {
+      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,['*']))
    })


-    test('from Foo [<key>]', () => {
+    it('should consistently handle lists', () => {
+      const ID = 11,  args = [`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)
+    })

-      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 }] }]
-        }},
+  })
+
+
+  describe(`SELECT...`, () => {
+    test('from ( Foo )', () => {
+      expect({
+        SELECT: { from: { ref: ['Foo'] } },
+      })
+      .to.eql(CQL`SELECT from Foo`)
+      .to.eql(SELECT.from(Foo))
+    })
+
+    test('from ( ..., <key>)', () => {
+      // Compiler
+      expect(CQL`SELECT from Foo[11]`).to.eql({
+        SELECT: {
+          // REVISIT: add one:true?
+          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,
-            from: { ref: [{ id: 'Foo', where: [{ ref: ['ID'] }, '=', { val: 11 }] }] },
+      expect(CQL`SELECT from Foo[ID=11]`).to.eql({
+        SELECT: {
+          // REVISIT: add one:true
+          from: {
+            ref: [{ id: 'Foo', where: [{ ref: ['ID'] }, '=', { val: 11 }] }],
          },
-        })
-      } else {
-        expect.one(cqn)
+        },
+      })
+
+      // 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 }],
          },
        })
-      }

-    })
-
-    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({
+      expect(CQL`SELECT from Foo[11]{a}`).to.eql({
        SELECT: {
-          from: { ref: ['Foo'] },
-          columns: [ STAR, { ref: ['a'] }, { ref: ['b'], as: 'c' }],
+          // REVISIT: add one:true?
+          from: { ref: [{ id: 'Foo', where: [{ val: 11 }] }] },
+          columns: [{ ref: ['a'] }],
        },
      })

-      cdr && expect.plain(cqn)
-      .to.eql(CQL`SELECT *,a,b as c from Foo`)
-      .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)
+      expect(SELECT.from(Foo, 11, ['a']))
+        .to.eql(SELECT.from(Foo, 11, (foo) => foo.a))
        .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', () => {
-      // SELECT from Foo { *, x, bar.*, car{*}, boo { *, moo.zoo } }
-      expect(cqn =
-        SELECT.from (Foo, foo => {
-          foo`*`, foo.x, foo.car`*`, foo.boo (b => {
-            b`*`, b.moo.zoo(
-              x => x.y.z
-            )
-          })
+    test('from ( ..., => {...})', () => {
+      // single *, prefix and postfix, as array and function
+      let parsed, fluid
+      expect((parsed = CQL`SELECT * from Foo`)).to.eql(CQL`SELECT from Foo{*}`)
+      //> .to.eql... FIXME: see skipped 'should handle * correctly' below
+      expect((fluid = SELECT('*').from(Foo)))
+        .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
-            )
-          })
+
+      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('*')
        })
      )
-
-      expect.plain(cqn)
      .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('with nested inlines', () => {
+    test('from ( ..., => _.inline ( _=>{...}))', () => {
      // SELECT from Foo { *, x, bar.*, car{*}, boo { *, moo.zoo } }
-      expect.plain(
-        SELECT.from (Foo, foo => {
-          foo.bar `*`,
-          foo.bar `.*`, //> leading dot indicates inline
-          foo.boo(_ => _.moo.zoo), //> underscore arg name indicates inline
-          foo.boo(x => x.moo.zoo)
+      expect(
+        SELECT.from(Foo, (foo) => {
+          foo.bar('*'),
+            foo.bar('.*'), //> leading dot indicates inline
+            foo.boo((x) => x.moo.zoo),
+            foo.boo((_) => _.moo.zoo) //> underscore arg name indicates inline
        })
      ).to.eql({
        SELECT: {
@@ -218,142 +209,62 @@ 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 ? [
-            { ref: ['x'] },
-            '=',
-            { val: 1 },
-            'and',
-            // '(',
-            {xpr:[
-              { ref: ['y'] },
-              '=',
-              { val: 2 },
-              'or',
-              { ref: ['z'] },
-              '=',
-              { val: 3 },
-            ]},
-            // ')',
-          ] : [
+          where: [
            { ref: ['x'] },
            '=',
            { val: 1 },
            'and',
            '(',
-            // {xpr:[
-              { ref: ['y'] },
-              '=',
-              { val: 2 },
-              'or',
-              { ref: ['z'] },
-              '=',
-              { val: 3 },
-            // ]},
+            { ref: ['y'] },
+            '=',
+            { val: 2 },
+            'or',
+            { 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,17 +280,18 @@ describe('cds.ql → cqn', () => {
      ).to.eql({
        SELECT: {
          from: { ref: ['Foo'] },
-          where: cdr ? [
-            { ref: ['ID'] },
-            '=',
-            { val: ID },
-            'and',
-            { ref: ['args'] },
-            'in',
-            { list: args.map(val => ({ val })) },
-            'and',
-            {
-              xpr: [
+          where: cds.version >= '5.3.0'
+            ? [
+                // '(', //> this one is not required
+                { ref: ['ID'] },
+                '=',
+                { val: ID },
+                'and',
+                { ref: ['args'] },
+                'in',
+                { list: args.map(val => ({ val })) },
+                'and',
+                '(', //> this one is missing, and that's changing the logic -> that's a BUG
                { ref: ['x'] },
                'like',
                { val: '%x%' },
@@ -387,28 +299,29 @@ describe('cds.ql → cqn', () => {
                { ref: ['y'] },
                '>=',
                { val: 9 },
+                ')',
              ]
-            },
-          ] : [
-            { ref: ['ID'] },
-            '=',
-            { val: ID },
-            'and',
-            { ref: ['args'] },
-            'in',
-            { list: args.map(val => ({ val })) },
-            'and',
-            '(',
-            { ref: ['x'] },
-            'like',
-            { val: '%x%' },
-            'or',
-            { ref: ['y'] },
-            '>=',
-            { val: 9 },
-            ')',
-          ],
-        }
+            : [
+                // '(', //> this one is not required
+                { ref: ['ID'] },
+                '=',
+                { val: ID },
+                'and',
+                { ref: ['args'] },
+                'in',
+                { val: args },
+                'and',
+                '(',  //> this one is missing, and that's changing the logic -> that's a BUG
+                { ref: ['x'] },
+                'like',
+                { val: '%x%' },
+                'or',
+                { ref: ['y'] },
+                '>=',
+                { 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', () => {
--- a/test/consuming-services.test.js
+++ b/test/consuming-services.test.js
@@ -1,11 +1,11 @@
-const cds = require('@sap/cds/lib')
-const { expect } = cds.test (
+const { expect } = require('../test') .run (
  '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))
-    .to.eql(await SELECT.from('Authors'))
-    .to.eql(await AdminService.read(Authors))
+    const _ = expect (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ë',
--- a/test/custom-handlers.test.js
+++ b/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, quantity: 5 }}`
-    await expect(POST `/browse/submitOrder ${{ book: 201, quantity: 5 }}`).to.be.rejectedWith(/409 - 5 exceeds stock for book #201/)
+    await POST('/browse/submitOrder', { book: 201, amount: 5 })
+    await POST('/browse/submitOrder', { book: 201, amount: 5 })
+    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)
  })
--- a/test/hello-world.test.js
+++ b/test/hello-world.test.js
@@ -1,5 +1,4 @@
-const cds = require('@sap/cds/lib')
-const { GET, expect } = cds.test (__dirname+'/../hello')
+const { GET, expect } = require('../test') .run ('serve','hello/world.cds')

 describe('Hello world!', () => {

--- a/test/hierarchical-data.test.js
+++ b/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)
 	})
--- a/test/index.js
+++ b/test/index.js
@@ -0,0 +1,2 @@
+const cds = require('@sap/cds')
+module.exports = cds.test.in(__dirname,'..')
--- a/test/localized-data.test.js
+++ b/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

--- a/test/messaging.test.js
+++ b/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 },
-            { count: 2, subject: '201', rating: 1.5 },
-            { count: 3, subject: '201', rating: 2 },
-            { count: 4, subject: '201', rating: 2.5 },
-            { count: 5, subject: '201', rating: 3 },
+            { subject: '201', rating: 1 },
+            { subject: '201', rating: 1.5 },
+            { subject: '201', rating: 2 },
+            { subject: '201', rating: 2.5 },
+            { subject: '201', rating: 3 },
        ])
    })
 })
--- a/test/odata.test.js
+++ b/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ë' },
--- a/test/registry.test.js
+++ b/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())
-    })
-  })
-
-}