gina 0.6.2 → 0.6.3

package/framework/{v0.6.2 → v0.6.3}/core/connectors/couchbase/index.js

@@ -38,6 +38,12 @@ function Couchbase(conn, infos) {
      * - `ExpressionScan` / `KeyScan` — USE KEYS direct KV lookup (green badge,
      *   reported as "KV lookup (USE KEYS)")
      *
+     * Recursion covers the four child containers plans actually use: `~child`,
+     * `~children`, plus (#B193) the nested-scan containers `scans`
+     * (IntersectScan / UnionScan / OrderedIntersectScan) and `scan`
+     * (DistinctScan) — so a plan the planner serves with MULTIPLE indexes
+     * reports all of them instead of reading as "no index".
+     *
      * @inner
      * @param {object} profile - The plan object (meta.profile or EXPLAIN row)
      * @returns {Array<{name: string, primary: boolean}>|null} Array of index descriptors,
@@ -77,6 +83,20 @@ function Couchbase(conn, infos) {
                     walk(node['~children'][i]);
                 }
             }
+            // #B193 — the multi-index operators nest their child scans under
+            // `scans` (IntersectScan / UnionScan / OrderedIntersectScan) or
+            // `scan` (DistinctScan), NOT ~child/~children. Unwalked, every
+            // multi-index plan returned [] and the Inspector rendered it as
+            // "no index — full bucket scan" — a false negative that invites a
+            // pointless (write-amplifying) index build for a query the planner
+            // was already serving with several indexes. seen[] above already
+            // dedupes an index appearing in more than one child scan.
+            if (node['scan'])  walk(node['scan']);
+            if (node['scans'] && Array.isArray(node['scans'])) {
+                for (var j = 0; j < node['scans'].length; j++) {
+                    walk(node['scans'][j]);
+                }
+            }
         };
         walk(root);
         return results;
@@ -127,6 +147,84 @@ function Couchbase(conn, infos) {
         return cluster;
     };
 
+    /**
+     * #B243 — guards the assembled N1QL parameter list against values the
+     * Couchbase SDK cannot serialize. This defends against a PROCESS ABORT,
+     * not a normal validation failure.
+     *
+     * The SDK maps `JSON.stringify` over the parameter list. For a `function`,
+     * a `symbol`, or an `undefined`, `JSON.stringify` returns the VALUE
+     * `undefined` rather than a string; the native binding coerces that to the
+     * empty string, and the C++ core's JSON parse of `""` throws
+     * `tao::pegtl::parse_error` on an internal thread, reaching
+     * `std::terminate()` and then `abort()`. That kills the whole bundle — no
+     * `try/catch`, `uncaughtException` or `unhandledRejection` can intercept
+     * it, so the request cannot even fail with a 500. Measured against a live
+     * cluster on SDK 4.1.3 and 4.7.1 (4.2.0+ maps a bare `undefined` to null,
+     * but still aborts on functions and symbols).
+     *
+     * Reachable WITHOUT any misuse of the SDK: the cursor-style assembly branch
+     * fills `queryParams[i]` for every `i < params.length` while guarding only
+     * `undefined`, so a caller that under-supplies one argument AND passes a
+     * trailing callback puts the CALLBACK itself into a parameter slot. The
+     * arity check at the top of the query method cannot catch that shape — it
+     * only fires when the LAST argument is not a function.
+     *
+     * Scope: `typeof` covers every value `JSON.stringify` renders as
+     * `undefined` EXCEPT an object whose own `toJSON()` returns undefined,
+     * which is left unguarded deliberately — detecting it would cost a full
+     * `JSON.stringify` per parameter on every query, and no realistic call site
+     * produces it.
+     *
+     * @param {Array|object} queryParams - Assembled parameter list: a positional array, or a named map.
+     * @param {string} entityName - Entity the query belongs to (message only).
+     * @param {string} name - Query method name (message only).
+     * @param {string} source - Path of the backing `.sql` file (message only).
+     * @param {Array} [params] - Declared placeholders, used for the arity hint.
+     * @returns {TypeError|null} A ready-to-surface error, or `null` when every parameter is serializable.
+     * @private
+     *
+     * @example
+     * var err = getUnserializableParamError(['a', undefined], 'invoice', 'getByRef', src, ['$1','$2']);
+     * if (err) { return cb(err); } // never reaches the SDK, so the process survives
+     */
+    var getUnserializableParamError = function(queryParams, entityName, name, source, params) {
+        if ( !queryParams || typeof(queryParams) != 'object' ) {
+            return null;
+        }
+
+        var isPositional = Array.isArray(queryParams)
+            , keys        = isPositional ? null : Object.keys(queryParams)
+            , len         = isPositional ? queryParams.length : keys.length
+            , declared    = ( params && params.length ) ? params.length : 0
+        ;
+
+        for (var i = 0; i < len; ++i) {
+            var key  = isPositional ? i : keys[i]
+                , type = typeof(queryParams[key])
+            ;
+
+            if ( type != 'undefined' && type != 'function' && type != 'symbol' ) {
+                continue;
+            }
+
+            var label = isPositional ? ('$' + (i + 1)) : ('$' + key);
+            var hint  = ( type == 'function' )
+                ? 'A callback landed in a parameter slot: the query declares ' + declared
+                    + ' parameter(s), so every one of them must be passed BEFORE the callback.'
+                : 'Pass `null` for an intentionally empty parameter — `null` serializes correctly.';
+
+            var _err = new TypeError('[N1QL][ ' + entityName + '#' + name + '() ] parameter ' + label
+                + ' is a `' + type + '`, which the Couchbase SDK cannot serialize: dispatching it would '
+                + 'abort the process instead of raising an error. ' + hint
+                + ' Please refer to [ ' + source + ' ]');
+            _err.code = 'GINA_COUCHBASE_UNSERIALIZABLE_PARAM';
+            return _err;
+        }
+
+        return null;
+    };
+
     /**
      * Runs EXPLAIN on a N1QL statement asynchronously and caches the
      * extracted indexes. Patches `queryEntry.indexes` in-place once
@@ -772,6 +870,22 @@ function Couchbase(conn, infos) {
                     if ( query.indexOf('$scope') > -1 ) {
                         query = query.replace(/\$scope/g, "'" + (infos.scope || process.env.NODE_SCOPE) + "'");
                     }
+                    // #B243 — refuse a parameter the SDK cannot serialize BEFORE dispatch.
+                    // This is the single site where `queryOptions.parameters` is assigned,
+                    // so both assembly branches above (and any future one) are covered by
+                    // this one gate. It has to run here: once the value reaches the SDK the
+                    // failure is an uncatchable `abort()`, so there is no downstream
+                    // recovery point. Surfacing matches the missing-context precedent at
+                    // the top of this method — callback when the caller passed one, throw
+                    // otherwise — which turns a bundle-killing crash into an ordinary 500.
+                    var _unserializableErr = getUnserializableParamError(queryParams, entityName, name, source, params);
+                    if (_unserializableErr) {
+                        if (_mainCallback) {
+                            return _mainCallback(_unserializableErr);
+                        }
+                        throw _unserializableErr;
+                    }
+
                     queryOptions.parameters = queryParams;
 
                     // JUNE 2021 patch

package/framework/{v0.6.2 → v0.6.3}/core/connectors/couchbase/lib/connector.js

@@ -9,10 +9,21 @@ var console         = lib.logger;
 var version = 3; // by default
 // old - GINA_FRAMEWORK_DIR + '/package.json'
 var dependenciesPath = getPath('project') + '/package.json';// jshint ignore:line
-var dependencies = JSON.parse(fs.readFileSync(dependenciesPath)).dependencies;// jshint ignore:line
+// #B203 — `|| {}`: a project package.json without a `dependencies` key used to
+// TypeError on the `.couchbase` read below.
+var dependencies = JSON.parse(fs.readFileSync(dependenciesPath)).dependencies || {};// jshint ignore:line
 if ( dependencies.couchbase ) {
-    version = JSON.parse(fs.readFileSync(dependenciesPath)).dependencies.couchbase;// jshint ignore:line
-    version = version.replace(/\^/, '').split(/\./)[0];
+    // #B203 — the SDK major is the pin's FIRST integer: the former caret-only
+    // strip mangled range pins (`~4.5.0` became `~4`, `>=4.5` became `>=4`),
+    // which slipped past the #CN8 v2 floor (parseInt of the mangled token is
+    // NaN) and died at the existsSync gate below with a misdirecting
+    // "supported majors" error.
+    var pinnedMajor = String(dependencies.couchbase).match(/\d+/);
+    if ( !pinnedMajor ) {
+        throw new Error('[ CONNECTOR ][ couchbase ] could not derive the SDK major from the project package.json couchbase dependency pin: "'
+            + dependencies.couchbase + '". Use a numeric range or exact version (e.g. ^4.6.1) — supported couchbase SDK majors are 3 and 4.');
+    }
+    version = pinnedMajor[0];
 }
 // #CN8 — fail fast on SDK v2 (or older). The migration is a driver bump, not a config edit:
 // upgrade the `couchbase` dependency in your project package.json to ^3 or ^4.

package/framework/{v0.6.2 → v0.6.3}/core/connectors/couchbase/lib/session-store.js

@@ -8,10 +8,21 @@ var console         = lib.logger;
 // Default to v3 when the project does not pin a couchbase version.
 var version = 3; // by default
 var dependenciesPath = getPath('project') + '/package.json';// jshint ignore:line
-var dependencies = JSON.parse(fs.readFileSync(dependenciesPath)).dependencies;// jshint ignore:line
+// #B203 — `|| {}`: a project package.json without a `dependencies` key used to
+// TypeError on the `.couchbase` read below.
+var dependencies = JSON.parse(fs.readFileSync(dependenciesPath)).dependencies || {};// jshint ignore:line
 if ( dependencies.couchbase ) {
-    version = JSON.parse(fs.readFileSync(dependenciesPath)).dependencies.couchbase;// jshint ignore:line
-    version = version.replace(/\^/, '').split(/\./)[0];
+    // #B203 — the SDK major is the pin's FIRST integer: the former caret-only
+    // strip mangled range pins (`~4.5.0` became `~4`, `>=4.5` became `>=4`),
+    // which slipped past the #CN8 v2 floor (parseInt of the mangled token is
+    // NaN) and died at the existsSync gate below with a misdirecting
+    // "supported majors" error.
+    var pinnedMajor = String(dependencies.couchbase).match(/\d+/);
+    if ( !pinnedMajor ) {
+        throw new Error('[ CONNECTOR ][ couchbase ] session-store could not derive the SDK major from the project package.json couchbase dependency pin: "'
+            + dependencies.couchbase + '". Use a numeric range or exact version (e.g. ^4.6.1) — supported couchbase SDK majors are 3 and 4.');
+    }
+    version = pinnedMajor[0];
 }
 // #CN8 — fail fast on SDK v2 (or older). The migration is a driver bump, not a config edit:
 // upgrade the `couchbase` dependency in your project package.json to ^3 or ^4.

package/framework/{v0.6.2 → v0.6.3}/core/connectors/couchbase/lib/session-store.v3.js

@@ -71,7 +71,7 @@ module.exports = function(session, bundle){
      * @constructor
      * @param {object}  options
      * @param {object}  options.db                        - Open Couchbase bucket (required).
-     * @param {number}  [options.ttl=null]                - Expiry in seconds. Unset, the cookie's maxAge applies, then one day.
+     * @param {number}  [options.ttl=null]                - Expiry in seconds. Unset, the cookie's maxAge applies, then one day. Must be > 0 when set — non-positive refuses (#B207).
      * @param {string}  [options.prefix='sess:']          - Document key prefix.
      * @param {number}  [options.connectionTimeout=10000] - Connect-time timeout in ms.
      * @param {number}  [options.operationTimeout=10000]  - Per-operation timeout in ms.
@@ -99,6 +99,15 @@ module.exports = function(session, bundle){
         this.client.connectionTimeout = options.connectionTimeout || 10000;
         this.client.operationTimeout = options.operationTimeout || 10000;
 
+        // #B207 — parity with the redis/sqlite/mongodb/scylladb stores: a
+        // non-positive ttl is refused at construction. couchbase collapsed 0
+        // at the constructor and still upserted a ZERO expiry — a document
+        // that never expires — when the cookie's decaying maxAge resolved to
+        // <= 0 at set()/touch().
+        if (options.ttl != null && !(options.ttl > 0)) {
+            throw new Error('['+ bundle +'][SessionStore v3] `ttl` must be a positive number of seconds or unset — got '
+                + JSON.stringify(options.ttl) + ' (store options). `ttl: 0` is not supported (it previously behaved as unset).');
+        }
         this.ttl = options.ttl || null;
     }
 
@@ -190,6 +199,15 @@ module.exports = function(session, bundle){
                     : oneDay)
                 ;
 
+            // #B207 — a resolved ttl <= 0 (decaying cookie.maxAge at/past
+            // expiry) must never reach the SDK: a zero expiry stores the
+            // document WITHOUT expiration, and a negative one is SDK-version-
+            // dependent. No-op — the existing record keeps its original
+            // expiry (mirrors the #B166 guard the sibling stores carry).
+            if (ttl <= 0) {
+                return fn(null);
+            }
+
             if (ttl > 0) {
                 sess.lastModified = new Date().toISOString();
             }
@@ -241,7 +259,9 @@ module.exports = function(session, bundle){
      * Also re-stamps `sess.lastModified` (ISO 8601, UTC) whenever `ttl > 0`.
      * The stamp is unconditional by design: the `upsert` extends the document's
      * expiry on every call, and the client-side session countdown derives its
-     * origin from that stamp, so it must track every extension (#B165).
+     * origin from that stamp, so it must track every extension (#B165). A
+     * resolved ttl <= 0 is a no-op — never extend with a non-positive
+     * expiry (#B207).
      *
      * @param {String} sid
      * @param {Session} sess
@@ -259,6 +279,13 @@ module.exports = function(session, bundle){
                 : oneDay)
             ;
 
+        // #B207 — same guard as set(): never extend with a non-positive
+        // expiry (zero = the document never expires; negative is SDK-version-
+        // dependent). The #B166 sibling-store guards are identical.
+        if (ttl <= 0) {
+            return fn(null);
+        }
+
         // #B165 — an idle-check used to gate this stamp. It compared an elapsed
         // value in MILLISECONDS against `ttl` in SECONDS, so it fired ~1000x too
         // eagerly (86.4s idle on the 86400s default). Correcting only the units

package/framework/{v0.6.2 → v0.6.3}/core/connectors/couchbase/lib/session-store.v4.js

@@ -74,7 +74,7 @@ module.exports = function(session, bundle){
      * @constructor
      * @param {object}  options
      * @param {object}  options.db                        - Open Couchbase bucket (required).
-     * @param {number}  [options.ttl=null]                - Expiry in seconds. Unset, the cookie's maxAge applies, then one day.
+     * @param {number}  [options.ttl=null]                - Expiry in seconds. Unset, the cookie's maxAge applies, then one day. Must be > 0 when set — non-positive refuses (#B207).
      * @param {string}  [options.prefix='sess:']          - Document key prefix.
      * @param {number}  [options.connectionTimeout=10000] - Connect-time timeout in ms.
      * @param {number}  [options.operationTimeout=10000]  - Per-operation timeout in ms.
@@ -102,6 +102,15 @@ module.exports = function(session, bundle){
         this.client.connectionTimeout = options.connectionTimeout || 10000;
         this.client.operationTimeout = options.operationTimeout || 10000;
 
+        // #B207 — parity with the redis/sqlite/mongodb/scylladb stores: a
+        // non-positive ttl is refused at construction. couchbase collapsed 0
+        // at the constructor and still upserted a ZERO expiry — a document
+        // that never expires — when the cookie's decaying maxAge resolved to
+        // <= 0 at set()/touch().
+        if (options.ttl != null && !(options.ttl > 0)) {
+            throw new Error('['+ bundle +'][SessionStore v4] `ttl` must be a positive number of seconds or unset — got '
+                + JSON.stringify(options.ttl) + ' (store options). `ttl: 0` is not supported (it previously behaved as unset).');
+        }
         this.ttl = options.ttl || null;
     }
 
@@ -242,6 +251,15 @@ module.exports = function(session, bundle){
                     : oneDay)
                 ;
 
+            // #B207 — a resolved ttl <= 0 (decaying cookie.maxAge at/past
+            // expiry) must never reach the SDK: a zero expiry stores the
+            // document WITHOUT expiration, and a negative one is SDK-version-
+            // dependent. No-op — the existing record keeps its original
+            // expiry (mirrors the #B166 guard the sibling stores carry).
+            if (ttl <= 0) {
+                return fn(null);
+            }
+
             if (ttl > 0) {
                 // #B165 — was `.format('isoDateTime')`, a zone-less local-time
                 // string ("yyyy-mm-dd'T'HH:MM:ss", helpers/dateFormat.js). The
@@ -316,7 +334,9 @@ module.exports = function(session, bundle){
      * Also re-stamps `sess.lastModified` (ISO 8601, UTC) whenever `ttl > 0`.
      * The stamp is unconditional by design: the `upsert` extends the document's
      * expiry on every call, and the client-side session countdown derives its
-     * origin from that stamp, so it must track every extension (#B165).
+     * origin from that stamp, so it must track every extension (#B165). A
+     * resolved ttl <= 0 is a no-op — never extend with a non-positive
+     * expiry (#B207).
      *
      * @param {String} sid
      * @param {Session} sess
@@ -334,6 +354,13 @@ module.exports = function(session, bundle){
                 : oneDay)
             ;
 
+        // #B207 — same guard as set(): never extend with a non-positive
+        // expiry (zero = the document never expires; negative is SDK-version-
+        // dependent). The #B166 sibling-store guards are identical.
+        if (ttl <= 0) {
+            return fn(null);
+        }
+
         // #B165 — an idle-check used to gate this stamp. It compared an elapsed
         // value in MILLISECONDS against `ttl` in SECONDS, so it fired ~1000x too
         // eagerly (86.4s idle on the 86400s default). Correcting only the units

package/framework/{v0.6.2 → v0.6.3}/core/connectors/mongodb/lib/session-store.js

@@ -46,8 +46,9 @@ var noop = function() {};
  * intent (return active sessions only) is the same.
  *
  * @param {object} session - The `express-session` module (must have `.Store` on it).
- *                           The caller sets `session.name` to the connectors.json key
- *                           before calling `new SessionStore(session)`.
+ *                           `session.name` is express-session's read-only function name —
+ *                           the literal `'session'` — so the bundle's connectors.json must
+ *                           declare its store entry under the key `"session"` (#B206).
  * @param {string} bundle  - Bundle name — used to look up `getConfig()[bundle][env]`.
  * @returns {function}     - MongodbStore constructor.
  */
@@ -138,6 +139,7 @@ module.exports = function(session, bundle) {
      * @param {string} [options.collection] - Sessions collection (default 'sessions').
      * @param {number} [options.ttl]        - Default TTL seconds (default: connectors.json ttl;
      *                                        unset → cookie maxAge drives expiry, else 86400).
+     *                                        Must be > 0 when set — non-positive refuses (#B207).
      * @throws {Error} when `database` is missing.
      */
     function MongodbStore(options) {
@@ -145,6 +147,19 @@ module.exports = function(session, bundle) {
         Store.call(this, options);
 
         this.collection = (options.collection != null) ? options.collection : (connConf.collection || 'sessions');
+        // #B207 — a non-positive ttl is refused at construction: `ttl: 0` used
+        // to collapse to the maxAge fallback through double truthiness (options
+        // preserve + `this.ttl ||` at every use site), silently meaning "unset",
+        // while a RESOLVED ttl <= 0 reached backend-specific semantics. A ttl
+        // is a positive number of seconds, or unset.
+        if (options.ttl != null && !(options.ttl > 0)) {
+            throw new Error('[' + bundle + '][MongodbStore] `ttl` must be a positive number of seconds or unset — got '
+                + JSON.stringify(options.ttl) + ' (store options). `ttl: 0` is not supported (it previously behaved as unset).');
+        }
+        if (connConf.ttl != null && !(connConf.ttl > 0)) {
+            throw new Error('[' + bundle + '][MongodbStore] `ttl` must be a positive number of seconds or unset — got '
+                + JSON.stringify(connConf.ttl) + ' (connectors.json session entry). `ttl: 0` is not supported (it previously behaved as unset).');
+        }
         // #B163 — was `connConf.ttl || oneDay`: the implicit one-day default made the
         // cookie-maxAge fallback in set()/touch() unreachable; unset now stays null (couchbase parity).
         this.ttl        = (options.ttl        != null) ? options.ttl        : (connConf.ttl        || null);
@@ -269,6 +284,13 @@ module.exports = function(session, bundle) {
         var maxAge = sess.cookie && sess.cookie.maxAge;
         var ttl    = this.ttl || ('number' === typeof maxAge ? maxAge / 1000 | 0 : oneDay);
 
+        // #B207 — a resolved ttl <= 0 means the session is already at/past its
+        // expiry: writing an immediately-expired document is pointless. No-op
+        // for parity with the sibling stores (mirrors the #B166 touch() guard).
+        if (ttl <= 0) {
+            return fn(null);
+        }
+
         if (ttl > 0) {
             sess.lastModified = new Date().toISOString();
         }

package/framework/{v0.6.2 → v0.6.3}/core/connectors/redis/lib/session-store.js

@@ -37,8 +37,10 @@ var noop = function() {};
  * Supports standalone Redis, Redis Cluster, and TLS (ElastiCache, Cloud Memorystore, Upstash).
  *
  * @param {object} session       - The `express-session` module (must have `.Store` on it).
- *                                 The caller sets `session.name` to the connectors.json key
- *                                 before calling `new SessionStore(session)`.
+ *                                 `session.name` is express-session's read-only function
+ *                                 name — the literal `'session'` — so the bundle's
+ *                                 connectors.json must declare its store entry under the
+ *                                 key `"session"` (#B206).
  * @param {string} bundle        - Bundle name — used to look up `getConfig()[bundle][env]`.
  * @returns {function}           - RedisStore constructor.
  */
@@ -54,7 +56,7 @@ module.exports = function(session, bundle) {
     // `getConfig()` and `getContext()` are framework globals injected by gna.js.
     var env      = getContext().env;
     var conf     = getConfig()[bundle][env];
-    var connName = session.name; // the key in connectors.json (e.g. "myRedis")
+    var connName = session.name; // express-session's read-only function name — always the literal 'session' (#B206)
     var connConf = (conf && conf.content && conf.content.connectors && conf.content.connectors[connName]) || {};
 
     /**
@@ -73,6 +75,8 @@ module.exports = function(session, bundle) {
      * @param {string}  [options.prefix]    - Session key prefix (default: connectors.json → 'sess:').
      * @param {number}  [options.ttl]       - Session TTL in seconds (default: connectors.json ttl;
      *                                        unset → cookie maxAge drives expiry, else 86400).
+     *                                        Must be > 0 when set — non-positive refuses (#B207).
+     * @throws {Error} When `ttl` is configured non-positive on either channel (#B207).
      */
     function RedisStore(options) {
         var self = this;
@@ -80,6 +84,20 @@ module.exports = function(session, bundle) {
         Store.call(this, options);
 
         this.prefix = (options.prefix != null) ? options.prefix : (connConf.prefix || 'sess:');
+
+        // #B207 — a non-positive ttl is refused at construction: `ttl: 0` used
+        // to collapse to the maxAge fallback through double truthiness (options
+        // preserve + `this.ttl ||` at every use site), silently meaning "unset",
+        // while a RESOLVED ttl <= 0 reached backend-specific semantics. A ttl
+        // is a positive number of seconds, or unset.
+        if (options.ttl != null && !(options.ttl > 0)) {
+            throw new Error('[' + bundle + '][RedisStore] `ttl` must be a positive number of seconds or unset — got '
+                + JSON.stringify(options.ttl) + ' (store options). `ttl: 0` is not supported (it previously behaved as unset).');
+        }
+        if (connConf.ttl != null && !(connConf.ttl > 0)) {
+            throw new Error('[' + bundle + '][RedisStore] `ttl` must be a positive number of seconds or unset — got '
+                + JSON.stringify(connConf.ttl) + ' (connectors.json session entry). `ttl: 0` is not supported (it previously behaved as unset).');
+        }
         // #B163 — was `connConf.ttl || oneDay`: the implicit one-day default made the
         // cookie-maxAge fallback in set()/touch() unreachable; unset now stays null (couchbase parity).
         this.ttl    = (options.ttl    != null) ? options.ttl    : (connConf.ttl    || null);
@@ -166,7 +184,8 @@ module.exports = function(session, bundle) {
 
     /**
      * Commit the given `sess` object associated with `sid`.
-     * Uses SETEX when TTL > 0, SET otherwise.
+     * Always SETEX — a resolved ttl <= 0 is a no-op, never an expiry-less
+     * SET (#B207).
      *
      * @param {string}   sid  - Session ID.
      * @param {object}   sess - Session data.
@@ -178,6 +197,15 @@ module.exports = function(session, bundle) {
         var maxAge = sess.cookie && sess.cookie.maxAge;
         var ttl    = this.ttl || ('number' === typeof maxAge ? maxAge / 1000 | 0 : oneDay);
 
+        // #B207 — a resolved ttl <= 0 means the session is already at/past its
+        // expiry (cookie.maxAge is a decaying remainder): the former plain-SET
+        // fallback wrote the key with NO expiry, making it immortal. No-op
+        // instead — the existing record dies on its original schedule. Mirrors
+        // the #B166 touch() guard.
+        if (ttl <= 0) {
+            return fn(null);
+        }
+
         if (ttl > 0) {
             sess.lastModified = new Date().toISOString();
         }
@@ -191,11 +219,7 @@ module.exports = function(session, bundle) {
 
         console.debug('[RedisStore] SETEX "' + key + '" ttl:' + ttl);
 
-        if (ttl > 0) {
-            this.client.setex(key, ~~ttl, data, fn);
-        } else {
-            this.client.set(key, data, fn);
-        }
+        this.client.setex(key, ~~ttl, data, fn);
     };
 
     /**

package/framework/{v0.6.2 → v0.6.3}/core/connectors/scylladb/lib/session-store.js

@@ -48,8 +48,9 @@ var noop = function() {};
  * waiting for TTL to expire.
  *
  * @param {object} session - The `express-session` module (must have `.Store` on it).
- *                           The caller sets `session.name` to the connectors.json key
- *                           before calling `new SessionStore(session)`.
+ *                           `session.name` is express-session's read-only function name —
+ *                           the literal `'session'` — so the bundle's connectors.json must
+ *                           declare its store entry under the key `"session"` (#B206).
  * @param {string} bundle  - Bundle name — used to look up `getConfig()[bundle][env]`.
  * @returns {function}     - ScylladbStore constructor.
  */
@@ -134,12 +135,26 @@ module.exports = function(session, bundle) {
      * @param {string}   [options.table]           - Sessions table name (default: connectors.json → 'sessions').
      * @param {number}   [options.ttl]             - Default TTL seconds (default: connectors.json ttl;
      *                                              unset → cookie maxAge drives expiry, else 86400).
+     *                                              Must be > 0 when set — non-positive refuses (#B207).
      */
     function ScylladbStore(options) {
         options = options || {};
         Store.call(this, options);
 
         this.table = (options.table != null) ? options.table : (connConf.table || 'sessions');
+        // #B207 — a non-positive ttl is refused at construction: `ttl: 0` used
+        // to collapse to the maxAge fallback through double truthiness (options
+        // preserve + `this.ttl ||` at every use site), silently meaning "unset",
+        // while a RESOLVED ttl <= 0 reached backend-specific semantics. A ttl
+        // is a positive number of seconds, or unset.
+        if (options.ttl != null && !(options.ttl > 0)) {
+            throw new Error('[' + bundle + '][ScylladbStore] `ttl` must be a positive number of seconds or unset — got '
+                + JSON.stringify(options.ttl) + ' (store options). `ttl: 0` is not supported (it previously behaved as unset).');
+        }
+        if (connConf.ttl != null && !(connConf.ttl > 0)) {
+            throw new Error('[' + bundle + '][ScylladbStore] `ttl` must be a positive number of seconds or unset — got '
+                + JSON.stringify(connConf.ttl) + ' (connectors.json session entry). `ttl: 0` is not supported (it previously behaved as unset).');
+        }
         // #B163 — was `connConf.ttl || oneDay`: the implicit one-day default made the
         // cookie-maxAge fallback in set()/touch() unreachable; unset now stays null (couchbase parity).
         this.ttl   = (options.ttl   != null) ? options.ttl   : (connConf.ttl   || null);
@@ -219,6 +234,14 @@ module.exports = function(session, bundle) {
         var maxAge = sess.cookie && sess.cookie.maxAge;
         var ttl    = this.ttl || ('number' === typeof maxAge ? maxAge / 1000 | 0 : oneDay);
 
+        // #B207 — a resolved ttl <= 0 must never reach CQL: `USING TTL 0`
+        // stores the row WITHOUT expiry (immortal), and a negative TTL is a
+        // server error. No-op — the existing record dies on its original
+        // schedule (mirrors the #B166 touch() guard).
+        if (ttl <= 0) {
+            return fn(null);
+        }
+
         if (ttl > 0) {
             sess.lastModified = new Date().toISOString();
         }

package/framework/{v0.6.2 → v0.6.3}/core/connectors/sqlite/lib/session-store.js

@@ -42,8 +42,10 @@ var noop = function() {};
  * For multi-pod horizontal scaling use the Redis connector instead.
  *
  * @param {object} session       - The `express-session` module (must have `.Store` on it).
- *                                 The caller sets `session.name` to the connectors.json key
- *                                 before calling `new SessionStore(session)`.
+ *                                 `session.name` is express-session's read-only function
+ *                                 name — the literal `'session'` — so the bundle's
+ *                                 connectors.json must declare its store entry under the
+ *                                 key `"session"` (#B206).
  * @param {string} bundle        - Bundle name — used to look up `getConfig()[bundle][env]`.
  * @returns {function}           - SqliteStore constructor.
  */
@@ -73,6 +75,7 @@ module.exports = function(session, bundle) {
      * @param {string}  [options.prefix]             - Session key prefix (default: `'sess:'`).
      * @param {number}  [options.ttl]                - Session TTL in seconds (default: connectors.json ttl;
      *                                                 unset → cookie maxAge drives expiry, else 86400).
+     *                                                 Must be > 0 when set — non-positive refuses (#B207).
      * @param {number}  [options.cleanupInterval]    - Expired-session purge interval in seconds.
      *                                                 Set to 0 to disable. (default: 900).
      */
@@ -82,6 +85,19 @@ module.exports = function(session, bundle) {
         Store.call(this, options);
 
         this.prefix          = (options.prefix          != null) ? options.prefix          : (connConf.prefix          || 'sess:');
+        // #B207 — a non-positive ttl is refused at construction: `ttl: 0` used
+        // to collapse to the maxAge fallback through double truthiness (options
+        // preserve + `this.ttl ||` at every use site), silently meaning "unset",
+        // while a RESOLVED ttl <= 0 reached backend-specific semantics. A ttl
+        // is a positive number of seconds, or unset.
+        if (options.ttl != null && !(options.ttl > 0)) {
+            throw new Error('[' + bundle + '][SqliteStore] `ttl` must be a positive number of seconds or unset — got '
+                + JSON.stringify(options.ttl) + ' (store options). `ttl: 0` is not supported (it previously behaved as unset).');
+        }
+        if (connConf.ttl != null && !(connConf.ttl > 0)) {
+            throw new Error('[' + bundle + '][SqliteStore] `ttl` must be a positive number of seconds or unset — got '
+                + JSON.stringify(connConf.ttl) + ' (connectors.json session entry). `ttl: 0` is not supported (it previously behaved as unset).');
+        }
         // #B163 — was `connConf.ttl || oneDay`: the implicit one-day default made the
         // cookie-maxAge fallback in set()/touch() unreachable; unset now stays null (couchbase parity).
         this.ttl             = (options.ttl             != null) ? options.ttl             : (connConf.ttl             || null);
@@ -201,6 +217,14 @@ module.exports = function(session, bundle) {
         var key    = this.prefix + sid;
         var maxAge = sess.cookie && sess.cookie.maxAge;
         var ttl    = this.ttl || ('number' === typeof maxAge ? maxAge / 1000 | 0 : oneDay);
+
+        // #B207 — a resolved ttl <= 0 means the session is already at/past its
+        // expiry: writing an immediately-dead row is pointless. No-op for
+        // parity with the sibling stores (mirrors the #B166 touch() guard).
+        if (ttl <= 0) {
+            return fn(null);
+        }
+
         var expires = Math.floor(Date.now() / 1000) + ~~ttl;
 
         if (ttl > 0) {