spec-3nweb-server 1.8.6 → 1.8.7

package/build/asmail/routes/retrieval/remove-message.js

@@ -19,6 +19,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.deleteMsg = void 0;
 const recipients_1 = require("../../resources/recipients");
 const retrieval_1 = require("../../../lib-common/service-api/asmail/retrieval");
+const utils_1 = require("../../resources/utils");
 function deleteMsg(delMsgFunc) {
     return async (req, res, next) => {
         const userId = req.session.params.userId;
@@ -32,10 +33,10 @@ function deleteMsg(delMsgFunc) {
                 next(err);
             }
             else if (err === recipients_1.SC.MSG_UNKNOWN) {
-                res.status(retrieval_1.rmMsg.SC.unknownMsg).send("Message " + msgId + " is unknown.");
+                (0, utils_1.replyWithErr)(retrieval_1.rmMsg.SC.unknownMsg, "Message " + msgId + " is unknown.", res);
             }
             else if (err === recipients_1.SC.USER_UNKNOWN) {
-                res.status(retrieval_1.ERR_SC.server).send("Recipient disappeared from the system.");
+                (0, utils_1.replyWithErr)(retrieval_1.ERR_SC.server, "Recipient disappeared from the system.", res);
                 req.session.close();
             }
             else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spec-3nweb-server",
-  "version": "1.8.6",
+  "version": "1.8.7",
   "description": "3NWeb spec server.",
   "main": "build/lib.js",
   "types": "build/lib.d.ts",

package/ts-code/3nstorage/resources/store.ts

@@ -1,5 +1,5 @@
 /*
- Copyright (C) 2015 - 2017, 2019 - 2020, 2022, 2025 3NSoft Inc.
+ Copyright (C) 2015 - 2017, 2019 - 2020, 2022, 2025 - 2026 3NSoft Inc.
  
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
@@ -511,7 +511,7 @@ export class Store extends UserFiles<StorageParams> {
 	//		file/folder.
 
 	async archiveCurrentObjVersion(
-		objId: string, version: number
+		objId: string|null, version: number
 	): Promise<void> {
 		// XXX need to put archiving transaction, closing it in a finally clause
 		//  - make in memory transactions for archival and removal, or chaining(?)
@@ -535,7 +535,7 @@ export class Store extends UserFiles<StorageParams> {
 		);
 	}
 
-	async getObjStatus(objId: string): Promise<ObjStatus> {
+	async getObjStatus(objId: string|null): Promise<ObjStatus> {
 		const status = await this.statuses.get(objId);
 		return {
 			current: status.currentVersion,

package/ts-code/3nstorage/resources/users.ts

@@ -1,5 +1,5 @@
 /*
- Copyright (C) 2015 - 2017, 2020, 2025 3NSoft Inc.
+ Copyright (C) 2015 - 2017, 2020, 2025 - 2026 3NSoft Inc.
  
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
@@ -48,15 +48,15 @@ export type GetArchivedObjVersion = (
 ) => Promise<ObjReader>;
 
 export type CancelTransaction = (
-	userId: string, objId: string, transactionId?: string
+	userId: string, objId: string|null, transactionId?: string
 ) => Promise<void>;
 
 export type ArchiveObjCurrentVersion = (
-	userId: string, objId: string, version: number
+	userId: string, objId: string|null, version: number
 ) => Promise<void>;
 
 export type GetObjStatus = (
-	userId: string, objId: string
+	userId: string, objId: string|null
 ) => Promise<ObjStatus>;
 
 export type DeleteCurrentObjVersion = (
@@ -181,7 +181,7 @@ export function makeFactory(
 	}
 
 	function makeTransactionCanceller(): CancelTransaction {
-		return async (userId: string, objId: string, transactionId?: string) => {
+		return async (userId: string, objId: string|null, transactionId?: string) => {
 			const store = await getStore(userId);
 			await store.cancelTransaction(objId, transactionId);
 		};

package/ts-code/3nstorage/resources/utils.ts

@@ -0,0 +1,45 @@
+/*
+ Copyright (C) 2026 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import { Response, Request } from 'express';
+import { base64urlSafe } from '../../lib-common/buffer-utils';
+import { ErrorReply } from '../../lib-common/service-api/3nstorage/owner';
+import { attachByteDrainToRequest } from '../../lib-server/middleware/body-parsers';
+
+export function getObjIdFromParams(rootObj: boolean, req: Request): {
+	objId: string|null; objIdParseErr?: string;
+} {
+	if (rootObj) {
+		return { objId: null };
+	} else {
+		const objId = req.params.objId;
+		return ((!!objId && base64urlSafe.allCharsFromAlphabet(objId)) ?
+			{ objId } :
+			{ objId: undefined as any, objIdParseErr: "Bad object id" }
+		);
+	}
+}
+
+export function replyWithErr(status: number, msg: string, res: Response, reqToDrainBytesFrom?: Request): void {
+	if (reqToDrainBytesFrom) {
+		attachByteDrainToRequest(reqToDrainBytesFrom);
+	}
+	res.status(status).json({ error: msg } as ErrorReply);
+}
+
+
+Object.freeze(exports);

package/ts-code/3nstorage/routes/owner/archive-obj-version.ts

@@ -19,24 +19,25 @@ import { RequestHandler } from 'express';
 import { ArchiveObjCurrentVersion, MismatchedObjVerException, SC as storeSC } from '../../resources/users';
 import { archiveObj as api, ERR_SC, HTTP_HEADER } from '../../../lib-common/service-api/3nstorage/owner';
 import { Request } from '../../resources/sessions';
+import { getObjIdFromParams, replyWithErr } from '../../resources/utils';
 
 const SC = api.SC;
 
 export function archiveCurrentObjVersion(
 	root: boolean, archiveObjVerFunc: ArchiveObjCurrentVersion
 ): RequestHandler {
-	if ('function' !== typeof archiveObjVerFunc) { throw new TypeError(
-			"Given argument 'archiveObjVerFunc' must be function, but is not."); }
 
 	return async (req: Request, res, next) => {
 
 		const userId = req.session.params.userId;
-		const objId: string = (root ? null as any : req.params.objId);
+		const { objId, objIdParseErr } = getObjIdFromParams(root, req);
+		if (objIdParseErr) {
+			return replyWithErr(ERR_SC.malformed, objIdParseErr, res);
+		}
 
 		const version = parseInt(req.query.ver as any);
 		if (isNaN(version) || (version < 1)) {
-			res.status(ERR_SC.malformed).send("Bad query parameters");
-			return;
+			return replyWithErr(ERR_SC.malformed, "Bad query parameters", res);
 		}
 
 		try {
@@ -55,12 +56,9 @@ export function archiveCurrentObjVersion(
 					next(err);
 				}
 			} else if (err === storeSC.OBJ_UNKNOWN) {
-				res.status(SC.unknownObj).send(root ?
-					`Root object is not set.` :
-					`Object ${objId} is unknown.`);
+				replyWithErr(SC.unknownObj, (root ? `Root object is not set.` : `Object ${objId} is unknown.`), res);
 			} else if (err === storeSC.USER_UNKNOWN) {
-				res.status(ERR_SC.server).send(
-					"Recipient disappeared from the system.");
+				replyWithErr(ERR_SC.server, "Recipient disappeared from the system.", res);
 				req.session.close();
 			} else {
 				next(new Error("Unhandled storage error code: "+err));

package/ts-code/3nstorage/routes/owner/cancel-trans.ts

@@ -19,17 +19,19 @@ import { RequestHandler } from 'express';
 import { CancelTransaction, SC as storeSC } from '../../resources/users';
 import { cancelTransaction as api, ERR_SC } from '../../../lib-common/service-api/3nstorage/owner';
 import { Request } from '../../resources/sessions';
+import { getObjIdFromParams, replyWithErr } from '../../resources/utils';
 
 export function cancelTransaction(
 	root: boolean, cancelTransFunc: CancelTransaction
 ): RequestHandler {
-	if ('function' !== typeof cancelTransFunc) { throw new TypeError(
-			"Given argument 'cancelTransFunc' must be function, but is not."); }
 
 	return async (req: Request, res, next) => {
 
 		const userId = req.session.params.userId;
-		const objId: string = (root ? null as any : req.params.objId);
+		const { objId, objIdParseErr } = getObjIdFromParams(root, req);
+		if (objIdParseErr) {
+			return replyWithErr(ERR_SC.malformed, objIdParseErr, res);
+		}
 		const transactionId: string = req.params.transactionId;
 
 		try {

package/ts-code/3nstorage/routes/owner/delete-obj.ts

@@ -20,13 +20,12 @@ import { DeleteArchivedObjVersion, DeleteCurrentObjVersion, SC as storeSC } from
 import { ERR_SC, currentObj as api } from '../../../lib-common/service-api/3nstorage/owner';
 import { Request } from '../../resources/sessions';
 import { assert } from '../../../lib-common/assert';
+import { getObjIdFromParams, replyWithErr } from '../../resources/utils';
 
 function deleteObj(
 	root: boolean, delCurrent: boolean,
 	deleteObjFunc: DeleteArchivedObjVersion|DeleteCurrentObjVersion
 ): RequestHandler {
-	if ('function' !== typeof deleteObjFunc) { throw new TypeError(
-			"Given argument 'deleteObjFunc' must be function, but is not."); }
 	if (delCurrent) {
 		assert(!root);
 	}
@@ -34,7 +33,10 @@ function deleteObj(
 	return async (req: Request, res, next) => {
 
 		const userId = req.session.params.userId;
-		const objId: string|null = (root ? null : req.params.objId);
+		const { objId, objIdParseErr } = getObjIdFromParams(root, req);
+		if (objIdParseErr) {
+			return replyWithErr(ERR_SC.malformed, objIdParseErr, res);
+		}
 
 		const ver = parseInt(req.query.ver as string);
 		let version: number|undefined;
@@ -42,26 +44,20 @@ function deleteObj(
 			if (delCurrent) {
 				version = undefined
 			} else {
-				res.status(ERR_SC.malformed).send("Bad query parameters");
-				return;
+				return replyWithErr(ERR_SC.malformed, "Bad query parameters", res);
 			}
 		} else {
 			if (ver < 1) {
-				res.status(ERR_SC.malformed).send("Bad query parameters");
-				return;
+				return replyWithErr(ERR_SC.malformed, "Bad query parameters", res);
 			}
 			version = ver;
 		}
 
 		try {
 			if (delCurrent) {
-				await (deleteObjFunc as DeleteCurrentObjVersion)(
-					userId, objId!, version
-				);
+				await (deleteObjFunc as DeleteCurrentObjVersion)(userId, objId!, version);
 			} else {
-				await (deleteObjFunc as DeleteArchivedObjVersion)(
-					userId, objId, version!
-				);
+				await (deleteObjFunc as DeleteArchivedObjVersion)(userId, objId, version!);
 			}
 			res.status(api.SC.okDelete).send();
 		} catch (err) {

package/ts-code/3nstorage/routes/owner/get-archived-obj-ver.ts

@@ -1,5 +1,5 @@
 /*
- Copyright (C) 2017, 2020 3NSoft Inc.
+ Copyright (C) 2017, 2020, 2026 3NSoft Inc.
  
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
@@ -21,6 +21,7 @@ import { GetObjQueryOpts, ERR_SC, HTTP_HEADER, BIN_TYPE, archivedObjVersion as a
 import { Request } from '../../resources/sessions';
 import { errWithCause } from '../../../lib-common/exceptions/error';
 import { EMPTY_BUFFER } from '../../../lib-common/buffer-utils';
+import { getObjIdFromParams, replyWithErr } from '../../resources/utils';
 
 function extractQueryOptions(req: Request): undefined|{
 	header: boolean; limit: number|undefined; ofs: number; ver: number
@@ -51,23 +52,22 @@ function extractQueryOptions(req: Request): undefined|{
 export function getArchivedObjVersion(
 	root: boolean, getArchivedObjFunc: GetArchivedObjVersion
 ): RequestHandler {
-	if ('function' !== typeof getArchivedObjFunc) { throw new TypeError(
-			"Given argument 'getArchivedObjFunc' must be function, but is not."); }
 
 	return async (req: Request, res, next) => {
 		
 		const userId = req.session.params.userId;
-		const objId: string = (root ? null as any : req.params.objId);
+		const { objId, objIdParseErr } = getObjIdFromParams(root, req);
+		if (objIdParseErr) {
+			return replyWithErr(ERR_SC.malformed, objIdParseErr, res);
+		}
 		
 		const opts = extractQueryOptions(req);
 		if (!opts) {
-			res.status(ERR_SC.malformed).send("Bad query parameters");
-			return;
+			return replyWithErr(ERR_SC.malformed, "Bad query parameters", res);
 		}
 		
 		try {
-			const reader = await getArchivedObjFunc(userId, objId, opts.ver,
-				opts.header, opts.ofs, opts.limit);
+			const reader = await getArchivedObjFunc(userId, objId, opts.ver, opts.header, opts.ofs, opts.limit);
 			res.status(api.SC.okGet);
 			res.set(HTTP_HEADER.contentType, BIN_TYPE);
 			res.set(HTTP_HEADER.contentLength, `${reader.len}`);
@@ -90,15 +90,13 @@ export function getArchivedObjVersion(
 			if ("string" !== typeof err) {
 				next(err);
 			} else if (err === storeSC.OBJ_UNKNOWN) {
-				res.status(api.SC.unknownObj).send(objId ?
-					`Object ${objId}is unknown.` : `Root object is not set`);
+				replyWithErr(api.SC.unknownObj, (objId ? `Object ${objId}is unknown.` : `Root object is not set`), res);
 			} else if (err === storeSC.OBJ_VER_UNKNOWN) {
-				res.status(api.SC.unknownObjVer).send(objId ?
-					`Object ${objId}, version ${opts.ver} is unknown.` :
-					`Root object version ${opts.ver} is not known.`);
+				replyWithErr(api.SC.unknownObjVer, (objId ?
+					`Object ${objId}, version ${opts.ver} is unknown.` : `Root object version ${opts.ver} is not known.`
+				), res);
 			} else if (err === storeSC.USER_UNKNOWN) {
-				res.status(ERR_SC.server).send(
-					`Recipient disappeared from the system.`);
+				replyWithErr(ERR_SC.server, `Recipient disappeared from the system.`, res);
 				req.session.close();
 			} else {
 				next(new Error(`Unhandled storage error code: ${err}`));

package/ts-code/3nstorage/routes/owner/get-current-obj.ts

@@ -21,6 +21,7 @@ import { GetObjQueryOpts, ERR_SC, HTTP_HEADER, BIN_TYPE, currentObj as api } fro
 import { Request } from '../../resources/sessions';
 import { errWithCause, stringifyErr } from '../../../lib-common/exceptions/error';
 import { EMPTY_BUFFER } from '../../../lib-common/buffer-utils';
+import { getObjIdFromParams, replyWithErr } from '../../resources/utils';
 
 function extractQueryOptions(req: Request): undefined|{
 	header: boolean; limit: number|undefined; ofs: number;
@@ -58,13 +59,14 @@ function extractQueryOptions(req: Request): undefined|{
 export function getCurrentObj(
 	root: boolean, getCurrentObjFunc: GetCurrentObj
 ): RequestHandler {
-	if ('function' !== typeof getCurrentObjFunc) { throw new TypeError(
-			"Given argument 'getCurrentObjFunc' must be function, but is not."); }
 
 	return async (req: Request, res, next) => {
 		
 		const userId = req.session.params.userId;
-		const objId: string = (root ? null as any : req.params.objId);
+		const { objId, objIdParseErr } = getObjIdFromParams(root, req);
+		if (objIdParseErr) {
+			return replyWithErr(ERR_SC.malformed, objIdParseErr, res);
+		}
 		
 		const opts = extractQueryOptions(req);
 		if (!opts) {
@@ -107,9 +109,9 @@ export function getCurrentObj(
 				next(err);
 			} else if ((err === storeSC.OBJ_UNKNOWN)
 			|| (err === storeSC.OBJ_VER_UNKNOWN)) {
-				res.status(api.SC.unknownObj).send(objId ? `Object ${objId} is unknown.` : `Root object is not set.`);
+				replyWithErr(api.SC.unknownObj, (objId ? `Object ${objId} is unknown.` : `Root object is not set.`), res);
 			} else if (err === storeSC.USER_UNKNOWN) {
-				res.status(ERR_SC.server).send(`Recipient disappeared from the system.`);
+				replyWithErr(ERR_SC.server, `Recipient disappeared from the system.`, res);
 				req.session.close();
 			} else {
 				next(new Error(`Unhandled storage error code: ${err}`));

package/ts-code/3nstorage/routes/owner/get-obj-status.ts

@@ -1,5 +1,5 @@
 /*
- Copyright (C) 2022 3NSoft Inc.
+ Copyright (C) 2022, 2026 3NSoft Inc.
  
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
@@ -19,17 +19,19 @@ import { RequestHandler } from 'express';
 import { GetObjStatus, SC as storeSC } from '../../resources/users';
 import { objStatus as api, ERR_SC } from '../../../lib-common/service-api/3nstorage/owner';
 import { Request } from '../../resources/sessions';
+import { getObjIdFromParams, replyWithErr } from '../../resources/utils';
 
 export function getObjStatus(
 	root: boolean, getObjStatusFunc: GetObjStatus
 ): RequestHandler {
-	if ('function' !== typeof getObjStatusFunc) { throw new TypeError(
-			"Given argument 'getObjStatusFunc' must be function, but is not."); }
 
 	return async (req: Request, res, next) => {
 
 		const userId = req.session.params.userId;
-		const objId: string = (root ? null as any : req.params.objId);
+		const { objId, objIdParseErr } = getObjIdFromParams(root, req);
+		if (objIdParseErr) {
+			return replyWithErr(ERR_SC.malformed, objIdParseErr, res);
+		}
 		
 		try {
 			const lst = await getObjStatusFunc(userId, objId);
@@ -38,11 +40,9 @@ export function getObjStatus(
 			if ("string" !== typeof err) {
 				next(err);
 			} else if (err === storeSC.OBJ_UNKNOWN) {
-				res.status(api.SC.unknownObj).send(root ?
-					`Root object is set.` : `Object ${objId} is unknown.`);
+				replyWithErr(api.SC.unknownObj, (root ? `Root object is set.` : `Object ${objId} is unknown.`), res);
 			} else if (err === storeSC.USER_UNKNOWN) {
-				res.status(ERR_SC.server).send(
-					"Recipient disappeared from the system.");
+				replyWithErr(ERR_SC.server, "Recipient disappeared from the system.", res);
 				req.session.close();
 			} else {
 				next(new Error("Unhandled storage error code: "+err));

package/ts-code/3nstorage/routes/owner/put-current-obj.ts

@@ -1,5 +1,5 @@
 /*
- Copyright (C) 2017, 2019 - 2020 3NSoft Inc.
+ Copyright (C) 2017, 2019 - 2020, 2026 3NSoft Inc.
  
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
@@ -24,7 +24,8 @@ import { attachByteDrainToRequest } from '../../../lib-server/middleware/body-pa
 import { Readable as ReadableStream } from 'stream';
 import { BytesFIFOBuffer } from '../../../lib-common/byte-streaming/common';
 import { defer, Deferred } from '../../../lib-common/processes';
-import { utf8, base64urlSafe } from '../../../lib-common/buffer-utils';
+import { utf8 } from '../../../lib-common/buffer-utils';
+import { getObjIdFromParams, replyWithErr } from '../../resources/utils';
 
 export function saveCurrentObj(
 	root: boolean, saveObjFunc: SaveNewObjVersion, chunkLimit: string|number
@@ -36,43 +37,36 @@ export function saveCurrentObj(
 	return async (req: Request, res, next) => {
 		
 		if (!req.is(BIN_TYPE)) {
-			attachByteDrainToRequest(req);
-			res.status(ERR_SC.wrongContentType).json( <ErrorReply> {
-				error: `Content-Type must be ${BIN_TYPE} for this call.`
-			});
-			return;
+			return replyWithErr(ERR_SC.wrongContentType, `Content-Type must be ${BIN_TYPE} for this call.`, res, req);
 		}
-	
-		const userId = req.session.params.userId;
-		const objId: string = (root ? null as any : req.params.objId);
 
 		// get and check Content-Length, implicitly sending replies for bad length
 		let len = getContentLenOrSendError(req, res, maxChunkSize);
 		if (len === undefined) {
-			attachByteDrainToRequest(req);
 			return;
 		}
+	
+		const userId = req.session.params.userId;
+		const { objId, objIdParseErr } = getObjIdFromParams(root, req);
+		if (objIdParseErr) {
+			return replyWithErr(ERR_SC.malformed, objIdParseErr, res, req);
+		}
 		
 		// extract and check query parameters
 		const opts = extractQueryOptions(req);
-		if (!opts) { return replyToMalformed(req, "Bad query parameters", res); }
+		if (!opts) {
+			return replyWithErr(ERR_SC.malformed, "Bad query parameters", res, req);
+		}
 		const { fstReq, sndReq } = opts;
 
 		let diff: DiffInfo|undefined;
 
 		if (fstReq) {
 
-			if (!root && objId) {
-				if (!base64urlSafe.allCharsFromAlphabet(objId!)) {
-					return replyToMalformed(req, "Bad object id", res);
-				}
-			}
-
 			// cross-check given lengths
-			const diffAndHeader = fstReq.header +
-				(fstReq.diff ? fstReq.diff : 0);
+			const diffAndHeader = fstReq.header + (fstReq.diff ? fstReq.diff : 0);
 			if (diffAndHeader > len) {
-				return replyToMalformed(req, "Bad query parameters", res);
+				return replyWithErr(ERR_SC.malformed, "Bad query parameters", res, req);
 			}
 
 			// read diff, if it is expected
@@ -81,30 +75,29 @@ export function saveCurrentObj(
 				if (diffBytes) {
 					len -= fstReq.diff;
 				} else {
-					return replyToMalformed(req, "Cannot read diff bytes", res);
+				return replyWithErr(ERR_SC.malformed, "Cannot read diff bytes", res, req);
 				}
 				try {
 					const diffFromReq = JSON.parse(utf8.open(diffBytes));
 					diff = sanitizedDiff(diffFromReq, fstReq.ver);
 					if (!diff) {
-						return replyToMalformed(req, "Malformed diff info", res);
+						return replyWithErr(ERR_SC.malformed, "Malformed diff info", res, req);
 					}
 				} catch (err) {
-					 return replyToMalformed(req, "Malformed diff info", res);
+					return replyWithErr(ERR_SC.malformed, "Malformed diff info", res, req);
 				}
 			}
 
 		} else if (sndReq) {
 
 			if ((len === 0) && !sndReq.last) {
-				return replyToMalformed(req, "No segment bytes", res);
+				return replyWithErr(ERR_SC.malformed, "No segment bytes", res, req);
 			}
 
 		}
 
 		try {
-			const transactionId = await saveObjFunc(
-				userId, objId, fstReq, diff, sndReq, len, req);
+			const transactionId = await saveObjFunc(userId, objId, fstReq, diff, sndReq, len, req);
 			const reply: api.ReplyToPut = (transactionId ? { transactionId } : {});
 			res.status(api.SC.okPut).json(reply);
 		} catch (err) {
@@ -114,42 +107,28 @@ export function saveCurrentObj(
 						error: "Current object version doesn't match assumed one.",
 						current_version: (err as MismatchedObjVerException).current_version
 					};
-					res.set(HTTP_HEADER.objVersion, `${(err as MismatchedObjVerException).current_version}`);
+					res.set(HTTP_HEADER.objVersion, `${rep.current_version}`);
 					res.status(api.SC.mismatchedObjVer).json(rep);
 				} else {
 					next(err);
 				}
 			} else if ((err === saveSC.OBJ_UNKNOWN)
 			|| (err === saveSC.OBJ_VER_UNKNOWN)) {
-				res.status(api.SC.unknownObj).json( <ErrorReply> {
-					error: `Unknown object ${objId}.`
-				});
+				replyWithErr(api.SC.unknownObj, `Unknown object ${objId}.`, res);
 			} else if (err === saveSC.TRANSACTION_UNKNOWN) {
-				res.status(api.SC.unknownTransaction).json( <ErrorReply> {
-					error: "Unknown transaction."
-				});
+				replyWithErr(api.SC.unknownTransaction, "Unknown transaction.", res);
 			} else if ((err === saveSC.OBJ_EXIST)
 			|| (err === saveSC.OBJ_VER_EXIST)) {
-				res.status(api.SC.objAlreadyExists).json( <ErrorReply> {
-					error: "Object already exists."
-				});
+				replyWithErr(api.SC.objAlreadyExists, "Object already exists.", res);
 			} else if (err === saveSC.CONCURRENT_TRANSACTION) {
-				res.status(api.SC.concurrentTransaction).json( <ErrorReply> {
-					error: `Object ${objId} is currently under a transaction.`
-				});
+				replyWithErr(api.SC.concurrentTransaction, `Object ${objId} is currently under a transaction.`, res);
 			} else if (err === saveSC.USER_UNKNOWN) {
-				res.status(ERR_SC.server).json( <ErrorReply> {
-					error: "Recipient disappeared from the system."
-				});
+				replyWithErr(ERR_SC.server, "Recipient disappeared from the system.", res);
 				req.session.close();
 			} else if (err === saveSC.NOT_ENOUGH_SPACE) {
-				res.status(ERR_SC.noSpace).json( <ErrorReply> {
-					error: "Reached storage limits."
-				});
+				replyWithErr(ERR_SC.noSpace, "Reached storage limits.", res);
 			} else if (err === saveSC.OBJ_FILE_INCOMPLETE) {
-				res.status(api.SC.objIncomplete).json( <ErrorReply> {
-					error: "Object version file is incomplete."
-				});
+				replyWithErr(api.SC.objIncomplete, "Object version file is incomplete.", res);
 			} else {
 				next(new Error(`Unhandled storage error code: ${err}`));
 			}
@@ -202,11 +181,9 @@ function getContentLenOrSendError(
 ): number|undefined {
 	const contentLength = parseInt(req.get(HTTP_HEADER.contentLength)!);
 	if (isNaN(contentLength)) {
-		res.status(ERR_SC.contentLenMissing).json( <ErrorReply> {
-			error: "Content-Length header is required with proper number." });
+		replyWithErr(ERR_SC.contentLenMissing, "Content-Length header is required with proper number.", res, req);
 	} else if (contentLength > maxChunkSize) {
-		res.status(ERR_SC.contentTooLong).json( <ErrorReply> {
-			error: "Request body is too long." });
+		replyWithErr(ERR_SC.contentTooLong, "Request body is too long.", res, req);
 	} else {
 		return contentLength;
 	}
@@ -225,8 +202,9 @@ const EARLY_END_OF_STREAM_ERR_STR = `Unexpected end of stream`;
 function readChunkFrom(
 	stream: ReadableStream, bytesToRead: number
 ): Promise<Uint8Array> {
-	if (bytesToRead < 1) { throw new Error(
-		`Illegal number of bytes to read from stream: ${bytesToRead}`); }
+	if (bytesToRead < 1) {
+		throw new Error(`Illegal number of bytes to read from stream: ${bytesToRead}`);
+	}
 	
 	const buffer = new BytesFIFOBuffer();
 	let deferred: Deferred<Uint8Array>|undefined = defer<Uint8Array>();
@@ -274,11 +252,6 @@ function readChunkFrom(
 	return deferred.promise;
 }
 
-function replyToMalformed(req: Request, msg: string, res: Response): void {
-	attachByteDrainToRequest(req);
-	res.status(ERR_SC.malformed).json( <ErrorReply> { error: msg });
-}
-
 function noop() {}
 
 Object.freeze(exports);

package/ts-code/3nstorage/routes/owner/session-params.ts

@@ -26,17 +26,18 @@ export function sessionParams(maxChunk: number|string): RequestHandler {
 
 	return async (req: Request, res, next) => {
 		
+		// XXX currently session params are same for all, hence, userId is unused, but, this whole
+		//     thing must be within a session
 		const userId = req.session.params.userId;
 		
-		try{
+		try {
 			const reply: api.Reply = { maxChunkSize };
 			res.status(api.SC.ok).json(reply);
 		} catch (err) {
 			if ("string" !== typeof err) {
 				next(err);
 			} else if (err === storeSC.USER_UNKNOWN) {
-				res.status(ERR_SC.server).send(
-					"Recipient disappeared from the system.");
+				res.status(ERR_SC.server).send("Recipient disappeared from the system.");
 				req.session.close();
 			} else {
 				next(new Error("Unhandled storage error code: "+err));