mbkbucket 3.8.2 → 4.0.0

package/lib/src/core/storage/storage-manager.js

@@ -0,0 +1,203 @@
+/**
+ * MBKBucket - Storage Manager & Provider Registry
+ * Copyright (c) 2026 Muhammad Bin Khalid, MBKTech.org and contributors
+ * Licensed under the MIT License.
+ */
+
+import dotenv from "dotenv";
+import { mbkautheVar } from "mbkauthe";
+import { S3StorageProvider } from "./s3-provider.js";
+import { GoogleDriveStorageProvider } from "./gdrive-provider.js";
+import { StorageConfigError, StorageValidationError } from "./errors.js";
+import { createLogger } from "#logger";
+
+dotenv.config();
+const debugStorage = createLogger('storage-manager');
+
+function parseJsonEnv(envVar, fallback = {}) {
+  if (!envVar) return fallback;
+  try {
+    return JSON.parse(envVar);
+  } catch (e) {
+    console.error(`❌ Error parsing JSON for envVar: ${String(envVar).slice(0, 200)} - ${e.message}`);
+    return fallback;
+  }
+}
+
+export class StorageManager {
+  constructor() {
+    this._providers = new Map();
+    this._factories = new Map();
+    this._configs = new Map();
+
+    // Register built-in provider drivers
+    this.registerDriver('s3', (name, cfg) => new S3StorageProvider(name, cfg));
+    this.registerDriver('r2', (name, cfg) => new S3StorageProvider(name, cfg));
+    this.registerDriver('minio', (name, cfg) => new S3StorageProvider(name, cfg));
+    this.registerDriver('gdrive', (name, cfg) => new GoogleDriveStorageProvider(name, cfg));
+    this.registerDriver('google-drive', (name, cfg) => new GoogleDriveStorageProvider(name, cfg));
+    this.registerDriver('googledrive', (name, cfg) => new GoogleDriveStorageProvider(name, cfg));
+
+    this.reloadFromEnv();
+  }
+
+  /**
+   * Register a custom provider driver.
+   * @param {string} type
+   * @param {(name: string, config: object) => import('./storage-provider.js').StorageProvider} factory
+   */
+  registerDriver(type, factory) {
+    this._factories.set(String(type).toLowerCase(), factory);
+  }
+
+  registerProviderFactory(type, factory) {
+    this.registerDriver(type, factory);
+  }
+
+  /**
+   * Reload all connections from environment variables.
+   */
+  reloadFromEnv() {
+    this._providers.clear();
+    this._configs.clear();
+
+    const envSource = process.env.StorageConnection || process.env.BucketConnection;
+    const rawConfigs = parseJsonEnv(envSource, {});
+
+    for (const [name, config] of Object.entries(rawConfigs)) {
+      if (config && typeof config === 'object' && !Array.isArray(config)) {
+        this.registerConnection(name, config);
+      }
+    }
+  }
+
+  /**
+   * Register a named storage connection.
+   * @param {string} name
+   * @param {object} config
+   */
+  registerConnection(name, config) {
+    const cleanName = String(name).trim();
+    if (!cleanName) throw new StorageValidationError("Connection name cannot be empty");
+    this._configs.set(cleanName, Object.freeze({ ...config }));
+    this._providers.delete(cleanName);
+  }
+
+  /**
+   * Get all registered connection names.
+   * @returns {string[]}
+   */
+  getAvailableConnectionNames() {
+    return Array.from(this._configs.keys());
+  }
+
+  /**
+   * Get the default connection name.
+   * @returns {string|null}
+   */
+  getDefaultConnectionName() {
+    const configuredDefault = mbkautheVar?.bucket;
+    if (configuredDefault && this._configs.has(configuredDefault)) {
+      return configuredDefault;
+    }
+    const available = this.getAvailableConnectionNames();
+    return available.length > 0 ? available[0] : null;
+  }
+
+  /**
+   * Resolve a candidate connection name or fall back to default.
+   * @param {string} [name]
+   * @returns {string}
+   */
+  resolveConnectionName(name) {
+    const raw = typeof name === 'string' ? name.trim() : name;
+    const candidate = !raw ? this.getDefaultConnectionName() : String(raw);
+
+    const available = this.getAvailableConnectionNames();
+    if (!candidate) {
+      throw new StorageValidationError('No storage connection selected. Provide ?bucket=<name> or configure a default bucket in mbkautheVar.bucket.');
+    }
+    if (available.length === 0) {
+      throw new StorageConfigError('BucketConnection environment variable is not set or empty. Please configure it with your storage connections.');
+    }
+    if (!this._configs.has(candidate)) {
+      throw new StorageValidationError(`Storage connection '${candidate}' not found in BucketConnection. Available connections: ${available.join(', ')}`);
+    }
+    return candidate;
+  }
+
+  /**
+   * Get connection configuration object.
+   * @param {string} [name]
+   * @returns {object}
+   */
+  getConnectionConfig(name) {
+    const resolved = this.resolveConnectionName(name);
+    return this._configs.get(resolved);
+  }
+
+  /**
+   * Determine the provider type from configuration.
+   * @param {object} config
+   * @returns {string}
+   */
+  inferProviderType(config = {}) {
+    if (config?.type) return String(config.type).toLowerCase();
+    if (config?.provider) return String(config.provider).toLowerCase();
+    if (config?.client_id || config?.refresh_token || config?.service_account_key || config?.folder_id || config?.service_account_email) {
+      return 'gdrive';
+    }
+    return 's3';
+  }
+
+  /**
+   * Get or instantiate the StorageProvider for a connection.
+   * @param {string} [name]
+   * @returns {import('./storage-provider.js').StorageProvider}
+   */
+  getProvider(name) {
+    const resolved = this.resolveConnectionName(name);
+    if (this._providers.has(resolved)) {
+      return this._providers.get(resolved);
+    }
+
+    const config = this.getConnectionConfig(resolved);
+    const providerType = this.inferProviderType(config);
+    const factory = this._factories.get(providerType);
+
+    if (!factory) {
+      throw new StorageConfigError(`Unsupported storage provider type '${providerType}' for connection '${resolved}'. Registered drivers: ${Array.from(this._factories.keys()).join(', ')}`);
+    }
+
+    debugStorage('Instantiating provider "%s" (type: %s)', resolved, providerType);
+    const provider = factory(resolved, config);
+    this._providers.set(resolved, provider);
+    return provider;
+  }
+
+  /**
+   * Check health of the default or specified connection.
+   * @param {string} [name]
+   * @returns {Promise<object>}
+   */
+  async checkHealth(name) {
+    try {
+      const provider = this.getProvider(name);
+      return await provider.checkHealth();
+    } catch (error) {
+      let bucket = 'unknown';
+      try {
+        const resolved = this.resolveConnectionName(name);
+        bucket = this.getConnectionConfig(resolved)?.BUCKET_NAME || resolved;
+      } catch {}
+      return {
+        status: 'unhealthy',
+        error: error.message,
+        bucket,
+        checkedAt: new Date().toISOString()
+      };
+    }
+  }
+}
+
+export const storageManager = new StorageManager();

package/lib/src/core/storage/storage-provider.js

@@ -0,0 +1,217 @@
+/**
+ * MBKBucket - Core Storage Provider Interface
+ * Copyright (c) 2026 Muhammad Bin Khalid, MBKTech.org and contributors
+ * Licensed under the MIT License.
+ */
+
+import { StorageUnsupportedOperationError } from "./errors.js";
+
+/**
+ * Abstract base class for storage providers (S3, Cloudflare R2, Google Drive, Azure, etc.)
+ */
+export class StorageProvider {
+  /**
+   * @param {string} name - Connection/Bucket name identifier
+   * @param {object} config - Provider-specific configuration
+   */
+  constructor(name, config = {}) {
+    if (new.target === StorageProvider) {
+      throw new TypeError("Cannot construct StorageProvider instances directly");
+    }
+    this.name = name;
+    this.config = Object.freeze({ ...config });
+  }
+
+  /**
+   * Provider type identifier (e.g. 's3', 'gdrive', 'r2')
+   * @returns {string}
+   */
+  get type() {
+    return 'generic';
+  }
+
+  /**
+   * Explicit provider capabilities.
+   * @returns {object}
+   */
+  get capabilities() {
+    return {
+      multipart: false,
+      presignedUrls: false,
+      nativeFolders: false,
+      ranges: true,
+      copy: false,
+      move: false,
+      search: false,
+      directDownloadUrl: false
+    };
+  }
+
+  /**
+   * List files and folders at the given prefix/path.
+   * @param {string} [prefix='']
+   * @param {object} [options={}]
+   * @returns {Promise<import('./models.js').StorageListResult>}
+   */
+  async listFiles(prefix = '', options = {}) {
+    throw new StorageUnsupportedOperationError(`listFiles() not implemented by ${this.constructor.name}`);
+  }
+
+  /**
+   * Upload a file.
+   * @param {string} key
+   * @param {Buffer|Uint8Array|import('node:stream').Readable} fileBuffer
+   * @param {string} contentType
+   * @param {object} [options={}]
+   * @returns {Promise<{ key: string, fileSize: number, contentType: string, uploadedAt: string, [key: string]: any }>}
+   */
+  async uploadFile(key, fileBuffer, contentType, options = {}) {
+    throw new StorageUnsupportedOperationError(`uploadFile() not implemented by ${this.constructor.name}`);
+  }
+
+  /**
+   * Download a file.
+   * @param {string} key
+   * @param {object} [options={}]
+   * @returns {Promise<{ Body: import('node:stream').Readable, ContentType?: string, ContentLength?: number, ETag?: string, LastModified?: Date, notModified?: boolean, key: string }>}
+   */
+  async downloadFile(key, options = {}) {
+    throw new StorageUnsupportedOperationError(`downloadFile() not implemented by ${this.constructor.name}`);
+  }
+
+  /**
+   * Delete a single file.
+   * @param {string} key
+   * @param {object} [options={}]
+   * @returns {Promise<{ key: string, deletedAt: string, [key: string]: any }>}
+   */
+  async deleteFile(key, options = {}) {
+    throw new StorageUnsupportedOperationError(`deleteFile() not implemented by ${this.constructor.name}`);
+  }
+
+  /**
+   * Delete multiple files.
+   * @param {string[]} keys
+   * @param {object} [options={}]
+   * @returns {Promise<{ results: any[], deletedCount: number, errors: any[], deletedAt: string }>}
+   */
+  async deleteFiles(keys, options = {}) {
+    let deletedCount = 0;
+    const errors = [];
+    const results = [];
+    for (const key of keys) {
+      try {
+        const res = await this.deleteFile(key, options);
+        results.push(res);
+        deletedCount++;
+      } catch (err) {
+        errors.push({ key, error: err.message });
+      }
+    }
+    return { results, deletedCount, errors, deletedAt: new Date().toISOString() };
+  }
+
+  /**
+   * Delete a folder and its contents.
+   * @param {string} prefix
+   * @param {object} [options={}]
+   * @returns {Promise<{ deletedCount: number, prefix: string, deletedAt: string }>}
+   */
+  async deleteFolder(prefix, options = {}) {
+    throw new StorageUnsupportedOperationError(`deleteFolder() not implemented by ${this.constructor.name}`);
+  }
+
+  /**
+   * Create a folder.
+   * @param {string} key
+   * @param {object} [options={}]
+   * @returns {Promise<{ key: string, success: boolean, [key: string]: any }>}
+   */
+  async createFolder(key, options = {}) {
+    throw new StorageUnsupportedOperationError(`createFolder() not implemented by ${this.constructor.name}`);
+  }
+
+  /**
+   * Get file metadata.
+   * @param {string} key
+   * @param {object} [options={}]
+   * @returns {Promise<{ key: string, exists: boolean, ContentLength?: number, ContentType?: string, LastModified?: Date, ETag?: string, Metadata?: object, queriedAt: string }>}
+   */
+  async getFileMetadata(key, options = {}) {
+    throw new StorageUnsupportedOperationError(`getFileMetadata() not implemented by ${this.constructor.name}`);
+  }
+
+  /**
+   * Check if a file exists.
+   * @param {string} key
+   * @param {object} [options={}]
+   * @returns {Promise<boolean>}
+   */
+  async fileExists(key, options = {}) {
+    try {
+      const meta = await this.getFileMetadata(key, options);
+      return Boolean(meta?.exists);
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get file size in bytes.
+   * @param {string} key
+   * @param {object} [options={}]
+   * @returns {Promise<number|null>}
+   */
+  async getFileSize(key, options = {}) {
+    try {
+      const meta = await this.getFileMetadata(key, options);
+      return meta?.exists ? (meta.ContentLength ?? null) : null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Generate a signed or temporary access URL if supported.
+   * @param {string} key
+   * @param {'getObject'|'putObject'} [operation='getObject']
+   * @param {number} [expiresIn=3600]
+   * @param {object} [options={}]
+   * @returns {Promise<{ url: string, key: string, operation: string, expiresIn: number, expiresAt: string, generatedAt: string }>}
+   */
+  async generateSignedUrl(key, operation = 'getObject', expiresIn = 3600, options = {}) {
+    throw new StorageUnsupportedOperationError(`generateSignedUrl() is not supported by provider ${this.type}`);
+  }
+
+  /**
+   * Copy a file.
+   * @param {string} sourceKey
+   * @param {string} destKey
+   * @param {object} [options={}]
+   * @returns {Promise<{ sourceKey: string, destKey: string, copiedAt: string }>}
+   */
+  async copyFile(sourceKey, destKey, options = {}) {
+    throw new StorageUnsupportedOperationError(`copyFile() is not supported by provider ${this.type}`);
+  }
+
+  /**
+   * Move a file.
+   * @param {string} sourceKey
+   * @param {string} destKey
+   * @param {object} [options={}]
+   * @returns {Promise<{ sourceKey: string, destKey: string, movedAt: string }>}
+   */
+  async moveFile(sourceKey, destKey, options = {}) {
+    await this.copyFile(sourceKey, destKey, options);
+    await this.deleteFile(sourceKey, options);
+    return { sourceKey, destKey, movedAt: new Date().toISOString() };
+  }
+
+  /**
+   * Run health check.
+   * @returns {Promise<{ status: 'healthy'|'unhealthy', responseTime?: number, error?: string, [key: string]: any }>}
+   */
+  async checkHealth() {
+    throw new StorageUnsupportedOperationError(`checkHealth() not implemented by ${this.constructor.name}`);
+  }
+}

package/lib/src/middleware/bucket-resolver.js

@@ -1,37 +1,37 @@
-import { resolveBucketName } from "../services/s3.service.js";
-import { sendApiError, sendViewError } from "../utils/errors.js";
-
-const NO_BUCKET_MSG = 'No bucket selected. Provide ?bucket=<name> or configure a default bucket in mbkautheVar.bucket.';
-
-/**
- * Resolves `?bucket=<name>` query param and attaches `req.activeBucket` and `req.bucketResolveError`.
- */
-export function bucketResolver(req, _res, next) {
-  try {
-    req.activeBucket = resolveBucketName(req.query.bucket);
-    req.bucketResolveError = null;
-  } catch (err) {
-    req.activeBucket = null;
-    req.bucketResolveError = err;
-  }
-  next();
-}
-
-/**
- * Guard middleware for API routes — returns 400/503 JSON if bucket is invalid.
- */
-export function requireBucketApi(req, res, next) {
-  if (req.bucketResolveError) return sendApiError(res, req.bucketResolveError, 'Invalid bucket selection');
-  if (!req.activeBucket) return sendApiError(res, new Error(NO_BUCKET_MSG));
-  next();
-}
-
-/**
- * Guard middleware for view routes — returns 400/503 JSON if bucket is invalid (skips /p_view/...).
- */
-export function requireBucketView(req, res, next) {
-  if (req.path.startsWith('/p_view/')) return next();
-  if (req.bucketResolveError) return sendViewError(res, req.bucketResolveError, 'Invalid bucket selection');
-  if (!req.activeBucket) return sendViewError(res, new Error(NO_BUCKET_MSG));
-  next();
-}
+import { resolveStorageName } from "../services/storage.service.js";
+import { sendApiError, sendViewError } from "../utils/errors.js";
+
+const NO_BUCKET_MSG = 'No storage connection selected. Provide ?bucket=<name> or configure a default bucket in mbkautheVar.bucket.';
+
+/**
+ * Resolves `?bucket=<name>` query param and attaches `req.activeBucket` and `req.bucketResolveError`.
+ */
+export function bucketResolver(req, _res, next) {
+  try {
+    req.activeBucket = resolveStorageName(req.query.bucket);
+    req.bucketResolveError = null;
+  } catch (err) {
+    req.activeBucket = null;
+    req.bucketResolveError = err;
+  }
+  next();
+}
+
+/**
+ * Guard middleware for API routes — returns 400/503 JSON if bucket is invalid.
+ */
+export function requireBucketApi(req, res, next) {
+  if (req.bucketResolveError) return sendApiError(res, req.bucketResolveError, 'Invalid storage connection');
+  if (!req.activeBucket) return sendApiError(res, new Error(NO_BUCKET_MSG));
+  next();
+}
+
+/**
+ * Guard middleware for view routes — returns 400/503 JSON if bucket is invalid (skips /p_view/...).
+ */
+export function requireBucketView(req, res, next) {
+  if (req.path.includes('/p_view/') || req.url.startsWith('/p_view/') || req.originalUrl?.includes('/p_view/')) return next();
+  if (req.bucketResolveError) return sendViewError(res, req.bucketResolveError, 'Invalid storage connection');
+  if (!req.activeBucket) return sendViewError(res, new Error(NO_BUCKET_MSG));
+  next();
+}

package/lib/src/routes/api.routes.js

@@ -2,7 +2,7 @@ import express from "express";
 import { sessRole } from "mbkauthe";
 import multer from "multer";
 import { requireBucketApi } from "../middleware/bucket-resolver.js";
-import { cleanupUploads, listIncompleteUploads, listFiles, uploadSingleFile, initiateMultipartUpload, uploadChunk, completeUpload, abortUpload, createFolder, deleteItems, downloadFileHandler } from "../controllers/api.controller.js";
+import { cleanupUploads, listIncompleteUploads, listFiles, uploadSingleFile, initiateMultipartUpload, uploadChunk, completeUpload, abortUpload, createFolder, deleteItems, downloadFileHandler, moveItem, copyItem, getHealthStatus, getFileInfo } from "../controllers/api.controller.js";
 
 const MAX_CHUNK_SIZE = 50 * 1024 * 1024; // 50 MB
 const upload = multer({ storage: multer.memoryStorage(), limits: { fileSize: MAX_CHUNK_SIZE } });
@@ -36,6 +36,8 @@ export function createApiRoutes({
   apiRouter.post('/api/cleanup-uploads', deleteAuth, cleanupUploads);
   apiRouter.get('/api/incomplete-uploads', viewAuth, listIncompleteUploads);
   apiRouter.get('/api/files', viewAuth, listFiles);
+  apiRouter.get('/api/health', viewAuth, getHealthStatus);
+  apiRouter.get('/api/file-info/*key', viewAuth, getFileInfo);
   apiRouter.post('/upload', uploadAuth, upload.single('file'), uploadSingleFile);
   apiRouter.post('/upload-init', uploadAuth, initiateMultipartUpload);
   apiRouter.post('/upload-chunk', uploadAuth, uploadChunkMiddleware, uploadChunk);
@@ -43,6 +45,8 @@ export function createApiRoutes({
   apiRouter.post('/upload-abort', deleteAuth, abortUpload);
   apiRouter.post('/create-folder', uploadAuth, createFolder);
   apiRouter.post('/delete', deleteAuth, deleteItems);
+  apiRouter.post('/move', uploadAuth, moveItem);
+  apiRouter.post('/copy', uploadAuth, copyItem);
   apiRouter.get('/download/*key', viewAuth, downloadFileHandler);
 
   return apiRouter;

package/lib/src/routes/index.js

@@ -1,60 +1,60 @@
-/**
- * MBKBucket
- * Copyright (c) 2026 Muhammad Bin Khalid, MBKTech.org and contributors
- * Licensed under the MIT License.
- * Source: https://github.com/MIbnEKhalid/mbkbucket
- */
-
-import express from "express";
-import { sessRole } from "mbkauthe";
-import path from "path";
-import { fileURLToPath } from "url";
-import { bucketResolver } from "../middleware/bucket-resolver.js";
-import { renderBucketDashboard } from "../controllers/dashboard.controller.js";
-import infoRoutes from "./info.routes.js";
-import { createViewRoutes } from "./view.routes.js";
-import { createApiRoutes } from "./api.routes.js";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const publicDir = path.resolve(__dirname, "..", "..", "public");
-
-const serveAsset = (filename) => (_req, res) => {
-  res.set("Cache-Control", "public, max-age=300, must-revalidate");
-  res.sendFile(path.join(publicDir, filename), (err) => {
-    if (err) res.status(err.status || 404).end();
-  });
-};
-
-export function createBucketRouter({ authorization } = {}) {
-  const router = express.Router();
-  const defaultAuth = sessRole('superadmin');
-  const auths = typeof authorization === 'function'
-    ? { view: authorization, upload: authorization, delete: authorization }
-    : authorization ?? {};
-  const viewAuth = auths.view ?? defaultAuth;
-  const uploadAuth = auths.upload ?? defaultAuth;
-  const deleteAuth = auths.delete ?? defaultAuth;
-
-  // Static dashboard & helper assets
-  router.get('/mbkbucket/bucketadmin.css', serveAsset('bucketadmin.css'));
-  router.get('/mbkbucket/bucketadmin.js', serveAsset('bucketadmin.js'));
-  router.get('/mbkbucket/mbkbucket-helper.css', serveAsset('mbkbucket-helper.css'));
-  router.get('/mbkbucket/mbkbucket-helper.js', serveAsset('mbkbucket-helper.js'));
-  router.get('/mbkbucket/helper-demo', serveAsset('mbkbucket-helper-demo.html'));
-
-  router.get('/mbkbucket', viewAuth, renderBucketDashboard);
-  router.use(
-    '/mbkbucket',
-    bucketResolver,
-    infoRoutes,
-    createViewRoutes({ authorization: viewAuth }),
-    createApiRoutes({ viewAuthorization: viewAuth, uploadAuthorization: uploadAuth, deleteAuthorization: deleteAuth })
-  );
-
-  return router;
-}
-
-const router = createBucketRouter();
-
-export default router;
+/**
+ * MBKBucket
+ * Copyright (c) 2026 Muhammad Bin Khalid, MBKTech.org and contributors
+ * Licensed under the MIT License.
+ * Source: https://github.com/MIbnEKhalid/mbkbucket
+ */
+
+import express from "express";
+import { sessRole } from "mbkauthe";
+import path from "path";
+import { fileURLToPath } from "url";
+import { bucketResolver } from "../middleware/bucket-resolver.js";
+import { renderBucketDashboard } from "../controllers/dashboard.controller.js";
+import infoRoutes from "./info.routes.js";
+import { createViewRoutes } from "./view.routes.js";
+import { createApiRoutes } from "./api.routes.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const publicDir = path.resolve(__dirname, "..", "..", "public");
+
+const serveAsset = (filename) => (_req, res) => {
+  res.set("Cache-Control", "public, max-age=300, must-revalidate");
+  res.sendFile(path.join(publicDir, filename), (err) => {
+    if (err) res.status(err.status || 404).end();
+  });
+};
+
+export function createBucketRouter({ authorization, publiViewEnabled } = {}) {
+  const router = express.Router();
+  const defaultAuth = sessRole('superadmin');
+  const auths = typeof authorization === 'function'
+    ? { view: authorization, upload: authorization, delete: authorization }
+    : authorization ?? {};
+  const viewAuth = auths.view ?? defaultAuth;
+  const uploadAuth = auths.upload ?? defaultAuth;
+  const deleteAuth = auths.delete ?? defaultAuth;
+
+  // Static dashboard & helper assets
+  router.get('/mbkbucket/bucketadmin.css', serveAsset('bucketadmin.css'));
+  router.get('/mbkbucket/bucketadmin.js', serveAsset('bucketadmin.js'));
+  router.get('/mbkbucket/mbkbucket-helper.css', serveAsset('mbkbucket-helper.css'));
+  router.get('/mbkbucket/mbkbucket-helper.js', serveAsset('mbkbucket-helper.js'));
+  router.get('/mbkbucket/helper-demo', serveAsset('mbkbucket-helper-demo.html'));
+
+  router.get('/mbkbucket', viewAuth, renderBucketDashboard);
+  router.use(
+    '/mbkbucket',
+    bucketResolver,
+    infoRoutes,
+    createViewRoutes({ authorization: viewAuth, publiViewEnabled }),
+    createApiRoutes({ viewAuthorization: viewAuth, uploadAuthorization: uploadAuth, deleteAuthorization: deleteAuth })
+  );
+
+  return router;
+}
+
+const router = createBucketRouter();
+
+export default router;