@cap-js/sqlite 0.1.0 → 1.0.0

package/CHANGELOG.md

@@ -4,6 +4,15 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+
+## Version 1.0.0 - 2023-06-23
+
+- First official release
+
+## Version 0.2.0 - 2023-05-03
+
+- Continuous improvements
+
 ## Version 0.1.0 - 2023-04-04
 
 - Initial release

package/README.md

@@ -2,188 +2,5 @@
 
 Welcome to the new SQLite database service for [SAP Cloud Application Programming Model](https://cap.cloud.sap) Node.js, based on new, streamlined database architecture and [*better-sqlite* driver](https://www.npmjs.com/package/better-sqlite3) .
 
->  ⚠️  _**WARNING:** This package is in a beta state._  ⚠️
->
+Find documentation at https://cap.cloud.sap/docs/guides/databases-sqlite.
 
-
-## Installing
-
-### Add `@cap-js/sqlite` as package dependency
-
-As SQLite is commonly used during development or tests only, add it as a dev dependency like so:
-
-```sh
-npm add @cap-js/sqlite -D 
-```
-
->  **Note:** There's no need to add the [*better-sqlite*](https://www.npmjs.com/package/better-sqlite3) driver, and it's also not recommended anymore to do so, as that is done transiently. 
-
-
-### Remove `sqlite3` package dependency
-
-If migrating an existing project you may want to remove the old [*sqlite3* driver](https://www.npmjs.com/package/sqlite3) :
-
-```sh
-npm rm sqlite3
-```
-
-
-## Usage
-
-
-### Via `@cap-js/sqlite` in package dependencies
-
-Adding `@cap-js/sqlite` to your package dependencies as described above is all you need to do. We'll automatically use the new service if that dependency is there in 
-`dependencies` or in `devDependencies`. Your configuration can stay as is, e.g.:
-
-```jsonc
-{ ...,
-  "cds": {
-    "requires": { 
-      "db": "sql" 
-    }
-  }
-}
-```
-
->  **Note:** This automatically also enables the new, lean draft implementation that's required for the new database services, i.e., `cds.fiori.lean_draft` will be automatically set to `true`.
-
-
-### Via `better-sqlite` config profile
-
-Alternatively, if you don't have `@cap-js/sqlite` in your package dependencies, but installed in an outer monorepo like in *[cap/samples](https://github.com/sap-samples/cloud-cap-samples)*, you can occasionally run or test your apps with the `better-sqlite` profile using one of these options to specify the profile:
-
-```sh
-cds watch bookshop --profile better-sqlite
-```
-```sh
-CDS_ENV=better-sqlite cds watch bookshop
-```
-```sh
-CDS_ENV=better-sqlite jest --silent
-```
-
-
-
-## New Features & Improvements
-
-### Full Support for Path Expressions
-
-The new SQLite service provides full support for all kinds of [path expressions](https://cap.cloud.sap/docs/cds/cql#path-expressions), including [infix filters](https://cap.cloud.sap/docs/cds/cql#with-infix-filters), and [exists predicates](https://cap.cloud.sap/docs/cds/cql#exists-predicate). For example, you can try this out with *[cap/samples](https://github.com/sap-samples/cloud-cap-samples)* as follows: 
-
-```sh
-cds repl --profile better-sqlite
-var { server } = await cds.test('bookshop')
-var { Books, Authors } = cds.entities
-await INSERT.into (Books) .entries ({ title: 'Unwritten Book' })
-await INSERT.into (Authors) .entries ({ name: 'Upcomming Author' })
-await SELECT `from ${Books} { title as book, author.name as author, genre.name as genre }`
-await SELECT `from ${Authors} { books.title as book, name as author, books.genre.name as genre }`
-await SELECT `from ${Books} { title as book, author[ID<170].name as author, genre.name as genre }`
-await SELECT `from ${Books} { title as book, author.name as author, genre.name as genre }` .where ({'author.name':{like:'Ed%'},or:{'author.ID':170}})
-await SELECT `from ${Books} { title as book, author.name as author, genre.name as genre } where author.name like 'Ed%' or author.ID=170`
-await SELECT `from ${Books}:author[name like 'Ed%' or ID=170] { books.title as book, name as author, books.genre.name as genre }`
-await SELECT `from ${Books}:author[150] { books.title as book, name as author, books.genre.name as genre }`
-await SELECT `from ${Authors} { ID, name, books { ID, title }}`
-await SELECT `from ${Authors} { ID, name, books { ID, title, genre { ID, name }}}`
-await SELECT `from ${Authors} { ID, name, books.genre { ID, name }}`
-await SELECT `from ${Authors} { ID, name, books as some_books { ID, title, genre.name as genre }}`
-await SELECT `from ${Authors} { ID, name, books[genre.ID=11] as dramatic_books { ID, title, genre.name as genre }}`
-await SELECT `from ${Authors} { ID, name, books.genre[name!='Drama'] as no_drama_books_count { count(*) as sum }}`
-await SELECT `from ${Authors} { books.genre.ID }`
-await SELECT `from ${Authors} { books.genre }`
-await SELECT `from ${Authors} { books.genre.name }`
-
-```
-
-
-
-### Specified Standard Functions
-
-A specified set of standard functions is now supported and translated to database-specific variants. These functions are by and large the same as specified in OData: 
-
-* `concat`, `indexof`, `length`
-* `contains`, `startswith`, `endswith`, `substring`, `matchesPattern`
-* `tolower`, `toupper`
-* `ceiling`
-* `year`, `month`, `day`, `hour`, `minute`, `second`
-
-The db service implementation translates these to the best-possible native SQL functions, thus enhancing the extend of **portable** queries. 
-
-> **Note** that usage is **case-sensitive**, which means you have to write these functions exactly as given above; all-uppercase usages are not supported. 
-
-### Support for Common HANA Functions
-
-In addition to the standard functions, which all new database services will support, the new SQLite service also supports these common HANA functions, to further increase the scope for portable testing:
-
-- `years_between`
-- `months_between`
-- `days_between`
-- `seconds_between`
-- `nano100_between`
-
-> Both usages are allowed here: all-lowercase as given above, as well as all-uppercase.
-
-### Support for Session Context Variables
-
-The new SQLite service can leverage  [*better-sqlite*](https://www.npmjs.com/package/better-sqlite3)'s user-defined functions to support *session context* variables. In particular, the pseudo variables `$user.id`, `$user.locale`,  `$valid.from`, and `$valid.to` are available in native SQL queries like so: 
-
-```sql
-SELECT session_context('$user.id')
-SELECT session_context('$user.locale')
-SELECT session_context('$valid.from')
-SELECT session_context('$valid.to')
-```
-
-Amongst other, this allows us to get rid of static helper views for localized data like `localized_de_sap_capire_Books`. 
-
-### Deep Reads via Single Queries
-
-The old database service implementation(s) translated deep reads, i.e., SELECTs with expands, into several database queries and collected the individual results into deep result structures. The new service uses `json_object` functions and alike to instead do that in one single query, with sub selects, which greatly improves performance. 
-
-### New `SELECT.localized` Queries
-
-With the old implementation when running queries like `SELECT.from(Books)` would always return localized data, without being able to easily read the non-localized data. The new service does only what you asked for, offering new `SELECT.localized` options:
-
-```js
-let books = await SELECT.from(Books)       //> non-localized data
-let lbooks = await SELECT.localized(Books) //> localized data
-```
-
-Usage variants include:  
-
-```js
-SELECT.localized(Books)
-SELECT.from.localized(Books)
-SELECT.one.localized(Books)
-```
-
-> **Note:** Queries executed through generic application service handlers continue to serve localized data as before. 
-
-### Using Lean Draft Implementation
-
-The old implementation was overly polluted with draft handling. But as draft is actually a Fiori UI concept, that should not be the case. Hence, we eliminated all draft handling from the new database service implementations, and implemented draft in a modular, non-intrusive way — called *'Lean Draft'*. The most important change is that we don't do expensive UNIONs anymore but work with single cheap selects. 
-
-When using the new SQLite service the new `cds.fiori.lean_draft` mode is automatically switched on. You may additionally switch on `cds.fiori_draft_compat` in case you run into problems. 
-
-More detailed documentation for that will follow soon. 
-
-### Performance Improvements
-
-The combination of the above-mentioned improvements commonly leads to significant performance improvements. For example displaying the list page of Travels in [cap/sflight](https://github.com/SAP-samples/cap-sflight) took **>250ms** in the past, and **~15ms** now.
-
-## Known Limitations & Changes
-
-- Node v14 is no longer supported → will be dropped anyways with upcomming cds7.
-- JOINs and UNIONs by CQN are no longer supported → use plain SQL instead.
-* CQNs with subqueries require table aliases to refer to elements of outer queries.
-* CQNs with an empty columns array now throws an error.
-* Search: only single values are allowed as search expression.
-* CSV input: column names like `author.ID` are disallowed → use  `author_ID` instead.
-* No `default` values are returned anymore for `virtual` elements.
-* `SELECT.from(...)` queries on database level don't return localized data anymore → use `SELECT.localized(...)`
-* Standard functions in CQN are case-sensitive → don't uppercase them.
-* For `@cds.on.insert/update`annotations only `$now` and `$user.id` are supported.
-* The `cds/db.stream()` methods are not implemented yet → will come soon.
-
-_The list of important changes is not final and will be constantly updated._

package/cds-plugin.js

@@ -0,0 +1,5 @@
+const cds = require('@sap/cds/lib')
+
+if (!cds.env.fiori.lean_draft) {
+  throw new Error('"@cap-js/sqlite" only works if cds.fiori.lean_draft is enabled. Please adapt your configuration.')
+}

package/index.js

@@ -1 +1 @@
-module.exports = require('./lib/db/sqlite/SQLiteService.js')
+module.exports = require('./lib/SQLiteService.js')

package/lib/ReservedWords.json

@@ -0,0 +1,149 @@
+{
+  "ABORT": 1,
+  "ACTION": 1,
+  "ADD": 1,
+  "AFTER": 1,
+  "ALL": 1,
+  "ALTER": 1,
+  "ALWAYS": 1,
+  "ANALYZE": 1,
+  "AND": 1,
+  "AS": 1,
+  "ASC": 1,
+  "ATTACH": 1,
+  "AUTOINCREMENT": 1,
+  "BEFORE": 1,
+  "BEGIN": 1,
+  "BETWEEN": 1,
+  "BY": 1,
+  "CASCADE": 1,
+  "CASE": 1,
+  "CAST": 1,
+  "CHECK": 1,
+  "COLLATE": 1,
+  "COLUMN": 1,
+  "COMMIT": 1,
+  "CONFLICT": 1,
+  "CONSTRAINT": 1,
+  "CREATE": 1,
+  "CROSS": 1,
+  "CURRENT": 1,
+  "CURRENT_DATE": 1,
+  "CURRENT_TIME": 1,
+  "CURRENT_TIMESTAMP": 1,
+  "DATABASE": 1,
+  "DEFAULT": 1,
+  "DEFERRABLE": 1,
+  "DEFERRED": 1,
+  "DELETE": 1,
+  "DESC": 1,
+  "DETACH": 1,
+  "DISTINCT": 1,
+  "DO": 1,
+  "DROP": 1,
+  "EACH": 1,
+  "ELSE": 1,
+  "END": 1,
+  "ESCAPE": 1,
+  "EXCEPT": 1,
+  "EXCLUDE": 1,
+  "EXCLUSIVE": 1,
+  "EXISTS": 1,
+  "EXPLAIN": 1,
+  "FAIL": 1,
+  "FILTER": 1,
+  "FIRST": 1,
+  "FOLLOWING": 1,
+  "FOR": 1,
+  "FOREIGN": 1,
+  "FROM": 1,
+  "FULL": 1,
+  "GENERATED": 1,
+  "GLOB": 1,
+  "GROUP": 1,
+  "GROUPS": 1,
+  "HAVING": 1,
+  "IF": 1,
+  "IGNORE": 1,
+  "IMMEDIATE": 1,
+  "IN": 1,
+  "INDEX": 1,
+  "INDEXED": 1,
+  "INITIALLY": 1,
+  "INNER": 1,
+  "INSERT": 1,
+  "INSTEAD": 1,
+  "INTERSECT": 1,
+  "INTO": 1,
+  "IS": 1,
+  "ISNULL": 1,
+  "JOIN": 1,
+  "KEY": 1,
+  "LAST": 1,
+  "LEFT": 1,
+  "LIKE": 1,
+  "LIMIT": 1,
+  "MATCH": 1,
+  "MATERIALIZED": 1,
+  "NATURAL": 1,
+  "NO": 1,
+  "NOT": 1,
+  "NOTHING": 1,
+  "NOTNULL": 1,
+  "NULL": 1,
+  "NULLS": 1,
+  "OF": 1,
+  "OFFSET": 1,
+  "ON": 1,
+  "OR": 1,
+  "ORDER": 1,
+  "OTHERS": 1,
+  "OUTER": 1,
+  "OVER": 1,
+  "PARTITION": 1,
+  "PLAN": 1,
+  "PRAGMA": 1,
+  "PRECEDING": 1,
+  "PRIMARY": 1,
+  "QUERY": 1,
+  "RAISE": 1,
+  "RANGE": 1,
+  "RECURSIVE": 1,
+  "REFERENCES": 1,
+  "REGEXP": 1,
+  "REINDEX": 1,
+  "RELEASE": 1,
+  "RENAME": 1,
+  "REPLACE": 1,
+  "RESTRICT": 1,
+  "RETURNING": 1,
+  "RIGHT": 1,
+  "ROLLBACK": 1,
+  "ROW": 1,
+  "ROWS": 1,
+  "SAVEPOINT": 1,
+  "SELECT": 1,
+  "SET": 1,
+  "TABLE": 1,
+  "TEMP": 1,
+  "TEMPORARY": 1,
+  "THEN": 1,
+  "TIES": 1,
+  "TO": 1,
+  "TRANSACTION": 1,
+  "TRIGGER": 1,
+  "UNBOUNDED": 1,
+  "UNION": 1,
+  "UNIQUE": 1,
+  "UPDATE": 1,
+  "USING": 1,
+  "VACUUM": 1,
+  "VALUES": 1,
+  "VIEW": 1,
+  "VIRTUAL": 1,
+  "WHEN": 1,
+  "WHERE": 1,
+  "WINDOW": 1,
+  "WITH": 1,
+  "WITHOUT": 1
+}

package/lib/SQLiteService.js

@@ -0,0 +1,215 @@
+const { SQLService } = require('@cap-js/db-service')
+const { Readable } = require('stream')
+const cds = require('@sap/cds/lib')
+const sqlite = require('better-sqlite3')
+const $session = Symbol('dbc.session')
+const convStrm = require('stream/consumers')
+
+class SQLiteService extends SQLService {
+  get factory() {
+    return {
+      options: { max: 1, ...this.options.pool },
+      create: tenant => {
+        const database = this.url4(tenant)
+        const dbc = new sqlite(database)
+        dbc.function('SESSION_CONTEXT', key => dbc[$session][key])
+        dbc.function('REGEXP', { deterministic: true }, (re, x) => (RegExp(re).test(x) ? 1 : 0))
+        if (!dbc.memory) dbc.pragma('journal_mode = WAL')
+        return dbc
+      },
+      destroy: dbc => dbc.close(),
+      validate: dbc => dbc.open,
+    }
+  }
+
+  url4(tenant) {
+    let { url, database: db = url } = this.options.credentials || this.options || {}
+    if (!db || db === ':memory:') return ':memory:'
+    if (tenant) db = db.replace(/\.(db|sqlite)$/, `-${tenant}.$1`)
+    return cds.utils.path.resolve(cds.root, db)
+  }
+
+  set(variables) {
+    const dbc = this.dbc || cds.error('Cannot set session context: No database connection')
+    if (!dbc[$session]) {
+      dbc[$session] = variables // initial call from within this.begin()
+      const $super = this._release
+      this._release = function (dbc) {
+        // reset session on release
+        delete dbc[$session]
+        return $super.call(this, dbc)
+      }
+    } else Object.assign(dbc[$session], variables) // subsequent uses from custom code
+  }
+
+  prepare(sql) {
+    try {
+      return this.dbc.prepare(sql)
+    } catch (e) {
+      e.message += ' in:\n' + (e.sql = sql)
+      throw e
+    }
+  }
+
+  exec(sql) {
+    return this.dbc.exec(sql)
+  }
+
+  static CQN2SQL = class CQN2SQLite extends SQLService.CQN2SQL {
+    SELECT_columns({ SELECT }) {
+      if (!SELECT.columns) return '*'
+      const { orderBy } = SELECT
+      const orderByMap = {}
+      // Collect all orderBy columns that should be taken from the SELECT.columns
+      if (Array.isArray(orderBy))
+        orderBy?.forEach(o => {
+          if (o.ref?.length === 1) {
+            orderByMap[o.ref[0]] = true
+          }
+        })
+      return SELECT.columns.map(x => {
+        const alias = this.column_name(x)
+        // Check whether the column alias should be added
+        const xpr = this.column_expr(x)
+        const needsAlias = (typeof x.as === 'string' && x.as) || orderByMap[alias]
+        return `${xpr}${needsAlias ? ` as ${this.quote(alias)}` : ''}`
+      })
+    }
+
+    operator(x, i, xpr) {
+      if (x === '=' && xpr[i + 1]?.val === null) return 'is'
+      if (x === '!=') return 'is not'
+      else return x
+    }
+
+    // Used for INSERT statements
+    static InputConverters = {
+      ...super.InputConverters,
+      Date: e => `strftime('%Y-%m-%d',${e})`,
+      Time: e => `strftime('%H:%M:%S',${e})`,
+      DateTime: e => `strftime('%Y-%m-%dT%H:%M:%SZ',${fixTimeZone(e)})`,
+      Timestamp: e => `strftime('%Y-%m-%dT%H:%M:%fZ',${fixTimeZone(e)})`,
+    }
+
+    static OutputConverters = {
+      ...super.OutputConverters,
+      boolean: expr => `CASE ${expr} when 1 then 'true' when 0 then 'false' END ->'$'`, // REVIEW: ist that correct?
+      Int64: expr => `CAST(${expr} as TEXT)`, // REVISIT: As discussed: please put that on a list of things to revisit later on
+      Decimal: expr => `nullif(quote(${expr}),'NULL')->'$'`, // REVISIT: what is that ->'$' doing?
+      Float: expr => `nullif(quote(${expr}),'NULL')->'$'`,
+      Double: expr => `nullif(quote(${expr}),'NULL')->'$'`,
+      struct: expr => `${expr}->'$'`, // Association + Composition inherits from struct
+      array: expr => `${expr}->'$'`,
+      // REVISIT: Timestamp should not loos precision
+      Date: e => `strftime('%Y-%m-%d',${e})`,
+      Time: e => `strftime('%H:%M:%S',${e})`,
+      DateTime: e => `strftime('%Y-%m-%dT%H:%M:%SZ',${fixTimeZone(e)})`,
+      Timestamp: e => `strftime('%Y-%m-%dT%H:%M:%fZ',${fixTimeZone(e)})`,
+    }
+
+    // Used for SQL function expressions
+    static Functions = { ...super.Functions }
+
+    // Used for CREATE TABLE statements
+    static TypeMap = {
+      ...super.TypeMap,
+      Binary: e => `BINARY_BLOB(${e.length || 5000})`,
+      Date: () => 'DATE_TEXT',
+      Time: () => 'TIME_TEXT',
+      DateTime: () => 'TIMESTAMP_TEXT',
+      Timestamp: () => 'TIMESTAMP_TEXT',
+    }
+
+    static ReservedWords = { ...super.ReservedWords, ...require('./ReservedWords.json') }
+  }
+
+  // REALLY REVISIT: Here we are doing error handling which we probably never should have started.
+  // And worst of all, we handed out this as APIs without documenting it, so stakeholder tests rely
+  // on that? -> we urgently need to review these stakeholder tests.
+  // And we'd also need this to be implemented by each db service, and therefore documented, correct?
+  async onINSERT(req) {
+    try {
+      return await super.onINSERT(req)
+    } catch (err) {
+      throw _not_unique(err, 'ENTITY_ALREADY_EXISTS') || err
+    }
+  }
+
+  async onUPDATE(req) {
+    try {
+      return await super.onUPDATE(req)
+    } catch (err) {
+      throw _not_unique(err, 'UNIQUE_CONSTRAINT_VIOLATION') || err
+    }
+  }
+
+  // overrides generic onSTREAM
+  // SQLite doesn't support streaming, the whole data is read from/written into the database
+  async onSTREAM(req) {
+    const { sql, values, entries } = this.cqn2sql(req.query)
+    // writing stream
+    if (req.query.STREAM.into) {
+      const stream = entries[0]
+      stream.on('error', () => stream.removeAllListeners('error'))
+      values.unshift((await convStrm.buffer(stream)).toString('base64'))
+      const ps = await this.prepare(sql)
+      return (await ps.run(values)).changes
+    }
+    // reading stream
+    const ps = await this.prepare(sql)
+    let result = await ps.all(values)
+    if (result.length === 0) return
+
+    const val = Object.values(result[0])[0]
+    if (val === null) return val
+    const stream_ = new Readable()
+    stream_.push(Buffer.from(val, 'base64'))
+    stream_.push(null)
+    return stream_
+  }
+}
+
+// function _not_null (err) {
+//   if (err.code === "SQLITE_CONSTRAINT_NOTNULL") return Object.assign ({
+//     code: 'MUST_NOT_BE_NULL',
+//     target: /\.(.*?)$/.exec(err.message)[1], // here we are even constructing OData responses, with .target
+//     message: 'Value is required',
+//   })
+// }
+
+function _not_unique(err, code) {
+  if (err.message.match(/unique constraint/i))
+    return Object.assign({
+      originalMessage: err.message, // FIXME: required because of next line
+      message: code, // FIXME: misusing message as code
+      code: 400, // FIXME: misusing code as (http) status
+    })
+}
+
+/**
+ * Generates SQL statement that allows SQLite to support most of the ISO 8601 timezone syntaxes
+ * @example
+ * '1970-01-01T00:00:00+0200' -> '1970-01-01T00:00:00+02:00'
+ * @example
+ * '1970-01-01T00:00:00-02' -> '1970-01-01T00:00:00-02:00'
+ * @example
+ * '1970-01-01T00:00:00Z' -> '1970-01-01T00:00:00Z'
+ * @param {String} e value SQL expression
+ * @returns {String} SQL statement that ensures that the value has the valid ISO timezone for SQLite
+ */
+const fixTimeZone = e =>
+  `(
+  SELECT
+    CASE
+      WHEN substr(T,length(T),1) = 'Z' THEN 
+        T
+      WHEN substr(T,length(T) - 4,1) = '-' OR substr(T,length(T) - 4,1) = '+' THEN
+        substr(T,0,length(T) - 1) || ':' || substr(T,length(T) - 1)
+      WHEN substr(T,length(T) - 2,1) = '-' OR substr(T,length(T) - 2,1) = '+' THEN 
+        T || ':' || '00'
+      ELSE T
+    END AS T
+  FROM (SELECT (${e}) AS T)
+)`.replace(/\s*\n\s*/g, ' ')
+
+module.exports = SQLiteService

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/sqlite",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "description": "CDS database service for SQLite",
   "homepage": "https://cap.cloud.sap/",
   "keywords": [
@@ -9,44 +9,40 @@
     "SQLite"
   ],
   "author": "SAP SE (https://www.sap.com)",
-  "license": "SEE LICENSE",
-  "homepage": "https://cap.cloud.sap/",
   "main": "index.js",
   "files": [
-    "cds.js",
-    "lib/db/DatabaseService.js",
-    "lib/db/sqlite",
-    "lib/db/sql",
-    "lib/ql",
-    "LICENSE",
+    "cds-plugin.js",
+    "lib",
     "CHANGELOG.md"
   ],
   "engines": {
-    "node": ">=14",
+    "node": ">=16",
     "npm": ">=8"
   },
   "scripts": {
-    "//pg:up": "use only for dev time, CI is handled separately",
-    "pg:up": "docker-compose -f etc/pg-stack.yml up -d",
-    "prettier": "npx prettier --write .",
-    "test": "jest --silent",
-    "lint": "npx eslint . && npx prettier --check ."
+    "test": "jest --silent"
   },
   "dependencies": {
+    "@cap-js/db-service": "^1",
     "better-sqlite3": "^8"
   },
   "peerDependencies": {
-    "@sap/cds": "*"
+    "@sap/cds": ">=7"
+  },
+  "cds": {
+    "requires": {
+      "kinds": {
+        "sql": {
+          "[development]": {
+            "kind": "sqlite"
+          }
+        },
+        "sqlite": {
+          "impl": "@cap-js/sqlite"
+        }
+      },
+      "db": "sql"
+    }
   },
-  "devDependencies": {
-    "@capire/sflight": "sap-samples/cap-sflight",
-    "@cap-js/sqlite": ".",
-    "axios": ">=1.3",
-    "chai": "^4.3.7",
-    "chai-as-promised": "^7.1.1",
-    "chai-subset": "^1.6.0",
-    "express": "^4",
-    "pg": "^8",
-    "jest": "^29"
-  }
+  "license": "SEE LICENSE"
 }