soajs.controller 4.3.18 → 4.3.20

package/.github/workflows/ci.yml

@@ -17,7 +17,10 @@ jobs:
 
     services:
       mongodb:
-        image: mongo:8
+        # TODO: back to mongo:8 once it starts on the GitHub runners again. Since 2026-10-19 mongod 8
+        #       exits on start with "Linux kernel versions 6.19 and newer has a known incompatibility
+        #       with this version of MongoDB" (https://jira.mongodb.org/browse/SERVER-121912).
+        image: mongo:7.0
         ports:
           - 27017:27017
 

package/.github/workflows/release.yml

@@ -17,7 +17,10 @@ jobs:
 
     services:
       mongodb:
-        image: mongo:8
+        # TODO: back to mongo:8 once it starts on the GitHub runners again. Since 2026-10-19 mongod 8
+        #       exits on start with "Linux kernel versions 6.19 and newer has a known incompatibility
+        #       with this version of MongoDB" (https://jira.mongodb.org/browse/SERVER-121912).
+        image: mongo:7.0
         ports:
           - 27017:27017
 

package/docs/maintenance-routes.md

@@ -18,6 +18,7 @@ The maintenance server runs on a separate port from the main gateway to allow in
 | `/loadProvision` | GET | Reload provision/tenant data |
 | `/reloadRegistry` | GET | Reload environment registry |
 | `/awarenessStat` | GET | Get service awareness statistics |
+| `/cache/invalidate` | POST | Remove cached GET responses a service knows are out of date |
 
 ---
 
@@ -226,6 +227,36 @@ curl http://localhost:5000/awarenessStat
 
 ---
 
+## 5. Cache Invalidation (`/cache/invalidate`)
+
+**Endpoint:** `POST /cache/invalidate`
+
+**Purpose:** Lets a service remove cached GET responses as soon as it knows they changed, instead of
+waiting for their TTL. Needs the mongo cache model.
+
+### Request
+
+```bash
+curl -X POST http://localhost:5000/cache/invalidate \
+  -H "Content-Type: application/json" \
+  -d '{"tenant": "5c0e74ba9acc3c5a84a51259", "service": "spaces", "api": "GET /spaces", "user": "5c8d0c505653de3985aa2001"}'
+```
+
+### Response
+
+```json
+{
+  "result": true,
+  "ts": 1792430000000,
+  "service": { "service": "soajs.controller", "version": "4.3.20", "type": "rest", "route": "/cache/invalidate" },
+  "data": { "removed": 3 }
+}
+```
+
+What each field matches, and the error cases, are in [Cache, Invalidation](middleware/cache.md#invalidation).
+
+---
+
 ## Security Considerations
 
 ### Network Access

package/docs/middleware/cache.md

@@ -157,7 +157,7 @@ APIs are matched using `GET /path` format with support for path parameters:
 - **tenant_id**: Isolates cache per tenant
 - **serviceName**: The target service name
 - **path**: The API path
-- **queryHash**: MD5 hash of sorted query parameters
+- **queryHash**: MD5 hash of sorted query parameters, without `access_token`
 - **user_id**: The logged-in user id (only for `tenant_user` scope), isolating cache per user within the tenant
 
 ### Query Parameter Handling
@@ -168,8 +168,14 @@ Query parameters are included in the cache key via MD5 hash:
 GET /users?page=1&limit=10  → key includes hash of {"limit":"10","page":"1"}
 GET /users?limit=10&page=1  → same hash (sorted)
 GET /users                  → different key (no query hash)
+GET /users?access_token=abc → same key as GET /users
 ```
 
+`access_token` is left out: it identifies the caller, not what is asked for. With it in the key, every
+token got its own entry, so a `tenant` scoped API was never shared between users, and a user's entries
+stopped matching after each login or token refresh. The user of a `tenant_user` entry is already in the
+key.
+
 ## Storage Backends
 
 ### Memory (Default)
@@ -229,6 +235,73 @@ Content-Type: application/json
 - Error responses (4xx, 5xx)
 - APIs not configured for caching
 
+## Invalidation
+
+A cached response normally lives until its TTL. A service that knows something changed can remove the
+affected entries right away by calling the gateway's maintenance port:
+
+```
+POST /cache/invalidate
+Content-Type: application/json
+
+{
+  "tenant": "5c0e74ba9acc3c5a84a51259",   // required, the tenant the GET was cached under
+  "service": "spaces",                    // required
+  "api": "GET /spaces",                   // optional, as written in the cache configuration
+  "user": "5c8d0c505653de3985aa2001"      // optional, the user id of a tenant_user entry
+}
+```
+
+```json
+{ "result": true, "data": { "removed": 3 } }
+```
+
+| Given | Removed |
+|-------|---------|
+| `tenant`, `service`, `api`, `user` | That user's entries of that api |
+| `tenant`, `service`, `api` | That api's entries for every user, and its tenant scoped entry |
+| `tenant`, `service`, `user` | That user's entries of every api of the service |
+| `tenant`, `service` | Every entry of the service in the tenant |
+
+Every cached variant of a matching entry is removed: every query string, and every value of a path
+parameter. `"api": "GET /space/:id"` removes `/space/1`, `/space/2` and so on. A `user` only matches
+`tenant_user` entries, a `tenant` scoped entry has no user.
+
+**Only the mongo model is supported.** It is the one shared by every gateway, so one call clears the
+entry everywhere. With the memory model the route answers `400`.
+
+**Example.** A service caches `GET /spaces`, the spaces a user is invited to, per user. When user A
+invites user B, the invite API removes B's list before it answers, so B's next call loads the new one:
+
+```javascript
+// at the end of the invite API, before replying
+await post("http://" + gatewayHost + ":" + maintenancePort + "/cache/invalidate", {
+	"tenant": req.soajs.tenant.id,
+	"service": "spaces",
+	"api": "GET /spaces",
+	"user": invitedUserId
+});
+```
+
+Wait for it with a short timeout. If the gateway cannot be reached, the change still stands and the
+entry expires on its TTL.
+
+**Requests already in flight.** A GET that started before the invalidation may have read the data
+before the change. Its response is still sent to the client but not stored, so it cannot put the old
+list back after the removal. Each invalidation is remembered for 15 minutes in the `cache_invalidation`
+collection for this check. It compares the time the gateway handling the GET received it with the time
+the invalidation ran, keep the gateways' clocks in sync.
+
+Entries cached before this version carry no service, api or user, an invalidation does not match them,
+they expire on their TTL.
+
+| Status | Reason |
+|--------|--------|
+| `200` | Removed, `data.removed` is the number of entries |
+| `400` | Missing `tenant` or `service`, an `api` not written as `GET /path`, a `user` that is not a string, caching not configured, or not the mongo model |
+| `405` | Not a `POST` |
+| `500` | The cache store failed or is not ready |
+
 ## Usage Notes
 
 - Only GET requests are cached

package/docs/middleware/idempotency.md

@@ -48,7 +48,8 @@ The Idempotency middleware prevents duplicate write operations by tracking reque
            │
            ├─── Found (in_flight) ──▶ 409 Conflict (code: 181)
            │
-           └─── Not found ──▶ Lock key → Execute → Store response
+           └─── Not found ──▶ Lock key → Execute → Store response (status < 500)
+                                                 or release the key
 ```
 
 ## Configuration
@@ -140,12 +141,39 @@ Content-Type: application/json
 {"caller": "user1", "callee": "user2"}
 ```
 
+## How a Locked Key Ends
+
+The key is locked before the request goes on to throttling, caching and the proxy. How the
+request ends decides what happens to it:
+
+| The request ends with | The key | A retry with the same key |
+|---|---|---|
+| An answer of the service below 500 (2xx, 3xx, 4xx) | Completed, the answer is stored for the TTL | Gets the stored answer, the service is not called |
+| An answer of the service of 500 or more | Released | Reaches the service again |
+| A proxy error (service down, connection closed) | Released | Reaches the service again |
+| An answer of the gateway before the service: throttling (429), an error, a refusal | Released | Runs again |
+| The client disconnecting before the request reaches the service | Released | Runs again |
+| The client disconnecting while the service is answering | Follows the service answer above | |
+
+Only an answer the service actually produced is replayed. A 4xx is the service's answer to that
+request and replaying it is correct. A 5xx, a throttling refusal or any other answer of the gateway
+says nothing about the operation, so the key is released and the client's retry runs instead of
+getting the same refusal for the whole TTL.
+
+While the request is running, a duplicate with the same key gets 409, code 181.
+
+A service that can fail with a 5xx after part of the work is done must protect that work itself,
+the retry reaches it again.
+
+The release only removes a key still in flight and locked by that request: never a completed
+one, and never a lock taken by a retry after the TTL of the first ran out.
+
 ## Response Scenarios
 
 ### New Request (First Time)
 
 ```
-Request processed normally, response cached
+Request processed normally, a service answer below 500 is stored
 ```
 
 ### Replay (Completed)
@@ -235,6 +263,7 @@ Keys are isolated per tenant to prevent cross-tenant collisions.
 - Only applies to non-GET requests (POST, PUT, DELETE, PATCH)
 - GET requests always pass through (idempotent by nature)
 - Keys expire after TTL (default 60 seconds)
+- A key is never left in flight by a request that does not reach the service, see [How a Locked Key Ends](#how-a-locked-key-ends)
 - Clients should generate a new UUID for each unique operation
 - Same UUID = same operation (for retries)
 - MongoDB backend required for horizontal scaling

package/mw/cache/index.js

@@ -16,17 +16,28 @@ const { logOnce } = require('../../lib/logOnce.js');
 
 let model = { memory, mongo };
 
+//NOTE: the access token is how the caller is identified, not what is asked for. Kept in, every token
+//		gets its own entry and a tenant scoped api is never shared, the user is already in the key of a
+//		tenant_user entry.
+const QUERY_PARAMS_NOT_IN_KEY = ['access_token'];
+
 function hashQuery(query) {
-	if (!query || Object.keys(query).length === 0) {
+	if (!query) {
+		return '';
+	}
+	const params = Object.keys(query).filter((key) => !QUERY_PARAMS_NOT_IN_KEY.includes(key));
+	if (params.length === 0) {
 		return '';
 	}
-	const sortedQuery = Object.keys(query).sort().reduce((obj, key) => {
+	const sortedQuery = params.sort().reduce((obj, key) => {
 		obj[key] = query[key];
 		return obj;
 	}, {});
 	return crypto.createHash('md5').update(JSON.stringify(sortedQuery)).digest('hex');
 }
 
+//NOTE: returns the entry name as written in the configuration with its config, an invalidation names
+//		the api the same way
 function matchesApi(method, path, apis) {
 	if (!apis || typeof apis !== 'object') {
 		return null;
@@ -34,7 +45,7 @@ function matchesApi(method, path, apis) {
 	const requestSignature = `${method} ${path}`;
 
 	if (apis[requestSignature]) {
-		return apis[requestSignature];
+		return { 'name': requestSignature, 'config': apis[requestSignature] };
 	}
 
 	for (const api in apis) {
@@ -59,7 +70,7 @@ function matchesApi(method, path, apis) {
 				}
 			}
 			if (matches) {
-				return apis[api];
+				return { 'name': api, 'config': apis[api] };
 			}
 		}
 	}
@@ -96,7 +107,8 @@ module.exports = function (configuration) {
 			return next();
 		}
 
-		const apiConfig = matchesApi(method, apiPath, serviceConfig.apis);
+		const matchedApi = matchesApi(method, apiPath, serviceConfig.apis);
+		const apiConfig = matchedApi ? matchedApi.config : null;
 		if (!apiConfig || !apiConfig.enabled) {
 			return next();
 		}
@@ -141,6 +153,7 @@ module.exports = function (configuration) {
 			'l2': `${serviceName}:GET:${apiPath}:${queryHash}${userPart}`
 		};
 
+		const startedAt = Date.now();
 		const processCache = async () => {
 			try {
 				const cached = await model[modelType].get(key);
@@ -157,6 +170,12 @@ module.exports = function (configuration) {
 				req.soajs.cacheContext = {
 					key: key,
 					ttl: ttl,
+					meta: {
+						service: serviceName,
+						api: matchedApi.name,
+						user: (scope === 'tenant_user') ? String(userId) : null,
+						startedAt: startedAt
+					},
 					modelType: modelType,
 					model: model[modelType],
 					log: configuration.log

package/mw/cache/invalidate.js

@@ -0,0 +1,71 @@
+'use strict';
+
+/**
+ * @license
+ * Copyright SOAJS All Rights Reserved.
+ *
+ * Use of this source code is governed by an Apache license that can be
+ * found in the LICENSE file at the root of this repository
+ */
+
+const get = (p, o) => p.reduce((xs, x) => (xs && xs[x]) ? xs[x] : null, o);
+const mongo = require('./model/mongo.js');
+
+const API_REGEX = /^GET \/\S*$/;
+
+function isNonEmptyString(value) {
+	return typeof value === 'string' && value.length > 0;
+}
+
+/**
+ * Remove cached GET responses a service knows are out of date, called on the maintenance port.
+ *
+ * NOTE: only the mongo model is supported, it is the one shared by every gateway, the memory model
+ *       is per gateway and meant for testing
+ *
+ * @param registry the gateway registry
+ * @param input {tenant, service, api, user} tenant and service are required
+ * @returns {Promise<{status: number, removed: number}|{status: number, error: string}>}
+ */
+async function invalidate(registry, input) {
+	if (!input || typeof input !== 'object') {
+		return { 'status': 400, 'error': 'A JSON body with tenant and service is required.' };
+	}
+	if (!isNonEmptyString(input.tenant) || !isNonEmptyString(input.service)) {
+		return { 'status': 400, 'error': 'tenant and service are required.' };
+	}
+	if (input.api !== undefined && (!isNonEmptyString(input.api) || !API_REGEX.test(input.api))) {
+		return { 'status': 400, 'error': 'api must be written as in the cache configuration, for example "GET /spaces".' };
+	}
+	if (input.user !== undefined && !isNonEmptyString(input.user)) {
+		return { 'status': 400, 'error': 'user must be a user id.' };
+	}
+
+	const cacheConfig = get(["custom", "gateway", "value", "cache"], registry);
+	if (!cacheConfig) {
+		return { 'status': 400, 'error': 'Caching is not configured.' };
+	}
+	if (cacheConfig.model !== 'mongo') {
+		return { 'status': 400, 'error': 'Cache invalidation needs the mongo model, the cache model is [' + (cacheConfig.model || 'memory') + '].' };
+	}
+	if (!mongo.mongo) {
+		return { 'status': 500, 'error': 'The cache store is not ready.' };
+	}
+
+	try {
+		const removed = await mongo.invalidateMatching({
+			'tenant': input.tenant,
+			'service': input.service,
+			'api': input.api,
+			'user': input.user
+		});
+		return { 'status': 200, 'removed': removed };
+	} catch (e) {
+		if (mongo.log) {
+			mongo.log.error('Cache invalidate:', e.message);
+		}
+		return { 'status': 500, 'error': 'Cache invalidation failed.' };
+	}
+}
+
+module.exports = invalidate;

package/mw/cache/model/mongo.js

@@ -12,6 +12,11 @@ const core = require('soajs.core.modules');
 const Mongo = core.mongo;
 
 const cache_store = 'cache_store';
+const cache_invalidation = 'cache_invalidation';
+
+//NOTE: an invalidation is remembered long enough to outlive any request that started before it,
+//		so that request cannot store what it read before the change
+const INVALIDATION_RETENTION = 15 * 60 * 1000;
 
 let model = {
 	'mongo': null,
@@ -35,6 +40,27 @@ let model = {
 					log.debug("Cache TTL index created: " + index);
 				}
 			});
+			model.mongo.createIndex(cache_store, { 'l1': 1, 'service': 1, 'api': 1, 'user': 1 }, {}, (err, index) => {
+				if (err) {
+					log.error("Cache invalidation lookup index creation failed: " + err.message);
+				} else {
+					log.debug("Cache invalidation lookup index created: " + index);
+				}
+			});
+			model.mongo.createIndex(cache_invalidation, { 'l1': 1, 'service': 1, 'api': 1, 'user': 1 }, { unique: true }, (err, index) => {
+				if (err) {
+					log.error("Cache invalidation index creation failed: " + err.message);
+				} else {
+					log.debug("Cache invalidation index created: " + index);
+				}
+			});
+			model.mongo.createIndex(cache_invalidation, { 'expiresAt': 1 }, { expireAfterSeconds: 0 }, (err, index) => {
+				if (err) {
+					log.error("Cache invalidation TTL index creation failed: " + err.message);
+				} else {
+					log.debug("Cache invalidation TTL index created: " + index);
+				}
+			});
 		}
 	},
 
@@ -58,7 +84,15 @@ let model = {
 		}
 	},
 
-	'set': async (key, response, ttl) => {
+	/**
+	 * @param key {l1, l2}
+	 * @param response {statusCode, headers, body}
+	 * @param ttl
+	 * @param meta {service, api, user, startedAt} what an invalidation matches on, user is null for a
+	 *        tenant scoped entry
+	 * @returns {Promise<boolean>} false when not stored
+	 */
+	'set': async (key, response, ttl, meta) => {
 		let condition = {
 			'l1': key.l1,
 			'l2': key.l2
@@ -70,13 +104,73 @@ let model = {
 			'cachedAt': new Date(),
 			'expiresAt': new Date(Date.now() + ttl)
 		};
+		if (meta) {
+			doc.service = meta.service;
+			doc.api = meta.api;
+			doc.user = meta.user || null;
+		}
 		let options = { 'upsert': true };
 		let s = { '$set': doc };
 		try {
+			//NOTE: a request that started before an invalidation covering it may have read the data
+			//		before the change, its response is passed on but not stored
+			if (meta && meta.startedAt) {
+				let invalidated = await model.mongo.findOne(cache_invalidation, {
+					'l1': key.l1,
+					'service': meta.service,
+					'api': { '$in': [meta.api, null] },
+					'user': { '$in': [doc.user, null] },
+					'clearedAt': { '$gt': new Date(meta.startedAt) }
+				});
+				if (invalidated) {
+					return false;
+				}
+			}
 			await model.mongo.updateOne(cache_store, condition, s, options);
+			return true;
 		} catch (e) {
 			model.log.error('Cache set:', e.message);
+			return false;
+		}
+	},
+
+	/**
+	 * Remove every cached variant of the matching entries, all query strings and path params.
+	 *
+	 * NOTE: the invalidation is recorded before the entries are removed, a request that read before the
+	 *       change and stores after the removal is caught by set
+	 *
+	 * @param criteria {tenant, service, api, user} api and user are optional, without them every api of
+	 *        the service, for every user and the tenant scoped entries
+	 * @returns {Promise<number>} the number of entries removed
+	 */
+	'invalidateMatching': async (criteria) => {
+		let marker = {
+			'l1': criteria.tenant,
+			'service': criteria.service,
+			'api': criteria.api || null,
+			'user': criteria.user || null
+		};
+		let now = new Date();
+		await model.mongo.updateOne(cache_invalidation, marker, {
+			'$set': Object.assign({}, marker, {
+				'clearedAt': now,
+				'expiresAt': new Date(now.getTime() + INVALIDATION_RETENTION)
+			})
+		}, { 'upsert': true });
+
+		let condition = {
+			'l1': criteria.tenant,
+			'service': criteria.service
+		};
+		if (criteria.api) {
+			condition.api = criteria.api;
+		}
+		if (criteria.user) {
+			condition.user = criteria.user;
 		}
+		let response = await model.mongo.deleteMany(cache_store, condition);
+		return (response && response.deletedCount) || 0;
 	},
 
 	'invalidate': async (key) => {

package/mw/gotoService/redirectToService.js

@@ -11,6 +11,7 @@
 const get = (p, o) => p.reduce((xs, x) => (xs && xs[x]) ? xs[x] : null, o);
 
 const { httpRequestLight, proxyRequestMonitor } = require("../../lib/request.js");
+const idempotency_mw = require("../idempotency/index.js");
 
 // Monitor buffer for batch uploads
 let monitorBuffer = [];
@@ -395,6 +396,11 @@ module.exports = (configuration) => {
 				};
 			}
 
+			//NOTE: from here the outcome of the service decides the key, the release on finish in the
+			//		idempotency middleware stands down
+			if (idempotencyContext) {
+				idempotencyContext.proxied = true;
+			}
 			proxyRequestMonitor(req, res, requestOptions, extraOptions)
 				.then(() => {
 					// Save to cache if applicable
@@ -405,17 +411,23 @@ module.exports = (configuration) => {
 							headers: cacheResponseHeaders,
 							body: cacheBody
 						};
-						cacheContext.model.set(cacheContext.key, cacheData, cacheContext.ttl);
+						cacheContext.model.set(cacheContext.key, cacheData, cacheContext.ttl, cacheContext.meta);
 					}
 					// Complete idempotency if applicable
+					//NOTE: only an answer of the service is replayed, a 5xx means it could not answer, release
+					//		the key so the retry reaches the service again
 					if (idempotencyContext) {
-						let idempotencyBody = Buffer.concat(idempotencyResponseChunks).toString('utf8');
-						let idempotencyData = {
-							statusCode: idempotencyResponseStatusCode,
-							headers: idempotencyResponseHeaders,
-							body: idempotencyBody
-						};
-						idempotencyContext.model.complete(idempotencyContext.key, idempotencyData, idempotencyContext.ttl);
+						if (idempotencyResponseStatusCode < 500) {
+							let idempotencyBody = Buffer.concat(idempotencyResponseChunks).toString('utf8');
+							let idempotencyData = {
+								statusCode: idempotencyResponseStatusCode,
+								headers: idempotencyResponseHeaders,
+								body: idempotencyBody
+							};
+							idempotencyContext.model.complete(idempotencyContext.key, idempotencyData, idempotencyContext.ttl);
+						} else {
+							idempotency_mw.unlock(idempotencyContext.model, idempotencyContext.key, idempotencyContext.lockId, req.soajs.log);
+						}
 					}
 					if (monitor && !monitor_service_blacklist && monitor.req_response) {
 						monitoObj.time.res_end = new Date().getTime();
@@ -430,7 +442,7 @@ module.exports = (configuration) => {
 					}
 					// Unlock idempotency on error
 					if (idempotencyContext) {
-						idempotencyContext.model.unlock(idempotencyContext.key);
+						idempotency_mw.unlock(idempotencyContext.model, idempotencyContext.key, idempotencyContext.lockId, req.soajs.log);
 					}
 					if (!req.soajs.controller.monitorEndingReq) {
 						req.soajs.controllerResponse(core.error.getError(135));

package/mw/idempotency/index.js

@@ -8,6 +8,7 @@
  * found in the LICENSE file at the root of this repository
  */
 
+const crypto = require('crypto');
 const get = (p, o) => p.reduce((xs, x) => (xs && xs[x]) ? xs[x] : null, o);
 const memory = require('./model/memory.js');
 const mongo = require('./model/mongo.js');
@@ -56,6 +57,21 @@ function matchesApi(method, path, apis) {
 	return false;
 }
 
+/**
+ * Release a key this request locked, only while it is still in flight and still ours
+ * @param modelObj memory or mongo
+ * @param key
+ * @param lockId
+ * @param log
+ */
+function unlock(modelObj, key, lockId, log) {
+	Promise.resolve()
+		.then(() => modelObj.unlock(key, lockId))
+		.catch((err) => {
+			log.error('Idempotency unlock:', err.message);
+		});
+}
+
 module.exports = function (configuration) {
 	model.memory.init(configuration.log);
 	model.mongo.init(configuration.log, configuration.gatewayDB);
@@ -131,6 +147,7 @@ module.exports = function (configuration) {
 			'l2': idempotencyKey
 		};
 
+		let lockId = null;
 		const processIdempotency = async () => {
 			try {
 				const existing = await model[modelType].get(key);
@@ -152,7 +169,8 @@ module.exports = function (configuration) {
 					}
 				}
 
-				const locked = await model[modelType].lock(key, ttl);
+				lockId = crypto.randomUUID();
+				const locked = await model[modelType].lock(key, ttl, lockId);
 				if (!locked) {
 					req.soajs.controllerResponse({
 						'status': 409,
@@ -163,18 +181,37 @@ module.exports = function (configuration) {
 				}
 
 				// Store idempotency context for gotoService to use
-				req.soajs.idempotencyContext = {
+				const context = {
 					key: key,
 					ttl: ttl,
+					lockId: lockId,
 					modelType: modelType,
 					model: model[modelType],
-					log: configuration.log
+					log: configuration.log,
+					proxied: false
 				};
+				req.soajs.idempotencyContext = context;
+
+				//NOTE: a request answered before it reaches the service, throttled, refused or dropped by
+				//		the client, must not keep the key in flight until the ttl, release it once the response
+				//		is over. A proxied request is completed or released by gotoService, never here.
+				let released = false;
+				const release = () => {
+					if (released || context.proxied) {
+						return;
+					}
+					released = true;
+					unlock(model[modelType], key, lockId, configuration.log);
+				};
+				res.on('finish', release);
+				res.on('close', release);
 
 				next();
 			} catch (err) {
 				configuration.log.error('Idempotency error:', err);
-				model[modelType].unlock(key).catch(() => {});
+				if (lockId) {
+					unlock(model[modelType], key, lockId, configuration.log);
+				}
 				next();
 			}
 		};
@@ -185,3 +222,4 @@ module.exports = function (configuration) {
 
 // Export model for external use
 module.exports.model = model;
+module.exports.unlock = unlock;