Merge branch 'master' into adding-suppliers

.registry/server.js

@@ -5,7 +5,7 @@ const app = express()
 
 const { PORT=4444 } = process.env
 const [,,port=PORT] = process.argv
-process.chdir(__dirname)
+const cwd = __dirname
 
 app.use('/-/:tarball', (req,res,next) => {
   console.debug ('GET', req.params)
@@ -13,7 +13,7 @@ app.use('/-/:tarball', (req,res,next) => {
     const { tarball } = req.params
     const [, pkg ] = /^capire-(\w+)/.exec(tarball)
     fs.lstat(tarball,(err => {
-      if (err) exec(`npm pack ../${pkg}`,next)
+      if (err) exec(`npm pack ../${pkg}`,{cwd},next)
       else next()
     }))
   } catch (e) {

bookshop/srv/cat-service.cds

@@ -1,13 +1,15 @@
 using { sap.capire.bookshop as my } from '../db/schema';
 service CatalogService @(path:'/browse') {
 
-  @readonly entity Books as SELECT from my.Books { *,
+  /** For displaying lists of Books */
+  @readonly entity ListOfBooks as projection on Books
+  excluding { descr };
+
+  /** For display in details pages */
+  @readonly entity Books as projection on my.Books { *,
     author.name as author
   } excluding { createdBy, modifiedBy };
 
-  @readonly entity ListOfBooks as SELECT from Books
-  excluding { descr };
-
   @requires: 'authenticated-user'
   action submitOrder ( book: Books:ID, amount: Integer ) returns { stock: Integer };
   event OrderedBook : { book: Books:ID; amount: Integer; buyer: String };

test/cds.ql.test.js

@@ -152,69 +152,69 @@ describe('cds.ql → cqn', () => {
       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: ['*'] }],
-          },
+      .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: [
-              cdr ? '*' : { ref: ['*'] },
-              { ref: ['x'] },
-              { ref: ['car'], expand: ['*'] },
-              {
-                ref: ['boo'],
-                expand: ['*', { ref: ['moo', 'zoo'], expand: [{ ref: ['y', 'z'] }] }],
-              },
-            ],
-          },
+    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: [
+            cdr ? '*' : { ref: ['*'] },
+            { ref: ['x'] },
+            { ref: ['car'], expand: ['*'] },
+            {
+              ref: ['boo'],
+              expand: ['*', { ref: ['moo', 'zoo'], expand: [{ ref: ['y', 'z'] }] }],
+            },
+          ],
+        },
       })
+    })
 
-      test('from ( ..., => _.inline ( _=>{...}))', () => {
-        // SELECT from Foo { *, x, bar.*, car{*}, boo { *, 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: {
-            from: { ref: ['Foo'] },
-            columns: [
-              { ref: ['bar'], expand: ['*'] },
-              { ref: ['bar'], inline: ['*'] },
-              { ref: ['boo'], expand: [{ ref: ['moo', 'zoo'] }] },
-              { ref: ['boo'], inline: [{ ref: ['moo', 'zoo'] }] },
-            ],
-          },
+    test('from ( ..., => _.inline ( _=>{...}))', () => {
+      // SELECT from Foo { *, x, bar.*, car{*}, boo { *, 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: {
+          from: { ref: ['Foo'] },
+          columns: [
+            { ref: ['bar'], expand: ['*'] },
+            { ref: ['bar'], inline: ['*'] },
+            { ref: ['boo'], expand: [{ ref: ['moo', 'zoo'] }] },
+            { ref: ['boo'], inline: [{ ref: ['moo', 'zoo'] }] },
+          ],
+        },
       })
+    })
 
     test('one / distinct ...', () => {
       expect(SELECT.distinct.from(Foo).SELECT)