mbkbucket 1.5.1 → 2.0.0

package/lib/config/validation.js

@@ -0,0 +1,86 @@
+function normalizeBooleanLike(value) {
+  if (typeof value === 'boolean') return value;
+  if (typeof value === 'string') {
+    const normalized = value.trim().toLowerCase();
+    if (['true', 't', '1', 'yes', 'y', 'on'].includes(normalized)) return true;
+    if (['false', 'f', '0', 'no', 'n', 'off'].includes(normalized)) return false;
+  }
+  return value;
+}
+
+export function parseAndValidateMbkbucketVar(rawValue) {
+  const errors = [];
+  let parsed;
+
+  try {
+    parsed = rawValue ? JSON.parse(rawValue) : {};
+  } catch {
+    throw new Error('Invalid JSON in process.env.mbkbucketVar');
+  }
+
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error('mbkbucketVar must be a valid object');
+  }
+
+  const defaults = {
+    p_view_inline: true,
+    publiView_enabled: false
+  };
+
+  for (const [key, defaultVal] of Object.entries(defaults)) {
+    const current = parsed[key];
+    if (current === undefined || (typeof current === 'string' && current.trim() === '')) {
+      parsed[key] = defaultVal;
+    }
+  }
+
+  parsed.p_view_inline = normalizeBooleanLike(parsed.p_view_inline);
+  parsed.publiView_enabled = normalizeBooleanLike(parsed.publiView_enabled);
+
+  if (typeof parsed.p_view_inline !== 'boolean') {
+    errors.push('mbkbucketVar.p_view_inline must be a boolean if provided');
+  }
+  if (typeof parsed.publiView_enabled !== 'boolean') {
+    errors.push('mbkbucketVar.publiView_enabled must be a boolean if provided');
+  }
+
+  if (errors.length) {
+    throw new Error(errors.join(' | '));
+  }
+
+  return parsed;
+}
+
+export function parseAndValidateBucketConnection(rawValue) {
+  if (!rawValue) {
+    return null;
+  }
+
+  let parsed;
+  try {
+    parsed = JSON.parse(rawValue);
+  } catch {
+    throw new Error('BucketConnection is not valid JSON');
+  }
+
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed) || Object.keys(parsed).length === 0) {
+    throw new Error('BucketConnection must be a non-empty object');
+  }
+
+  const requiredFields = ['BUCKET_NAME', 'ACCESS_KEY_ID', 'SECRET_ACCESS_KEY', 'ENDPOINT'];
+
+  for (const [bucketName, config] of Object.entries(parsed)) {
+    if (!config || typeof config !== 'object' || Array.isArray(config)) {
+      throw new Error(`Bucket '${bucketName}' configuration must be an object, not a string. Remove quotes around the inner JSON object.`);
+    }
+
+    const missingFields = requiredFields.filter((field) => !config[field]);
+    if (missingFields.length) {
+      throw new Error(`Bucket '${bucketName}' is missing required fields: ${missingFields.join(', ')}`);
+    }
+  }
+
+  return parsed;
+}
+
+export { normalizeBooleanLike };

package/lib/routes/api.js

@@ -5,6 +5,47 @@ import multer from "multer";
 
 const router = express.Router();
 
+function classifyApiError(error, fallbackMessage = 'Request failed') {
+  const message = String(error?.message || fallbackMessage);
+  const lower = message.toLowerCase();
+
+  if (lower.includes('bucketconnection environment variable is not set')) {
+    return { status: 503, code: 'BUCKET_CONFIG_ERROR', message };
+  }
+  if (lower.includes('no bucket selected') || lower.includes('not found in bucketconnection')) {
+    return { status: 400, code: 'INVALID_BUCKET', message };
+  }
+  if (lower.includes('already exists')) {
+    return { status: 409, code: 'CONFLICT', message };
+  }
+  if (lower.includes('not found')) {
+    return { status: 404, code: 'NOT_FOUND', message };
+  }
+  if (lower.includes('access denied')) {
+    return { status: 403, code: 'ACCESS_DENIED', message };
+  }
+  if (lower.includes('required') || lower.includes('invalid') || lower.includes('must be')) {
+    return { status: 400, code: 'VALIDATION_ERROR', message };
+  }
+  return { status: 500, code: 'INTERNAL_ERROR', message };
+}
+
+function sendApiError(res, error, fallbackMessage = 'Request failed') {
+  const mapped = classifyApiError(error, fallbackMessage);
+  return res.status(mapped.status).json({ success: false, code: mapped.code, error: mapped.message });
+}
+
+// Central bucket guard for all API routes under /mbkbucket
+router.use((req, res, next) => {
+  if (req.bucketResolveError) {
+    return sendApiError(res, req.bucketResolveError, 'Invalid bucket selection');
+  }
+  if (!req.activeBucket) {
+    return sendApiError(res, new Error('No bucket selected. Provide ?bucket=<name> or configure a default bucket in mbkautheVar.bucket.'));
+  }
+  next();
+});
+
 // This is the maximum size we allow per chunk upload. It should be >=
 // the client chunk size (5MB) and leave room for any encoding overhead.
 // If you need to support larger chunks, increase this accordingly.
@@ -35,6 +76,7 @@ const uploadChunk = (req, res, next) => {
 router.post('/api/cleanup-uploads', validateSessionAndRole('SuperAdmin'), async (req, res) => {
   try {
     const { olderThanDays = 7, prefix = '' } = req.body;
+    const bucketName = req.activeBucket;
 
     // Validate olderThanDays
     const days = parseInt(olderThanDays, 10);
@@ -43,7 +85,7 @@ router.post('/api/cleanup-uploads', validateSessionAndRole('SuperAdmin'), async
     }
 
     console.log(`[mbkbucket] Starting cleanup of incomplete uploads older than ${days} days`);
-    const result = await cleanupIncompleteMultipartUploads(days, prefix);
+    const result = await cleanupIncompleteMultipartUploads(days, prefix, bucketName);
 
     res.json({
       success: true,
@@ -52,10 +94,7 @@ router.post('/api/cleanup-uploads', validateSessionAndRole('SuperAdmin'), async
     });
   } catch (error) {
     console.error('[mbkbucket] Cleanup failed:', error);
-    res.status(500).json({
-      success: false,
-      error: error.message
-    });
+    return sendApiError(res, error, 'Cleanup failed');
   }
 });
 
@@ -63,7 +102,8 @@ router.post('/api/cleanup-uploads', validateSessionAndRole('SuperAdmin'), async
 router.get('/api/incomplete-uploads', validateSessionAndRole('SuperAdmin'), async (req, res) => {
   try {
     const { prefix = '' } = req.query;
-    const uploads = await listIncompleteMultipartUploads(prefix);
+    const bucketName = req.activeBucket;
+    const uploads = await listIncompleteMultipartUploads(prefix, bucketName);
 
     res.json({
       success: true,
@@ -77,10 +117,7 @@ router.get('/api/incomplete-uploads', validateSessionAndRole('SuperAdmin'), asyn
     });
   } catch (error) {
     console.error('[mbkbucket] Failed to list incomplete uploads:', error);
-    res.status(500).json({
-      success: false,
-      error: error.message
-    });
+    return sendApiError(res, error, 'Failed to list incomplete uploads');
   }
 });
 
@@ -88,6 +125,7 @@ router.get('/api/incomplete-uploads', validateSessionAndRole('SuperAdmin'), asyn
 router.get('/api/files', validateSessionAndRole('SuperAdmin'), async (req, res) => {
   const { prefix = '', page = '1', search = '', recursive = 'true', token = '' } = req.query;
   const pageSize = 100;
+  const bucketName = req.activeBucket;
   let effectivePrefix;
   try {
     effectivePrefix = ensurePrefix(prefix);
@@ -124,7 +162,8 @@ router.get('/api/files', validateSessionAndRole('SuperAdmin'), async (req, res)
       const result = await listfiles(listPrefix, {
         continuationToken: token || undefined, // Use token from query if provided
         delimiter: '/',
-        maxKeys: 1000 // Fetch a healthy batch.
+        maxKeys: 1000, // Fetch a healthy batch.
+        bucketName
       });
 
       files = result.Contents || [];
@@ -141,7 +180,7 @@ router.get('/api/files', validateSessionAndRole('SuperAdmin'), async (req, res)
 
       // Fetch all files recursively (handling S3 pagination)
       do {
-        const result = await listfiles(effectivePrefix, { continuationToken });
+        const result = await listfiles(effectivePrefix, { continuationToken, bucketName });
         if (result.Contents) {
           // Filter out folder marker objects (zero-byte files ending with /)
           const actualFiles = result.Contents.filter(f => !f.Key.endsWith('/'));
@@ -153,7 +192,7 @@ router.get('/api/files', validateSessionAndRole('SuperAdmin'), async (req, res)
       // If no files found under the app prefixed path, try root as a legacy fallback
       if (!files.length && !search) {
         try {
-          const rootResult = await listfiles('');
+          const rootResult = await listfiles('', { bucketName });
           if ((rootResult.Contents || []).length) {
             files = rootResult.Contents || [];
             usedPrefix = '';
@@ -218,9 +257,11 @@ router.get('/api/files', validateSessionAndRole('SuperAdmin'), async (req, res)
 
   } catch (error) {
     console.error("Error listing files:", error);
-    res.status(500).json({
+    const mapped = classifyApiError(error, 'Error listing files');
+    return res.status(mapped.status).json({
       success: false,
-      error: "Error listing files: " + error.message,
+      code: mapped.code,
+      error: mapped.message,
       files: [],
       totalFiles: 0
     });
@@ -230,6 +271,7 @@ router.get('/api/files', validateSessionAndRole('SuperAdmin'), async (req, res)
 // Standard single-file upload
 router.post('/upload', validateSessionAndRole('SuperAdmin'), upload.single('file'), async (req, res) => {
   try {
+    const bucketName = req.activeBucket;
     if (!req.file) {
       return res.status(400).json({ success: false, error: 'No file selected' });
     }
@@ -250,6 +292,7 @@ router.post('/upload', validateSessionAndRole('SuperAdmin'), upload.single('file
         'upload-source': 'web-portal',
         'user-agent': req.headers['user-agent'] || 'unknown'
       },
+      bucketName,
       preventOverwrite: true // Use atomic operation to prevent race conditions
     };
 
@@ -262,12 +305,12 @@ router.post('/upload', validateSessionAndRole('SuperAdmin'), upload.single('file
       if (folderPath) {
         const folderMarkerKey = folderPath; // Already ends with /
         try {
-          const markerExists = await fileExists(folderMarkerKey);
+          const markerExists = await fileExists(folderMarkerKey, bucketName);
           if (markerExists) {
             // Check if this is actually a folder marker (zero-byte file)
-            const metadata = await getFileMetadata(folderMarkerKey);
+            const metadata = await getFileMetadata(folderMarkerKey, bucketName);
             if (metadata.ContentLength === 0 || metadata.Metadata?.marker === 'true') {
-              await deleteFile(folderMarkerKey);
+              await deleteFile(folderMarkerKey, bucketName);
               console.log(`[mbkbucket] Cleaned up folder marker: ${folderMarkerKey}`);
             }
           }
@@ -287,7 +330,7 @@ router.post('/upload', validateSessionAndRole('SuperAdmin'), upload.single('file
     }
   } catch (error) {
     console.error("Error uploading file:", error);
-    res.status(500).json({ success: false, error: `Upload failed: ${error.message}` });
+    return sendApiError(res, error, 'Upload failed');
   }
 });
 
@@ -296,6 +339,7 @@ router.post('/upload', validateSessionAndRole('SuperAdmin'), upload.single('file
 // Returns: { uploadId, key }
 router.post('/upload-init', validateSessionAndRole('SuperAdmin'), async (req, res) => {
   try {
+    const bucketName = req.activeBucket;
     const { fileName, prefix = '', contentType = 'application/octet-stream' } = req.body;
     if (!fileName) return res.status(400).json({ success: false, error: 'fileName is required' });
 
@@ -306,14 +350,14 @@ router.post('/upload-init', validateSessionAndRole('SuperAdmin'), async (req, re
     // Check if file exists before initiating multipart upload
     // Note: This is still slightly racy, but multipart uploads take time so collision risk is lower
     // A complete solution would require server-side locking or unique upload IDs
-    const exists = await fileExists(key);
+    const exists = await fileExists(key, bucketName);
     if (exists) return res.status(409).json({ success: false, error: `File already exists: ${fileName}` });
 
-    const result = await createMultipartUpload(key, contentType);
+    const result = await createMultipartUpload(key, contentType, {}, bucketName);
     return res.json({ success: true, uploadId: result.uploadId, key: result.key });
   } catch (err) {
     console.error('[mbkbucket] upload-init failed:', err);
-    return res.status(500).json({ success: false, error: err.message });
+    return sendApiError(res, err, 'upload-init failed');
   }
 });
 
@@ -322,6 +366,7 @@ router.post('/upload-init', validateSessionAndRole('SuperAdmin'), async (req, re
 // Returns: { partNumber, ETag }
 router.post('/upload-chunk', validateSessionAndRole('SuperAdmin'), uploadChunk, async (req, res) => {
   try {
+    const bucketName = req.activeBucket;
     const { uploadId, key, partNumber } = req.body;
     if (!req.file || !uploadId || !key || !partNumber) {
       return res.status(400).json({ success: false, error: 'chunk file, uploadId, key, and partNumber are required' });
@@ -331,11 +376,11 @@ router.post('/upload-chunk', validateSessionAndRole('SuperAdmin'), uploadChunk,
       return res.status(400).json({ success: false, error: 'partNumber must be an integer between 1 and 10000' });
     }
 
-    const result = await uploadPart(key, uploadId, part, req.file.buffer);
+    const result = await uploadPart(key, uploadId, part, req.file.buffer, bucketName);
     return res.json({ success: true, partNumber: result.partNumber, ETag: result.ETag });
   } catch (err) {
     console.error('[mbkbucket] upload-chunk failed:', err);
-    return res.status(500).json({ success: false, error: err.message });
+    return sendApiError(res, err, 'upload-chunk failed');
   }
 });
 
@@ -344,23 +389,24 @@ router.post('/upload-chunk', validateSessionAndRole('SuperAdmin'), uploadChunk,
 // Returns: { key }
 router.post('/upload-complete', validateSessionAndRole('SuperAdmin'), async (req, res) => {
   try {
+    const bucketName = req.activeBucket;
     const { uploadId, key, parts } = req.body;
     if (!uploadId || !key || !Array.isArray(parts) || !parts.length) {
       return res.status(400).json({ success: false, error: 'uploadId, key, and parts array are required' });
     }
 
-    const result = await completeMultipartUpload(key, uploadId, parts);
+    const result = await completeMultipartUpload(key, uploadId, parts, bucketName);
 
     // Clean up folder marker if it exists in the parent directory
     const folderPath = result.key.substring(0, result.key.lastIndexOf('/') + 1);
     if (folderPath) {
       const folderMarkerKey = folderPath;
       try {
-        const markerExists = await fileExists(folderMarkerKey);
+        const markerExists = await fileExists(folderMarkerKey, bucketName);
         if (markerExists) {
-          const metadata = await getFileMetadata(folderMarkerKey);
+          const metadata = await getFileMetadata(folderMarkerKey, bucketName);
           if (metadata.ContentLength === 0 || metadata.Metadata?.marker === 'true') {
-            await deleteFile(folderMarkerKey);
+            await deleteFile(folderMarkerKey, bucketName);
             console.log(`[mbkbucket] Cleaned up folder marker: ${folderMarkerKey}`);
           }
         }
@@ -372,7 +418,7 @@ router.post('/upload-complete', validateSessionAndRole('SuperAdmin'), async (req
     return res.json({ success: true, message: 'File uploaded successfully', key: result.key });
   } catch (err) {
     console.error('[mbkbucket] upload-complete failed:', err);
-    return res.status(500).json({ success: false, error: err.message });
+    return sendApiError(res, err, 'upload-complete failed');
   }
 });
 
@@ -380,20 +426,22 @@ router.post('/upload-complete', validateSessionAndRole('SuperAdmin'), async (req
 // Body: { uploadId, key }
 router.post('/upload-abort', validateSessionAndRole('SuperAdmin'), async (req, res) => {
   try {
+    const bucketName = req.activeBucket;
     const { uploadId, key } = req.body;
     if (!uploadId || !key) return res.status(400).json({ success: false, error: 'uploadId and key are required' });
 
-    await abortMultipartUpload(key, uploadId);
+    await abortMultipartUpload(key, uploadId, bucketName);
     return res.json({ success: true, message: 'Multipart upload aborted' });
   } catch (err) {
     console.error('[mbkbucket] upload-abort failed:', err);
-    return res.status(500).json({ success: false, error: err.message });
+    return sendApiError(res, err, 'upload-abort failed');
   }
 });
 
 // Create folder (zero-byte object with trailing slash)
 router.post('/create-folder', validateSessionAndRole('SuperAdmin'), async (req, res) => {
   try {
+    const bucketName = req.activeBucket;
     const { prefix = '', folderName } = req.body;
     if (!folderName) return res.status(400).json({ success: false, error: 'folderName is required' });
 
@@ -403,11 +451,11 @@ router.post('/create-folder', validateSessionAndRole('SuperAdmin'), async (req,
     const folderKey = `${effectivePrefix.replace(/\/+$/, '')}/${folderName}/`;
 
     // Check if folder marker already exists
-    const markerExists = await fileExists(folderKey);
+    const markerExists = await fileExists(folderKey, bucketName);
     if (markerExists) return res.status(409).json({ success: false, error: 'Folder already exists' });
 
     // Check if any files already exist under this prefix (folder already has content)
-    const existingFiles = await listfiles(folderKey, { maxKeys: 1 });
+    const existingFiles = await listfiles(folderKey, { maxKeys: 1, bucketName });
     const hasContent = existingFiles.Contents && existingFiles.Contents.length > 0;
 
     if (hasContent) {
@@ -422,23 +470,25 @@ router.post('/create-folder', validateSessionAndRole('SuperAdmin'), async (req,
 
     // Create zero-byte object to represent empty folder
     await uploadFile(folderKey, Buffer.alloc(0), 'application/x-empty', {
-      metadata: { 'folder': 'true', 'marker': 'true' }
+      metadata: { 'folder': 'true', 'marker': 'true' },
+      bucketName
     });
 
     return res.json({ success: true, message: 'Folder created', key: folderKey });
   } catch (err) {
     console.error('Create folder failed:', err);
-    return res.status(500).json({ success: false, error: err.message });
+    return sendApiError(res, err, 'Create folder failed');
   }
 });
 
 router.post('/delete', validateSessionAndRole('SuperAdmin'), async (req, res) => {
   try {
+    const bucketName = req.activeBucket;
     const { key, keys, folder } = req.body;
 
     if (keys && Array.isArray(keys) && keys.length) {
       // Bulk delete
-      await deleteFiles(keys);
+      await deleteFiles(keys, bucketName);
       return res.json({ success: true, message: 'Files deleted successfully' });
     }
 
@@ -449,21 +499,22 @@ router.post('/delete', validateSessionAndRole('SuperAdmin'), async (req, res) =>
 
     // If caller indicates it's a folder (or key ends with '/'), delete all objects under the prefix
     if (folder === true || String(keyToDelete).endsWith('/')) {
-      await deleteFolder(keyToDelete);
+      await deleteFolder(keyToDelete, bucketName);
       return res.json({ success: true, message: 'Folder deleted successfully' });
     }
 
-    await deleteFile(keyToDelete);
+    await deleteFile(keyToDelete, bucketName);
     res.json({ success: true, message: 'File deleted successfully' });
   } catch (error) {
     console.error("Error deleting file:", error);
-    res.status(500).json({ success: false, error: `Delete failed: ${error.message}` });
+    return sendApiError(res, error, 'Delete failed');
   }
 });
 
 router.get('/download/:key(*)', validateSessionAndRole('SuperAdmin'), async (req, res) => {
   let stream = null;
   try {
+    const bucketName = req.activeBucket;
     const key = req.params.key;
     let keyToUse;
     try {
@@ -471,19 +522,37 @@ router.get('/download/:key(*)', validateSessionAndRole('SuperAdmin'), async (req
     } catch (e) {
       return res.status(400).json({ success: false, error: e.message });
     }
-    const result = await downloadFile(keyToUse);
+    const result = await downloadFile(keyToUse, { bucketName });
     stream = result.Body;
 
     res.setHeader('Content-Disposition', `attachment; filename="${keyToUse.split('/').pop()}"`);
-    res.setHeader('Content-Type', result.ContentType || 'application/octet-stream');
+    const contentType = result.ContentType || 'application/octet-stream';
+    res.setHeader('Content-Type', contentType);
 
     // Set Content-Length header for proper download progress indication
     if (result.ContentLength) {
       res.setHeader('Content-Length', result.ContentLength);
     }
 
-    // Add cache headers for downloads
-    res.setHeader('Cache-Control', 'private, max-age=3600');
+    if (result.ETag) res.setHeader('ETag', result.ETag);
+    if (result.LastModified) res.setHeader('Last-Modified', result.LastModified.toUTCString());
+
+    const typeLower = String(contentType).toLowerCase();
+    const isSensitiveText = typeLower.startsWith('text/')
+      || typeLower.includes('json')
+      || typeLower.includes('xml')
+      || typeLower.includes('javascript')
+      || typeLower.includes('typescript');
+    const isLargeFile = Number(result.ContentLength || 0) > 50 * 1024 * 1024;
+
+    // Smarter cache policy for authenticated downloads.
+    if (isSensitiveText) {
+      res.setHeader('Cache-Control', 'private, no-store');
+    } else if (isLargeFile) {
+      res.setHeader('Cache-Control', 'private, max-age=600, must-revalidate');
+    } else {
+      res.setHeader('Cache-Control', 'private, max-age=1800, must-revalidate');
+    }
 
     // Proper stream error handling
     stream.on('error', (err) => {

package/lib/routes/index.js

@@ -3,13 +3,82 @@ import infoRoutes from "./info.js";
 import viewRoutes from "./view.js";
 import apiRoutes from "./api.js";
 import { validateSessionAndRole, renderPage, mbkautheVar } from "mbkauthe";
+import { resolveBucketName, getAvailableBucketNames } from "../s3.js";
 
 const router = express.Router();
 
+function renderBucketDashboard(req, res) {
+  const allBuckets = getAvailableBucketNames();
+  const configuredDefaultBucket = mbkautheVar?.bucket;
+
+  let bucketfilePath;
+
+  if(mbkautheVar?.APP_NAME === "portal") {
+    bucketfilePath ="bucketportal.handlebars";
+  } else {
+    bucketfilePath = "bucket.handlebars";
+  }
+
+
+  let selectedBucket;
+
+  try {
+    selectedBucket = resolveBucketName(req.query.bucket);
+  } catch (err) {
+    const fallbackSelected = mbkautheVar?.bucket;
+    const bucketOptions = allBuckets.map((name) => ({
+      name,
+      isSelected: name === fallbackSelected,
+      isDefault: name === configuredDefaultBucket
+    }));
+    return renderPage(req, res, bucketfilePath, mbkautheVar?.APP_NAME === "portal" ? true : false, {
+      page: "Admin Bucket",
+      layout: true,
+      bucketvar: mbkautheVar?.bucket,
+      selectedBucket: fallbackSelected,
+      bucketOptions,
+      APP_NAME: mbkautheVar?.APP_NAME,
+      message: req.query.message,
+      error: req.query.error || err.message,
+      availableBuckets: allBuckets
+    });
+  }
+
+  const bucketOptions = allBuckets.map((name) => ({
+    name,
+    isSelected: name === selectedBucket,
+    isDefault: name === configuredDefaultBucket
+  }));
+
+  renderPage(req, res, bucketfilePath, mbkautheVar?.APP_NAME === "portal" ? true : false, {
+    page: "Admin Bucket",
+    bucketvar: selectedBucket,
+    selectedBucket,
+    bucketOptions,
+    APP_NAME: mbkautheVar?.APP_NAME,
+    message: req.query.message,
+    error: req.query.error,
+    availableBuckets: allBuckets
+  });
+}
+
 router.get('/mbkbucket', validateSessionAndRole('SuperAdmin'), async (req, res) => {
-  renderPage(req, res, "bucket.handlebars", false, { page: "Admin Bucket", bucketvar: mbkautheVar?.bucket, APP_NAME: mbkautheVar?.APP_NAME, message: req.query.message, error: req.query.error });
+  return renderBucketDashboard(req, res);
 });
 
+// Central bucket resolution for all /mbkbucket subroutes.
+router.use('/mbkbucket', (req, _res, next) => {
+  try {
+    req.activeBucket = resolveBucketName(req.query.bucket);
+    req.bucketResolveError = null;
+  } catch (err) {
+    req.activeBucket = null;
+    req.bucketResolveError = err;
+  }
+  next();
+});
+
+
 router.use("/mbkbucket", infoRoutes);
 router.use("/mbkbucket", viewRoutes);
 router.use("/mbkbucket", apiRoutes);