@sap/cds 1.15.1 → 1.18.2

package/cds.js

@@ -1,76 +1,79 @@
-var async = require('async');
-
-var metadata = require('./metadata');
-var manager = require('./manager');
-var queries = require("./cds-queries");
-var SqlQuery = queries.Query;
-var transaction = require('./transaction');
+const async = require('async');
 
+const metadata = require('./metadata');
+const manager = require('./manager');
+const queries = require('./cds-queries');
+const SqlQuery = queries.Query;
+const transaction = require('./transaction');
+const _hdbext = require('./_hdbext');
 
 // transactions
 
 // returns connected DB client
-exports.$getTransaction = function (dbconn, callback) {
-    if (typeof callback === "undefined") {
-        callback = dbconn;
-        dbconn = null;
+exports.$getTransaction = function(dbconn, callback) {
+  if (typeof callback === 'undefined') {
+    callback = dbconn;
+    dbconn = null;
+  }
+  transaction.getClient(dbconn, function(err, client) {
+    if (err) {
+      return callback(err);
     }
-    transaction.getClient(dbconn, function(err, client) {
-        if (err)
-            return callback(err);
-        client.$get = function (entity, key, callback) {
-            manager._get(client, entity, key, callback);
-        };
-        client.$find = function (entity, condition, callback) {
-            manager._find(client, entity, condition, callback);
-        };
-        client.$save = function (instance, callback) {
-            manager._save(client, instance, callback);
-        };
-        client.$discard = function (instance, callback) {
-            manager._discard(client, instance, callback);
-        };
-        client.$getAll = function (refs, callback) {
-            var getter = function (ref, cb) {
-                manager._get(client, ref.$entity, ref, cb);
-            };
-            async.map(refs, getter, callback);
-        };
-        client.$findAll = function (refs, callback) {
-            var finder = function (ref, cb) {
-                manager._find(client, ref.$entity, ref, cb);
-            };
-            async.map(refs, finder, callback);
-        };
-        client.$saveAll = function (refs, callback) {
-            var saver = function(ref, cb) {
-                manager._save(client, ref, cb);
-            };
-            async.map(refs, saver, callback);
-        };
-        client.$discardAll = function (refs, callback) {
-            var discarder = function(ref, cb) {
-                manager._discard(client, ref, cb);
-            };
-            async.map(refs, discarder, function(err) { callback(err); });
-        };
-        client.$delete = function(entity, condition, callback) {
-            manager._delete(client, entity, condition, callback);
-        };
-        client.$setAutoCommit = function (auto) {
-            transaction._autoCommit(client, auto);
-        };
-        client.$commit = function (callback) {
-            transaction._commit(client, callback);
-        };
-        client.$rollback = function (callback) {
-            transaction._rollback(client, callback);
-        };
-        client.$close = function() {
-            transaction.releaseClient(client, dbconn);
-        };
-        callback(err, client);
-    });
+    client.$get = function(entity, key, callback) {
+      manager._get(client, entity, key, callback);
+    };
+    client.$find = function(entity, condition, callback) {
+      manager._find(client, entity, condition, callback);
+    };
+    client.$save = function(instance, callback) {
+      manager._save(client, instance, callback);
+    };
+    client.$discard = function(instance, callback) {
+      manager._discard(client, instance, callback);
+    };
+    client.$getAll = function(refs, callback) {
+      const getter = function(ref, cb) {
+        manager._get(client, ref.$entity, ref, cb);
+      };
+      async.map(refs, getter, callback);
+    };
+    client.$findAll = function(refs, callback) {
+      const finder = function(ref, cb) {
+        manager._find(client, ref.$entity, ref, cb);
+      };
+      async.map(refs, finder, callback);
+    };
+    client.$saveAll = function(refs, callback) {
+      const saver = function(ref, cb) {
+        manager._save(client, ref, cb);
+      };
+      async.map(refs, saver, callback);
+    };
+    client.$discardAll = function(refs, callback) {
+      const discarder = function(ref, cb) {
+        manager._discard(client, ref, cb);
+      };
+      async.map(refs, discarder, function(err) {
+        callback(err);
+      });
+    };
+    client.$delete = function(entity, condition, callback) {
+      manager._delete(client, entity, condition, callback);
+    };
+    client.$setAutoCommit = function(auto) {
+      transaction._autoCommit(client, auto);
+    };
+    client.$commit = function(callback) {
+      transaction._commit(client, callback);
+    };
+    client.$rollback = function(callback) {
+      transaction._rollback(client, callback);
+    };
+    client.$close = function() {
+      transaction.releaseClient(client, dbconn);
+    };
+    callback(err, client);
+  });
 };
 
 
@@ -78,55 +81,57 @@ exports.$getTransaction = function (dbconn, callback) {
 
 // batch-import (main API function)
 exports.$importEntities = function(refs, opts, callback) {
-    if (typeof callback === "undefined") {
-        callback = opts;
-        opts = {};
+  if (typeof callback === 'undefined') {
+    callback = opts;
+    opts = {};
+  }
+  metadata._import(refs, opts, function(error, entities) {
+    for (const name in entities) {
+      if (entities[name]) {
+        addXSInterface(entities[name]);
+      }
     }
-    metadata._import(refs, opts, function (error, entities) {
-        for (var name in entities)
-            if (entities[name])
-                addXSInterface(entities[name]);
-        callback(error, entities);
-    });
-}
+    callback(error, entities);
+  });
+};
 
 exports.$importEntity = function(ref, callback) {
-    exports.$importEntities([ref], callback);
+  exports.$importEntities([ref], callback);
 };
 
 // (async) retrieve entity object by name
 // NOTE: callback will never be invoked if entity is not imported!
 exports.$getEntity = function(entityName, callback) {
-    metadata.getEntity(entityName, callback);
+  metadata.getEntity(entityName, callback);
 };
 exports.$getEntities = function(entityNames, callback) {
-    var getter = function (name, cb) {
-        exports.$getEntity(name, cb);
-    };
-    async.map(entityNames, getter, callback);
+  const getter = function(name, cb) {
+    exports.$getEntity(name, cb);
+  };
+  async.map(entityNames, getter, callback);
 };
 
 // retrieve entity object by name
 // NOTE: returns null if entity import has not completed yet
 exports.$getEntitySync = function(entityName) {
-    return metadata.getEntitySync(entityName);
+  return metadata.getEntitySync(entityName);
 };
 
 
 // instance management
 
 function addXSInterface(entity) {
-    // batch operations
-    entity.$prepare = function(value) {
-        value.$entity = entity;
-        return value;
-    };
-    // general queries
-    entity.$query = function(client) {
-        var param = {};
-        param["t0"] = { entity: entity };
-        return new SqlQuery(client, param);
-    };
+  // batch operations
+  entity.$prepare = function(value) {
+    value.$entity = entity;
+    return value;
+  };
+  // general queries
+  entity.$query = function(client) {
+    const param = {};
+    param['t0'] = {entity: entity};
+    return new SqlQuery(client, param);
+  };
 }
 
 
@@ -141,7 +146,7 @@ exports._clearImports = metadata._clearImports;
 exports.Query = SqlQuery;
 exports.createQuery = queries.createQuery;
 exports.$par = function(id) {
-    return new queries.Par(id);
+  return new queries.Par(id);
 };
 
 
@@ -154,12 +159,14 @@ exports.save = exports.$save;
 exports.queries = queries;
 exports.extensionPoints = manager.extensionPoints; // hook for extenders
 exports.xsjs = function(conn, callback) {
-    exports.$getTransaction(conn._client, function(err, tx) {
-        if (err) {
-            callback(err);
-        } else {
-            var xsjscds = require("./xsjs-cds").init(tx);
-            callback(null, xsjscds);
-        }
-    });
+  exports.$getTransaction(conn._client, function(err, tx) {
+    if (err) {
+      callback(err);
+    } else {
+      const xsjscds = require('./xsjs-cds').init(tx);
+      callback(null, xsjscds);
+    }
+  });
 }.sync;
+// Use at your own risk, middleware comes from @sap/hdbext@^4
+exports.middleware = _hdbext.middleware;

package/exprs.js

@@ -1,142 +1,153 @@
-var utils = require('./utils');
+const utils = require('./utils');
 
 
 // NOTE: function raises exception in case of invalid expression
 exports.buildInstanceFilter = function(entity, condition) {
-    return function(instance) {
-        return evalExpression(entity, condition, instance);
-    };
+  return function(instance) {
+    return evalExpression(entity, condition, instance);
+  };
 };
 
 
 // check if given instance matches property criteria
 function evalExpression(entity, criteria, instance) {
-    var realcrit = criteria.$eq || criteria.$ne || criteria;
-    var match = true;
-    utils.forInstance(realcrit, entity.$_mapping, {
-        $column: function(p, f, v, m) {
-            if (v === null || typeof v[f] === "undefined")
-                return;  // property not part of criteria
-            var value = utils.getPropPath(instance, p + f);
-            if (!evalCondition(v[f], value))
-                match = false;
-        },
-        $association: function(p, f, v, m) {
-            if (v === null || typeof v[f] === "undefined")
-                return;  // property not part of criteria
-            var value = utils.getPropPath(instance, p + f);
-            // empty association
-            if (v[f] === null) { // short for { $none: true }
-                match = match && !value;
-                return;
-            } else if ("$none" in v[f]) {
-                match = match && (v[f].$none && isnone(value) || !v[f].$none && !isnone(value));
-                return;
-            } else if ("$empty" in v[f]) {  // deprecated for "$none"
-                match = match && (v[f].$empty && isnone(value) || !v[f].$empty && !isnone(value));
-                return;
-            } else if ("$null" in v[f]) {
-                throw new Error("invalid $null operator on association");
-            } else if (!value) {
-                match = match && (v[f].$none || v[f].$empty);
-                return;
-            }
-            // non-empty association
-            if (utils.isArray(value))
-                throw new Error("invalid navigation in expression");
-            if (!("$_entity" in value))
-                throw new Error("*** ASSERT FAIL *** comparing against non-instance");
-            if ("$_entity" in v[f]) {
-                // shortcut for comparing two instances
-                if (v[f] === value)
-                    return;  // found match --> keep match unchanged
-            } else {
-                // follow association recursively
-                if (evalExpression(m[f].$association.$class, v[f], value))
-                    return;  // found match --> keep match unchanged
-            }
-            match = false;
-        }
-    });
-    return "$ne" in criteria ? !match : match;
+  const realcrit = criteria.$eq || criteria.$ne || criteria;
+  let match = true;
+  utils.forInstance(realcrit, entity.$_mapping, {
+    $column: function(p, f, v, m) {
+      if (v === null || typeof v[f] === 'undefined') {
+        return;
+      } // property not part of criteria
+      const value = utils.getPropPath(instance, p + f);
+      if (!evalCondition(v[f], value)) {
+        match = false;
+      }
+    },
+    $association: function(p, f, v, m) {
+      if (v === null || typeof v[f] === 'undefined') {
+        return;
+      } // property not part of criteria
+      const value = utils.getPropPath(instance, p + f);
+      // empty association
+      if (v[f] === null) { // short for { $none: true }
+        match = match && !value;
+        return;
+      } else if ('$none' in v[f]) {
+        match = match && (v[f].$none && isnone(value) || !v[f].$none && !isnone(value));
+        return;
+      } else if ('$empty' in v[f]) { // deprecated for "$none"
+        match = match && (v[f].$empty && isnone(value) || !v[f].$empty && !isnone(value));
+        return;
+      } else if ('$null' in v[f]) {
+        throw new Error('invalid $null operator on association');
+      } else if (!value) {
+        match = match && (v[f].$none || v[f].$empty);
+        return;
+      }
+      // non-empty association
+      if (utils.isArray(value)) {
+        throw new Error('invalid navigation in expression');
+      }
+      if (!('$_entity' in value)) {
+        throw new Error('*** ASSERT FAIL *** comparing against non-instance');
+      }
+      if ('$_entity' in v[f]) {
+        // shortcut for comparing two instances
+        if (v[f] === value) {
+          return;
+        } // found match --> keep match unchanged
+      } else {
+        // follow association recursively
+        if (evalExpression(m[f].$association.$class, v[f], value)) {
+          return;
+        } // found match --> keep match unchanged
+      }
+      match = false;
+    },
+  });
+  return '$ne' in criteria ? !match : match;
 }
 
 
 // evaluate condition for property value
-var evalCondition = function(condition, value) {
-    // condition === expr
-    if (typeof condition !== 'object')
-        // NOTE: direct comparison between objects is always a bad idea
-        return defaultCompare(value, condition) === 0;
+const evalCondition = function(condition, value) {
+  // condition === expr
+  // NOTE: direct comparison between objects is always a bad idea
+  if (typeof condition !== 'object') {
+    return defaultCompare(value, condition) === 0;
+  }
 
-    // use user-supplied comparison function?
-    var compare = "$using" in condition ? condition.$using : defaultCompare;
+  // use user-supplied comparison function?
+  const compare = '$using' in condition ? condition.$using : defaultCompare;
 
-    // condition === { op: expr, op: expr, ... }
-    for (var op in condition) {
-        var expr = condition[op];
-        switch (op) {
-            // NOTE: using !(...) to handle "undefined" values
-            case "$using":
-                break;  // skip comparison function
-            case "$eq":
-                if (!(compare(value, expr) === 0)) return false;
-                break;
-            case "$ne":
-                var res = compare(value, expr);
-                if (!(res < 0 || res > 0)) return false;
-                break;
-            case "$lt":
-                if (!(compare(value, expr) < 0)) return false;
-                break;
-            case "$le":
-                if (!(compare(value, expr) <= 0)) return false;
-                break;
-            case "$gt":
-                if (!(compare(value, expr) > 0)) return false;
-                break;
-            case "$ge":
-                if (!(compare(value, expr) >= 0)) return false;
-                break;
-            case "$like":
-                if (!islike(expr, value)) return false;
-                break;
-            case "$unlike":
-                if (islike(expr, value) || typeof value === "undefined") return false;
-                break;
-            case "$null":
-                if (!(isnull(value) && expr || !isnull(value) && !expr)) return false;
-                break;
-            case "$empty":
-                throw new Error("invalid $empty operator on non-association");
-            case "$none":
-                throw new Error("invalid $none operator on non-association");
-            default:
-                throw new Error("invalid expression operator: " + op);
-        }
+  // condition === { op: expr, op: expr, ... }
+  for (const op in condition) {
+    const expr = condition[op];
+    switch (op) {
+      // NOTE: using !(...) to handle "undefined" values
+      case '$using':
+        break; // skip comparison function
+      case '$eq':
+        if (!(compare(value, expr) === 0)) return false;
+        break;
+      case '$ne':
+        const res = compare(value, expr);
+        if (!(res < 0 || res > 0)) return false;
+        break;
+      case '$lt':
+        if (!(compare(value, expr) < 0)) return false;
+        break;
+      case '$le':
+        if (!(compare(value, expr) <= 0)) return false;
+        break;
+      case '$gt':
+        if (!(compare(value, expr) > 0)) return false;
+        break;
+      case '$ge':
+        if (!(compare(value, expr) >= 0)) return false;
+        break;
+      case '$like':
+        if (!islike(expr, value)) return false;
+        break;
+      case '$unlike':
+        if (islike(expr, value) || typeof value === 'undefined') return false;
+        break;
+      case '$null':
+        if (!(isnull(value) && expr || !isnull(value) && !expr)) return false;
+        break;
+      case '$empty':
+        throw new Error('invalid $empty operator on non-association');
+      case '$none':
+        throw new Error('invalid $none operator on non-association');
+      default:
+        throw new Error(`invalid expression operator: ${ op}`);
     }
-    return true;
+  }
+  return true;
 };
 
 
 // compare two primitive values semantically
 function defaultCompare(lhs, rhs) {
-    return lhs < rhs ? -1 : lhs > rhs ? +1 : lhs == rhs ? 0 : undefined;
+  return lhs < rhs ? -1 : lhs > rhs ? +1 : lhs == rhs ? 0 : undefined;
 };
 
 
 // convert SQL LIKE pattern to regular expression
 function islike(pattern, value) {
-    var escaped = pattern.replace(/[-\\.^$*+?()|[\]{}]/g, '\\$&').replace(/%/g, ".*").replace(/_/g, ".");
-    return (new RegExp(escaped)).test(value);
+  const escaped = pattern
+      .replace(/[-\\.^$*+?()|[\]{}]/g, '\\$&')
+      .replace(/%/g, '.*')
+      .replace(/_/g, '.');
+  return (new RegExp(escaped)).test(value);
 }
 
 // check for NULL value; includes JavaScript null for associations
 function isnull(value) {
-    return typeof value === "undefined" || value === null;
+  return typeof value === 'undefined' || value === null;
 }
 
 // check if target instance(s) exist
 function isnone(value) {
-    return isnull(value) || utils.isArray(value) && value.length === 0;
+  return isnull(value) || utils.isArray(value) && value.length === 0;
 }