digitaltwin-core 0.9.1 → 0.10.0

package/dist/components/assets_manager.js

@@ -1,5 +1,7 @@
 import { ApisixAuthParser } from '../auth/apisix_parser.js';
 import { UserService } from '../auth/user_service.js';
+import { AuthConfig } from '../auth/auth_config.js';
+import { successResponse, errorResponse, badRequestResponse, unauthorizedResponse, forbiddenResponse, notFoundResponse, textResponse, fileResponse, multiStatusResponse, HttpStatus } from '../utils/http_responses.js';
 import fs from 'fs/promises';
 /**
  * Abstract base class for Assets Manager components with authentication and access control.
@@ -65,17 +67,23 @@ export class AssetsManager {
      *
      * @param {DatabaseAdapter} db - The database adapter for metadata storage
      * @param {StorageService} storage - The storage service for file persistence
+     * @param {UserService} [userService] - Optional user service for authentication (created automatically if not provided)
      *
      * @example
      * ```typescript
+     * // Standard usage (UserService created automatically)
      * const assetsManager = new MyAssetsManager()
      * assetsManager.setDependencies(databaseAdapter, storageService)
+     *
+     * // For testing (inject mock UserService)
+     * const mockUserService = new MockUserService()
+     * assetsManager.setDependencies(databaseAdapter, storageService, mockUserService)
      * ```
      */
-    setDependencies(db, storage) {
+    setDependencies(db, storage, userService) {
         this.db = db;
         this.storage = storage;
-        this.userService = new UserService(db);
+        this.userService = userService ?? new UserService(db);
     }
     /**
      * Validates that a source string is a valid URL.
@@ -177,6 +185,208 @@ export class AssetsManager {
             return false;
         }
     }
+    // ============================================================================
+    // Authentication & Request Processing Helpers
+    // ============================================================================
+    /**
+     * Authenticates a request and returns the user record.
+     *
+     * This method consolidates the authentication flow:
+     * 1. Validates APISIX headers are present
+     * 2. Parses authentication headers
+     * 3. Finds or creates user record in database
+     *
+     * @param req - HTTP request object
+     * @returns AuthResult with either userRecord on success or DataResponse on failure
+     *
+     * @example
+     * ```typescript
+     * const authResult = await this.authenticateRequest(req)
+     * if (!authResult.success) {
+     *     return authResult.response
+     * }
+     * const userRecord = authResult.userRecord
+     * ```
+     */
+    async authenticateRequest(req) {
+        // If auth is disabled, create an anonymous user
+        if (AuthConfig.isAuthDisabled()) {
+            const anonymousUser = {
+                id: AuthConfig.getAnonymousUserId(),
+                roles: []
+            };
+            const userRecord = await this.userService.findOrCreateUser(anonymousUser);
+            return { success: true, userRecord };
+        }
+        if (!ApisixAuthParser.hasValidAuth(req.headers || {})) {
+            return { success: false, response: unauthorizedResponse() };
+        }
+        const authUser = ApisixAuthParser.parseAuthHeaders(req.headers || {});
+        if (!authUser) {
+            return { success: false, response: unauthorizedResponse('Invalid authentication headers') };
+        }
+        const userRecord = await this.userService.findOrCreateUser(authUser);
+        if (!userRecord.id) {
+            return { success: false, response: errorResponse('Failed to retrieve user information') };
+        }
+        return { success: true, userRecord };
+    }
+    /**
+     * Extracts upload data from multipart form request.
+     *
+     * @param req - HTTP request object with body and file
+     * @returns UploadData object with extracted fields
+     */
+    extractUploadData(req) {
+        return {
+            description: req.body?.description,
+            source: req.body?.source,
+            is_public: req.body?.is_public,
+            filePath: req.file?.path,
+            fileBuffer: req.file?.buffer,
+            filename: req.file?.originalname || req.body?.filename
+        };
+    }
+    /**
+     * Validates required fields for asset upload and returns validated data.
+     *
+     * @param data - Upload data to validate
+     * @returns UploadValidationResult with validated data on success or error response on failure
+     */
+    validateUploadFields(data) {
+        const hasFile = data.filePath || data.fileBuffer;
+        if (!hasFile || !data.description || !data.source) {
+            return {
+                success: false,
+                response: badRequestResponse('Missing required fields: description, source, file')
+            };
+        }
+        if (!data.filename) {
+            return {
+                success: false,
+                response: badRequestResponse('Filename could not be determined from uploaded file')
+            };
+        }
+        if (!this.validateFileExtension(data.filename)) {
+            const config = this.getConfiguration();
+            return {
+                success: false,
+                response: badRequestResponse(`Invalid file extension. Expected: ${config.extension}`)
+            };
+        }
+        return {
+            success: true,
+            data: {
+                description: data.description,
+                source: data.source,
+                filePath: data.filePath,
+                fileBuffer: data.fileBuffer,
+                filename: data.filename,
+                is_public: data.is_public !== undefined ? Boolean(data.is_public) : true
+            }
+        };
+    }
+    /**
+     * Reads file content from temporary upload path.
+     *
+     * @param filePath - Path to temporary file
+     * @returns Buffer with file content
+     * @throws Error if file cannot be read
+     */
+    async readTempFile(filePath) {
+        return fs.readFile(filePath);
+    }
+    /**
+     * Cleans up temporary file after processing.
+     * Silently ignores cleanup errors.
+     *
+     * @param filePath - Path to temporary file
+     */
+    async cleanupTempFile(filePath) {
+        await fs.unlink(filePath).catch(() => {
+            // Ignore cleanup errors
+        });
+    }
+    /**
+     * Validates ownership of an asset.
+     *
+     * @param asset - Asset record to check
+     * @param userId - User ID to validate against
+     * @returns DataResponse with error if not owner, undefined if valid
+     */
+    validateOwnership(asset, userId) {
+        // Assets with no owner (null) can be modified by anyone
+        if (asset.owner_id === null) {
+            return undefined;
+        }
+        if (asset.owner_id !== userId) {
+            return forbiddenResponse('You can only modify your own assets');
+        }
+        return undefined;
+    }
+    /**
+     * Checks if a user can access a private asset.
+     *
+     * @param asset - Asset record to check
+     * @param req - HTTP request for authentication context
+     * @returns DataResponse with error if access denied, undefined if allowed
+     */
+    async checkPrivateAssetAccess(asset, req) {
+        // Public assets are always accessible
+        if (asset.is_public) {
+            return undefined;
+        }
+        // Admins can access everything
+        if (ApisixAuthParser.isAdmin(req.headers || {})) {
+            return undefined;
+        }
+        // Private asset - require authentication
+        if (!ApisixAuthParser.hasValidAuth(req.headers || {})) {
+            return unauthorizedResponse('Authentication required for private assets');
+        }
+        const authUser = ApisixAuthParser.parseAuthHeaders(req.headers || {});
+        if (!authUser) {
+            return unauthorizedResponse('Invalid authentication headers');
+        }
+        const userRecord = await this.userService.findOrCreateUser(authUser);
+        if (!userRecord.id || asset.owner_id !== userRecord.id) {
+            return forbiddenResponse('This asset is private');
+        }
+        return undefined;
+    }
+    /**
+     * Fetches an asset by ID with full access control validation.
+     *
+     * This method consolidates the common logic for retrieving an asset:
+     * 1. Validates that ID is provided
+     * 2. Fetches the asset from database
+     * 3. Verifies the asset belongs to this component
+     * 4. Checks access permissions for private assets
+     *
+     * @param req - HTTP request with params.id
+     * @returns Object with asset on success, or DataResponse on failure
+     */
+    async fetchAssetWithAccessCheck(req) {
+        const { id } = req.params || {};
+        if (!id) {
+            return { success: false, response: badRequestResponse('Asset ID is required') };
+        }
+        const asset = await this.getAssetById(id);
+        if (!asset) {
+            return { success: false, response: textResponse(HttpStatus.NOT_FOUND, 'Asset not found') };
+        }
+        // Verify this asset belongs to our component
+        const config = this.getConfiguration();
+        if (asset.name !== config.name) {
+            return { success: false, response: textResponse(HttpStatus.NOT_FOUND, 'Asset not found') };
+        }
+        // Check access permissions for private assets
+        const accessError = await this.checkPrivateAssetAccess(asset, req);
+        if (accessError) {
+            return { success: false, response: accessError };
+        }
+        return { success: true, asset };
+    }
     /**
      * Upload a new asset file with metadata.
      *
@@ -240,80 +450,59 @@ export class AssetsManager {
     async retrieve(req) {
         try {
             const assets = await this.getAllAssets();
-            const config = this.getConfiguration();
-            // Check if user is admin (admins can see everything)
             const isAdmin = req && ApisixAuthParser.isAdmin(req.headers || {});
-            // If admin, skip filtering and return all assets
+            // Admin can see everything
             if (isAdmin) {
-                const assetsWithMetadata = assets.map(asset => ({
-                    id: asset.id,
-                    name: asset.name,
-                    date: asset.date,
-                    contentType: asset.contentType,
-                    description: asset.description || '',
-                    source: asset.source || '',
-                    owner_id: asset.owner_id || null,
-                    filename: asset.filename || '',
-                    is_public: asset.is_public ?? true,
-                    url: `/${config.name}/${asset.id}`,
-                    download_url: `/${config.name}/${asset.id}/download`
-                }));
-                return {
-                    status: 200,
-                    content: JSON.stringify(assetsWithMetadata),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+                return successResponse(this.formatAssetsForResponse(assets));
             }
-            // For non-admin users, check authentication and ownership
-            let authenticatedUserId = null;
-            if (req && ApisixAuthParser.hasValidAuth(req.headers || {})) {
-                const authUser = ApisixAuthParser.parseAuthHeaders(req.headers || {});
-                if (authUser) {
-                    const userRecord = await this.userService.findOrCreateUser(authUser);
-                    authenticatedUserId = userRecord.id || null;
-                }
-            }
-            // Filter assets based on visibility and ownership
-            const visibleAssets = assets.filter(asset => {
-                // Public assets are visible to everyone
-                if (asset.is_public) {
-                    return true;
-                }
-                // Private assets are only visible to the owner
-                return authenticatedUserId !== null && asset.owner_id === authenticatedUserId;
-            });
-            // Transform to include asset metadata and user-friendly URLs
-            // Note: assets are already sorted by date desc from DB query
-            const assetsWithMetadata = visibleAssets.map(asset => ({
-                id: asset.id,
-                name: asset.name,
-                date: asset.date,
-                contentType: asset.contentType,
-                // Asset-specific metadata (from DB columns)
-                description: asset.description || '',
-                source: asset.source || '',
-                owner_id: asset.owner_id || null,
-                filename: asset.filename || '',
-                is_public: asset.is_public ?? true,
-                // Add URLs that the front-end can actually use
-                url: `/${config.name}/${asset.id}`, // For display/use
-                download_url: `/${config.name}/${asset.id}/download` // For download
-            }));
-            return {
-                status: 200,
-                content: JSON.stringify(assetsWithMetadata),
-                headers: { 'Content-Type': 'application/json' }
-            };
+            // Get authenticated user ID if available
+            const authenticatedUserId = await this.getAuthenticatedUserId(req);
+            // Filter to visible assets only
+            const visibleAssets = assets.filter(asset => asset.is_public || (authenticatedUserId !== null && asset.owner_id === authenticatedUserId));
+            return successResponse(this.formatAssetsForResponse(visibleAssets));
         }
         catch (error) {
-            return {
-                status: 500,
-                content: JSON.stringify({
-                    error: error instanceof Error ? error.message : 'Unknown error'
-                }),
-                headers: { 'Content-Type': 'application/json' }
-            };
+            return errorResponse(error);
+        }
+    }
+    /**
+     * Gets the authenticated user's database ID from request headers.
+     *
+     * @param req - HTTP request object
+     * @returns User ID or null if not authenticated
+     */
+    async getAuthenticatedUserId(req) {
+        if (!req || !ApisixAuthParser.hasValidAuth(req.headers || {})) {
+            return null;
+        }
+        const authUser = ApisixAuthParser.parseAuthHeaders(req.headers || {});
+        if (!authUser) {
+            return null;
         }
+        const userRecord = await this.userService.findOrCreateUser(authUser);
+        return userRecord.id || null;
+    }
+    /**
+     * Formats assets for API response with metadata and URLs.
+     *
+     * @param assets - Array of asset records
+     * @returns Formatted assets array ready for JSON serialization
+     */
+    formatAssetsForResponse(assets) {
+        const config = this.getConfiguration();
+        return assets.map(asset => ({
+            id: asset.id,
+            name: asset.name,
+            date: asset.date,
+            contentType: asset.contentType,
+            description: asset.description || '',
+            source: asset.source || '',
+            owner_id: asset.owner_id || null,
+            filename: asset.filename || '',
+            is_public: asset.is_public ?? true,
+            url: `/${config.name}/${asset.id}`,
+            download_url: `/${config.name}/${asset.id}/download`
+        }));
     }
     /**
      * Get all assets for this component type.
@@ -619,128 +808,67 @@ export class AssetsManager {
     async handleUpload(req) {
         try {
             // Validate request structure
-            if (!req || !req.body) {
-                return {
-                    status: 400,
-                    content: JSON.stringify({
-                        error: 'Invalid request: missing request body'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
-            }
-            // Step 1: Verify user is authenticated via Apache APISIX headers
-            if (!ApisixAuthParser.hasValidAuth(req.headers || {})) {
-                return {
-                    status: 401,
-                    content: JSON.stringify({
-                        error: 'Authentication required'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
-            }
-            // Step 2: Extract user identity from APISIX headers (x-user-id, x-user-roles)
-            const authUser = ApisixAuthParser.parseAuthHeaders(req.headers || {});
-            if (!authUser) {
-                return {
-                    status: 401,
-                    content: JSON.stringify({
-                        error: 'Invalid authentication headers'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+            if (!req?.body) {
+                return badRequestResponse('Invalid request: missing request body');
             }
-            // Step 3: Find or create user record in database and sync roles from Keycloak
-            const userRecord = await this.userService.findOrCreateUser(authUser);
-            if (!userRecord.id) {
-                return {
-                    status: 500,
-                    content: JSON.stringify({
-                        error: 'Failed to retrieve user information'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+            // Authenticate user
+            const authResult = await this.authenticateRequest(req);
+            if (!authResult.success) {
+                return authResult.response;
             }
-            // Step 4: Extract form data from multipart upload
-            const { description, source, is_public } = req.body;
-            const filePath = req.file?.path;
-            const filename = req.file?.originalname || req.body.filename;
-            // Step 5: Validate required fields are present
-            if (!filePath || !description || !source) {
-                return {
-                    status: 400,
-                    content: JSON.stringify({
-                        error: 'Missing required fields: description, source, file'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+            const userId = authResult.userRecord.id;
+            if (!userId) {
+                return errorResponse('Failed to retrieve user information');
             }
-            if (!filename) {
-                return {
-                    status: 400,
-                    content: JSON.stringify({
-                        error: 'Filename could not be determined from uploaded file'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+            // Extract and validate upload data
+            const uploadData = this.extractUploadData(req);
+            const validation = this.validateUploadFields(uploadData);
+            if (!validation.success) {
+                return validation.response;
             }
-            // Validate file extension early to avoid processing invalid files
-            if (!this.validateFileExtension(filename)) {
-                const config = this.getConfiguration();
-                return {
-                    status: 400,
-                    content: JSON.stringify({
-                        error: `Invalid file extension. Expected: ${config.extension}`
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
-            }
-            // Read file from temporary location
+            const validData = validation.data;
+            // Get file buffer from memory or read from temporary location
             let fileBuffer;
-            try {
-                fileBuffer = await fs.readFile(filePath);
+            if (validData.fileBuffer) {
+                // Memory storage: buffer already available
+                fileBuffer = validData.fileBuffer;
             }
-            catch (error) {
-                return {
-                    status: 500,
-                    content: JSON.stringify({
-                        error: `Failed to read uploaded file: ${error instanceof Error ? error.message : 'Unknown error'}`
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+            else if (validData.filePath) {
+                // Disk storage: read from temp file
+                try {
+                    fileBuffer = await this.readTempFile(validData.filePath);
+                }
+                catch (error) {
+                    return errorResponse(`Failed to read uploaded file: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                }
+            }
+            else {
+                return badRequestResponse('No file data available');
             }
+            // Upload asset and cleanup
             try {
                 await this.uploadAsset({
-                    description,
-                    source,
-                    owner_id: userRecord.id,
-                    filename,
+                    description: validData.description,
+                    source: validData.source,
+                    owner_id: userId,
+                    filename: validData.filename,
                     file: fileBuffer,
-                    is_public: is_public !== undefined ? Boolean(is_public) : true
-                });
-                // Clean up temporary file after successful upload
-                await fs.unlink(filePath).catch(() => {
-                    // Ignore cleanup errors, but log them in production
+                    is_public: validData.is_public
                 });
+                if (validData.filePath) {
+                    await this.cleanupTempFile(validData.filePath);
+                }
             }
             catch (error) {
-                // Clean up temporary file even on error
-                await fs.unlink(filePath).catch(() => { });
+                if (validData.filePath) {
+                    await this.cleanupTempFile(validData.filePath);
+                }
                 throw error;
             }
-            return {
-                status: 200,
-                content: JSON.stringify({ message: 'Asset uploaded successfully' }),
-                headers: { 'Content-Type': 'application/json' }
-            };
+            return successResponse({ message: 'Asset uploaded successfully' });
         }
         catch (error) {
-            return {
-                status: 500,
-                content: JSON.stringify({
-                    error: error instanceof Error ? error.message : 'Unknown error'
-                }),
-                headers: { 'Content-Type': 'application/json' }
-            };
+            return errorResponse(error);
         }
     }
     /**
@@ -760,87 +888,36 @@ export class AssetsManager {
     async handleUpdate(req) {
         try {
             if (!req) {
-                return {
-                    status: 400,
-                    content: JSON.stringify({
-                        error: 'Invalid request: missing request object'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+                return badRequestResponse('Invalid request: missing request object');
             }
-            // Check authentication
-            if (!ApisixAuthParser.hasValidAuth(req.headers || {})) {
-                return {
-                    status: 401,
-                    content: JSON.stringify({
-                        error: 'Authentication required'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+            // Authenticate user
+            const authResult = await this.authenticateRequest(req);
+            if (!authResult.success) {
+                return authResult.response;
             }
-            // Parse authenticated user
-            const authUser = ApisixAuthParser.parseAuthHeaders(req.headers || {});
-            if (!authUser) {
-                return {
-                    status: 401,
-                    content: JSON.stringify({
-                        error: 'Invalid authentication headers'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+            const userId = authResult.userRecord.id;
+            if (!userId) {
+                return errorResponse('Failed to retrieve user information');
             }
             const { id } = req.params || {};
             const { description, source, is_public } = req.body || {};
             if (!id) {
-                return {
-                    status: 400,
-                    content: JSON.stringify({
-                        error: 'Asset ID is required'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+                return badRequestResponse('Asset ID is required');
             }
             if (!description && !source && is_public === undefined) {
-                return {
-                    status: 400,
-                    content: JSON.stringify({
-                        error: 'At least one field (description, source, or is_public) must be provided for update'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
-            }
-            // Find or create user in database
-            const userRecord = await this.userService.findOrCreateUser(authUser);
-            if (!userRecord.id) {
-                return {
-                    status: 500,
-                    content: JSON.stringify({
-                        error: 'Failed to retrieve user information'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+                return badRequestResponse('At least one field (description, source, or is_public) must be provided for update');
             }
-            // Check if asset exists and belongs to this user
+            // Check if asset exists
             const asset = await this.getAssetById(id);
             if (!asset) {
-                return {
-                    status: 404,
-                    content: JSON.stringify({
-                        error: 'Asset not found'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+                return notFoundResponse('Asset not found');
             }
-            // Check ownership (only owner can modify their assets)
-            if (asset.owner_id !== userRecord.id) {
-                return {
-                    status: 403,
-                    content: JSON.stringify({
-                        error: 'You can only modify your own assets'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+            // Check ownership
+            const ownershipError = this.validateOwnership(asset, userId);
+            if (ownershipError) {
+                return ownershipError;
             }
+            // Build and apply updates
             const updates = {};
             if (description !== undefined)
                 updates.description = description;
@@ -849,20 +926,10 @@ export class AssetsManager {
             if (is_public !== undefined)
                 updates.is_public = Boolean(is_public);
             await this.updateAssetMetadata(id, updates);
-            return {
-                status: 200,
-                content: JSON.stringify({ message: 'Asset metadata updated successfully' }),
-                headers: { 'Content-Type': 'application/json' }
-            };
+            return successResponse({ message: 'Asset metadata updated successfully' });
         }
         catch (error) {
-            return {
-                status: 500,
-                content: JSON.stringify({
-                    error: error instanceof Error ? error.message : 'Unknown error'
-                }),
-                headers: { 'Content-Type': 'application/json' }
-            };
+            return errorResponse(error);
         }
     }
     /**
@@ -887,88 +954,15 @@ export class AssetsManager {
      */
     async handleGetAsset(req) {
         try {
-            const { id } = req.params || {};
-            if (!id) {
-                return {
-                    status: 400,
-                    content: JSON.stringify({
-                        error: 'Asset ID is required'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
-            }
-            const asset = await this.getAssetById(id);
-            if (!asset) {
-                return {
-                    status: 404,
-                    content: 'Asset not found',
-                    headers: { 'Content-Type': 'text/plain' }
-                };
-            }
-            // Verify this asset belongs to our component
-            const config = this.getConfiguration();
-            if (asset.name !== config.name) {
-                return {
-                    status: 404,
-                    content: 'Asset not found',
-                    headers: { 'Content-Type': 'text/plain' }
-                };
+            const result = await this.fetchAssetWithAccessCheck(req);
+            if (!result.success) {
+                return result.response;
             }
-            // Check if user is admin (admins can access everything)
-            const isAdmin = ApisixAuthParser.isAdmin(req.headers || {});
-            // Check visibility: if private and user is not admin, verify ownership
-            if (!asset.is_public && !isAdmin) {
-                // Asset is private, require authentication
-                if (!ApisixAuthParser.hasValidAuth(req.headers || {})) {
-                    return {
-                        status: 401,
-                        content: JSON.stringify({
-                            error: 'Authentication required for private assets'
-                        }),
-                        headers: { 'Content-Type': 'application/json' }
-                    };
-                }
-                // Verify ownership
-                const authUser = ApisixAuthParser.parseAuthHeaders(req.headers || {});
-                if (!authUser) {
-                    return {
-                        status: 401,
-                        content: JSON.stringify({
-                            error: 'Invalid authentication headers'
-                        }),
-                        headers: { 'Content-Type': 'application/json' }
-                    };
-                }
-                const userRecord = await this.userService.findOrCreateUser(authUser);
-                if (!userRecord.id || asset.owner_id !== userRecord.id) {
-                    return {
-                        status: 403,
-                        content: JSON.stringify({
-                            error: 'This asset is private'
-                        }),
-                        headers: { 'Content-Type': 'application/json' }
-                    };
-                }
-            }
-            // Get the file content
-            const fileContent = await asset.data();
-            return {
-                status: 200,
-                content: fileContent,
-                headers: {
-                    'Content-Type': config.contentType
-                    // No Content-Disposition - browser will display/use the file
-                }
-            };
+            const fileContent = await result.asset.data();
+            return fileResponse(fileContent, this.getConfiguration().contentType);
         }
         catch (error) {
-            return {
-                status: 500,
-                content: JSON.stringify({
-                    error: error instanceof Error ? error.message : 'Unknown error'
-                }),
-                headers: { 'Content-Type': 'application/json' }
-            };
+            return errorResponse(error);
         }
     }
     /**
@@ -993,90 +987,16 @@ export class AssetsManager {
      */
     async handleDownload(req) {
         try {
-            const { id } = req.params || {};
-            if (!id) {
-                return {
-                    status: 400,
-                    content: JSON.stringify({
-                        error: 'Asset ID is required'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+            const result = await this.fetchAssetWithAccessCheck(req);
+            if (!result.success) {
+                return result.response;
             }
-            const asset = await this.getAssetById(id);
-            if (!asset) {
-                return {
-                    status: 404,
-                    content: 'Asset not found',
-                    headers: { 'Content-Type': 'text/plain' }
-                };
-            }
-            // Verify this asset belongs to our component
-            const config = this.getConfiguration();
-            if (asset.name !== config.name) {
-                return {
-                    status: 404,
-                    content: 'Asset not found',
-                    headers: { 'Content-Type': 'text/plain' }
-                };
-            }
-            // Check if user is admin (admins can download everything)
-            const isAdmin = ApisixAuthParser.isAdmin(req.headers || {});
-            // Check visibility: if private and user is not admin, verify ownership
-            if (!asset.is_public && !isAdmin) {
-                // Asset is private, require authentication
-                if (!ApisixAuthParser.hasValidAuth(req.headers || {})) {
-                    return {
-                        status: 401,
-                        content: JSON.stringify({
-                            error: 'Authentication required for private assets'
-                        }),
-                        headers: { 'Content-Type': 'application/json' }
-                    };
-                }
-                // Verify ownership
-                const authUser = ApisixAuthParser.parseAuthHeaders(req.headers || {});
-                if (!authUser) {
-                    return {
-                        status: 401,
-                        content: JSON.stringify({
-                            error: 'Invalid authentication headers'
-                        }),
-                        headers: { 'Content-Type': 'application/json' }
-                    };
-                }
-                const userRecord = await this.userService.findOrCreateUser(authUser);
-                if (!userRecord.id || asset.owner_id !== userRecord.id) {
-                    return {
-                        status: 403,
-                        content: JSON.stringify({
-                            error: 'This asset is private'
-                        }),
-                        headers: { 'Content-Type': 'application/json' }
-                    };
-                }
-            }
-            // Get the file content
-            const fileContent = await asset.data();
-            // Get original filename from asset metadata
-            const filename = asset.filename || `asset_${id}`;
-            return {
-                status: 200,
-                content: fileContent,
-                headers: {
-                    'Content-Type': config.contentType,
-                    'Content-Disposition': `attachment; filename="${filename}"`
-                }
-            };
+            const fileContent = await result.asset.data();
+            const filename = result.asset.filename || `asset_${req.params?.id}`;
+            return fileResponse(fileContent, this.getConfiguration().contentType, filename);
         }
         catch (error) {
-            return {
-                status: 500,
-                content: JSON.stringify({
-                    error: error instanceof Error ? error.message : 'Unknown error'
-                }),
-                headers: { 'Content-Type': 'application/json' }
-            };
+            return errorResponse(error);
         }
     }
     /**
@@ -1094,84 +1014,34 @@ export class AssetsManager {
      */
     async handleDelete(req) {
         try {
-            // Check authentication first
-            if (!ApisixAuthParser.hasValidAuth(req.headers || {})) {
-                return {
-                    status: 401,
-                    content: JSON.stringify({
-                        error: 'Authentication required'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+            // Authenticate user
+            const authResult = await this.authenticateRequest(req);
+            if (!authResult.success) {
+                return authResult.response;
             }
-            // Parse authenticated user
-            const authUser = ApisixAuthParser.parseAuthHeaders(req.headers || {});
-            if (!authUser) {
-                return {
-                    status: 401,
-                    content: JSON.stringify({
-                        error: 'Invalid authentication headers'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+            const userId = authResult.userRecord.id;
+            if (!userId) {
+                return errorResponse('Failed to retrieve user information');
             }
             const { id } = req.params || {};
             if (!id) {
-                return {
-                    status: 400,
-                    content: JSON.stringify({
-                        error: 'Asset ID is required'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
-            }
-            // Find or create user in database
-            const userRecord = await this.userService.findOrCreateUser(authUser);
-            if (!userRecord.id) {
-                return {
-                    status: 500,
-                    content: JSON.stringify({
-                        error: 'Failed to retrieve user information'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+                return badRequestResponse('Asset ID is required');
             }
-            // Check if asset exists and belongs to this user
+            // Check if asset exists
             const asset = await this.getAssetById(id);
             if (!asset) {
-                return {
-                    status: 404,
-                    content: JSON.stringify({
-                        error: 'Asset not found'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+                return notFoundResponse('Asset not found');
             }
-            // Check ownership (only owner can delete their assets)
-            if (asset.owner_id !== userRecord.id) {
-                return {
-                    status: 403,
-                    content: JSON.stringify({
-                        error: 'You can only delete your own assets'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+            // Check ownership
+            const ownershipError = this.validateOwnership(asset, userId);
+            if (ownershipError) {
+                return ownershipError;
             }
             await this.deleteAssetById(id);
-            return {
-                status: 200,
-                content: JSON.stringify({ message: 'Asset deleted successfully' }),
-                headers: { 'Content-Type': 'application/json' }
-            };
+            return successResponse({ message: 'Asset deleted successfully' });
         }
         catch (error) {
-            return {
-                status: 500,
-                content: JSON.stringify({
-                    error: error instanceof Error ? error.message : 'Unknown error'
-                }),
-                headers: { 'Content-Type': 'application/json' }
-            };
+            return errorResponse(error);
         }
     }
     /**
@@ -1179,243 +1049,161 @@ export class AssetsManager {
      */
     async handleUploadBatch(req) {
         try {
-            if (!req || !req.body) {
-                return {
-                    status: 400,
-                    content: JSON.stringify({
-                        error: 'Invalid request: missing request body'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
-            }
-            // Check authentication
-            if (!ApisixAuthParser.hasValidAuth(req.headers || {})) {
-                return {
-                    status: 401,
-                    content: JSON.stringify({
-                        error: 'Authentication required'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+            if (!req?.body) {
+                return badRequestResponse('Invalid request: missing request body');
             }
-            // Parse authenticated user
-            const authUser = ApisixAuthParser.parseAuthHeaders(req.headers || {});
-            if (!authUser) {
-                return {
-                    status: 401,
-                    content: JSON.stringify({
-                        error: 'Invalid authentication headers'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+            // Authenticate user
+            const authResult = await this.authenticateRequest(req);
+            if (!authResult.success) {
+                return authResult.response;
             }
-            // Find or create user in database
-            const userRecord = await this.userService.findOrCreateUser(authUser);
-            if (!userRecord.id) {
-                return {
-                    status: 500,
-                    content: JSON.stringify({
-                        error: 'Failed to retrieve user information'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+            const userId = authResult.userRecord.id;
+            if (!userId) {
+                return errorResponse('Failed to retrieve user information');
             }
             const requests = req.body.requests;
             if (!Array.isArray(requests) || requests.length === 0) {
-                return {
-                    status: 400,
-                    content: JSON.stringify({
-                        error: 'Requests array is required and must not be empty'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+                return badRequestResponse('Requests array is required and must not be empty');
             }
-            // Validate all requests first (including extensions and base64 format)
-            for (const request of requests) {
-                if (!request.file || !request.description || !request.source || !request.filename) {
-                    return {
-                        status: 400,
-                        content: JSON.stringify({
-                            error: 'Each request must have description, source, filename, and file'
-                        }),
-                        headers: { 'Content-Type': 'application/json' }
-                    };
-                }
-                // Validate that file is valid base64 string
-                if (!this.validateBase64(request.file)) {
-                    return {
-                        status: 400,
-                        content: JSON.stringify({
-                            error: `Invalid base64 data for file: ${request.filename}. File must be a valid base64-encoded string.`
-                        }),
-                        headers: { 'Content-Type': 'application/json' }
-                    };
-                }
-                // Validate file extension for each request
-                if (!this.validateFileExtension(request.filename)) {
-                    const config = this.getConfiguration();
-                    return {
-                        status: 400,
-                        content: JSON.stringify({
-                            error: `Invalid file extension for ${request.filename}. Expected: ${config.extension}`
-                        }),
-                        headers: { 'Content-Type': 'application/json' }
-                    };
-                }
-            }
-            // Process each request individually for compatibility
-            const results = [];
-            for (const request of requests) {
-                try {
-                    await this.uploadAsset({
-                        description: request.description,
-                        source: request.source,
-                        owner_id: userRecord.id,
-                        filename: request.filename,
-                        file: Buffer.from(request.file, 'base64'), // Already validated as base64 above
-                        is_public: request.is_public !== undefined ? Boolean(request.is_public) : true
-                    });
-                    results.push({ success: true, filename: request.filename });
-                }
-                catch (error) {
-                    results.push({
-                        success: false,
-                        filename: request.filename,
-                        error: error instanceof Error ? error.message : 'Unknown error'
-                    });
-                }
+            // Validate all requests first
+            const validationError = this.validateBatchRequests(requests);
+            if (validationError) {
+                return validationError;
             }
+            // Process each request
+            const results = await this.processBatchUploads(requests, userId);
             const successCount = results.filter(r => r.success).length;
             const failureCount = results.length - successCount;
-            return {
-                status: failureCount > 0 ? 207 : 200, // 207 Multi-Status if some failed
-                content: JSON.stringify({
-                    message: `${successCount}/${requests.length} assets uploaded successfully`,
-                    results
-                }),
-                headers: { 'Content-Type': 'application/json' }
-            };
+            const message = `${successCount}/${requests.length} assets uploaded successfully`;
+            if (failureCount > 0) {
+                return multiStatusResponse(message, results);
+            }
+            return successResponse({ message, results });
         }
         catch (error) {
-            return {
-                status: 500,
-                content: JSON.stringify({
+            return errorResponse(error);
+        }
+    }
+    /**
+     * Validates all requests in a batch upload.
+     *
+     * @param requests - Array of upload requests to validate
+     * @returns DataResponse with error if validation fails, undefined if valid
+     */
+    validateBatchRequests(requests) {
+        const config = this.getConfiguration();
+        for (const request of requests) {
+            if (!request.file || !request.description || !request.source || !request.filename) {
+                return badRequestResponse('Each request must have description, source, filename, and file');
+            }
+            if (!this.validateBase64(request.file)) {
+                return badRequestResponse(`Invalid base64 data for file: ${request.filename}. File must be a valid base64-encoded string.`);
+            }
+            if (!this.validateFileExtension(request.filename)) {
+                return badRequestResponse(`Invalid file extension for ${request.filename}. Expected: ${config.extension}`);
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Processes batch upload requests.
+     *
+     * @param requests - Array of upload requests
+     * @param ownerId - Owner user ID
+     * @returns Array of results for each upload
+     */
+    async processBatchUploads(requests, ownerId) {
+        const results = [];
+        for (const request of requests) {
+            try {
+                await this.uploadAsset({
+                    description: request.description,
+                    source: request.source,
+                    owner_id: ownerId,
+                    filename: request.filename,
+                    file: Buffer.from(request.file, 'base64'),
+                    is_public: request.is_public !== undefined ? Boolean(request.is_public) : true
+                });
+                results.push({ success: true, filename: request.filename });
+            }
+            catch (error) {
+                results.push({
+                    success: false,
+                    filename: request.filename,
                     error: error instanceof Error ? error.message : 'Unknown error'
-                }),
-                headers: { 'Content-Type': 'application/json' }
-            };
+                });
+            }
         }
+        return results;
     }
     /**
      * Handle batch delete endpoint
      */
     async handleDeleteBatch(req) {
         try {
-            if (!req || !req.body) {
-                return {
-                    status: 400,
-                    content: JSON.stringify({
-                        error: 'Invalid request: missing request body'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
-            }
-            // Check authentication
-            if (!ApisixAuthParser.hasValidAuth(req.headers || {})) {
-                return {
-                    status: 401,
-                    content: JSON.stringify({
-                        error: 'Authentication required'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+            if (!req?.body) {
+                return badRequestResponse('Invalid request: missing request body');
             }
-            // Parse authenticated user
-            const authUser = ApisixAuthParser.parseAuthHeaders(req.headers || {});
-            if (!authUser) {
-                return {
-                    status: 401,
-                    content: JSON.stringify({
-                        error: 'Invalid authentication headers'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+            // Authenticate user
+            const authResult = await this.authenticateRequest(req);
+            if (!authResult.success) {
+                return authResult.response;
             }
-            // Find or create user in database
-            const userRecord = await this.userService.findOrCreateUser(authUser);
-            if (!userRecord.id) {
-                return {
-                    status: 500,
-                    content: JSON.stringify({
-                        error: 'Failed to retrieve user information'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+            const userId = authResult.userRecord.id;
+            if (!userId) {
+                return errorResponse('Failed to retrieve user information');
             }
             const { ids } = req.body;
             if (!Array.isArray(ids) || ids.length === 0) {
-                return {
-                    status: 400,
-                    content: JSON.stringify({
-                        error: 'IDs array is required and must not be empty'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
-            }
-            // Process deletions individually with error handling and ownership checks
-            const results = [];
-            for (const id of ids) {
-                try {
-                    // Check if asset exists and belongs to this user
-                    const asset = await this.getAssetById(id);
-                    if (!asset) {
-                        results.push({
-                            success: false,
-                            id,
-                            error: 'Asset not found'
-                        });
-                        continue;
-                    }
-                    // Check ownership (only owner can delete their assets)
-                    if (asset.owner_id !== userRecord.id) {
-                        results.push({
-                            success: false,
-                            id,
-                            error: 'You can only delete your own assets'
-                        });
-                        continue;
-                    }
-                    await this.deleteAssetById(id);
-                    results.push({ success: true, id });
-                }
-                catch (error) {
-                    results.push({
-                        success: false,
-                        id,
-                        error: error instanceof Error ? error.message : 'Unknown error'
-                    });
-                }
+                return badRequestResponse('IDs array is required and must not be empty');
             }
+            // Process deletions
+            const results = await this.processBatchDeletes(ids, userId);
             const successCount = results.filter(r => r.success).length;
             const failureCount = results.length - successCount;
-            return {
-                status: failureCount > 0 ? 207 : 200, // 207 Multi-Status if some failed
-                content: JSON.stringify({
-                    message: `${successCount}/${ids.length} assets deleted successfully`,
-                    results
-                }),
-                headers: { 'Content-Type': 'application/json' }
-            };
+            const message = `${successCount}/${ids.length} assets deleted successfully`;
+            if (failureCount > 0) {
+                return multiStatusResponse(message, results);
+            }
+            return successResponse({ message, results });
         }
         catch (error) {
-            return {
-                status: 500,
-                content: JSON.stringify({
+            return errorResponse(error);
+        }
+    }
+    /**
+     * Processes batch delete requests.
+     *
+     * @param ids - Array of asset IDs to delete
+     * @param userId - User ID for ownership validation
+     * @returns Array of results for each deletion
+     */
+    async processBatchDeletes(ids, userId) {
+        const results = [];
+        for (const id of ids) {
+            try {
+                const asset = await this.getAssetById(id);
+                if (!asset) {
+                    results.push({ success: false, id, error: 'Asset not found' });
+                    continue;
+                }
+                // Allow deletion if: owner is the current user OR asset has no owner
+                if (asset.owner_id !== null && asset.owner_id !== userId) {
+                    results.push({ success: false, id, error: 'You can only delete your own assets' });
+                    continue;
+                }
+                await this.deleteAssetById(id);
+                results.push({ success: true, id });
+            }
+            catch (error) {
+                results.push({
+                    success: false,
+                    id,
                     error: error instanceof Error ? error.message : 'Unknown error'
-                }),
-                headers: { 'Content-Type': 'application/json' }
-            };
+                });
+            }
         }
+        return results;
     }
 }
 //# sourceMappingURL=assets_manager.js.map