digitaltwin-core 0.13.0 → 0.13.2

package/dist/components/tileset_manager.js

@@ -3,42 +3,50 @@ import { extractAndStoreArchive } from '../utils/zip_utils.js';
 import { ApisixAuthParser } from '../auth/apisix_parser.js';
 import { AuthConfig } from '../auth/auth_config.js';
 import fs from 'fs/promises';
+import { successResponse, errorResponse, badRequestResponse, unauthorizedResponse, notFoundResponse, forbiddenResponse } from '../utils/http_responses.js';
+/** Threshold for async upload (50MB) */
+const ASYNC_UPLOAD_THRESHOLD = 50 * 1024 * 1024;
 /**
  * Specialized Assets Manager for handling 3D Tiles tilesets.
  *
- * This manager extracts uploaded ZIP files and stores each file individually,
- * allowing Cesium and other 3D viewers to load tilesets directly via URL.
+ * This manager extracts uploaded ZIP files and stores each file in cloud storage (OVH S3),
+ * allowing Cesium and other 3D viewers to load tilesets directly via public URLs.
  *
- * Key features:
- * - Extracts ZIP archives on upload (no ZIP stored, only extracted files)
- * - Detects and tracks the root tileset.json file
- * - Serves individual files via dedicated endpoint
- * - Returns tileset.json URL for direct Cesium loading
+ * ## How it works
  *
- * Endpoints:
- * - GET /{endpoint} - List all tilesets with tileset.json URLs
- * - POST /{endpoint} - Upload tileset ZIP (extracts and stores files)
- * - GET /{endpoint}/:id - Get tileset metadata
- * - GET /{endpoint}/:id/files/* - Serve extracted files (tileset.json, .b3dm, etc.)
+ * 1. User uploads a ZIP containing a 3D Tiles tileset
+ * 2. ZIP is extracted and all files are stored in OVH with public-read ACL
+ * 3. Database stores only the tileset.json URL and base path
+ * 4. Cesium loads tileset.json directly from OVH
+ * 5. Cesium fetches tiles using relative paths in tileset.json (directly from OVH)
+ *
+ * ## Endpoints
+ *
+ * - GET /{endpoint} - List all tilesets with their public URLs
+ * - POST /{endpoint} - Upload tileset ZIP (sync < 50MB, async >= 50MB)
+ * - GET /{endpoint}/:id/status - Poll async upload status
  * - PUT /{endpoint}/:id - Update tileset metadata
- * - DELETE /{endpoint}/:id - Delete tileset and all extracted files
+ * - DELETE /{endpoint}/:id - Delete tileset and all files from storage
  *
  * @example
  * ```typescript
  * class MyTilesetManager extends TilesetManager {
  *   getConfiguration() {
  *     return {
- *       name: 'tilesets_manager',
+ *       name: 'tilesets',
  *       description: 'Manage 3D Tiles tilesets',
  *       contentType: 'application/json',
  *       endpoint: 'api/tilesets',
- *       tags: ['Tileset']
+ *       extension: '.zip'
  *     }
  *   }
  * }
  *
- * // After upload, Cesium can load:
- * // Cesium3DTileset.fromUrl('/api/tilesets/123/files/tileset.json')
+ * // After upload, response contains:
+ * // { tileset_url: 'https://bucket.s3.../tilesets/123/tileset.json' }
+ * //
+ * // Cesium loads directly:
+ * // Cesium.Cesium3DTileset.fromUrl(tileset_url)
  * ```
  */
 export class TilesetManager extends AssetsManager {
@@ -55,524 +63,240 @@ export class TilesetManager extends AssetsManager {
         this.uploadQueue = queue;
     }
     /**
-     * Override the upload handler to support async processing for large files.
-     *
-     * When uploadQueue is available (async mode):
-     * 1. Validates request and authentication
-     * 2. Creates a database record with status 'pending'
-     * 3. Queues a job for background processing
-     * 4. Returns immediately with job ID
-     *
-     * When uploadQueue is not available (sync mode - fallback):
-     * 1. Validates request and authentication
-     * 2. Extracts ZIP and stores files synchronously
-     * 3. Returns with completed tileset info
+     * Handle tileset upload.
      *
-     * @param req - HTTP request with ZIP file upload
-     * @returns DataResponse with upload result (async: job info, sync: tileset info)
+     * - Files < 50MB: Synchronous extraction and upload
+     * - Files >= 50MB: Queued for async processing (returns 202)
      */
     async handleUpload(req) {
         try {
-            if (!req || !req.body) {
-                return {
-                    status: 400,
-                    content: JSON.stringify({
-                        error: 'Invalid request: missing request body'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+            if (!req?.body) {
+                return badRequestResponse('Invalid request: missing request body');
             }
-            // Check authentication (skip if auth is disabled)
-            let userId;
-            if (AuthConfig.isAuthDisabled()) {
-                const anonymousUser = {
-                    id: AuthConfig.getAnonymousUserId(),
-                    roles: []
-                };
-                const userRecord = await this.userService.findOrCreateUser(anonymousUser);
-                userId = userRecord.id;
-            }
-            else {
-                if (!ApisixAuthParser.hasValidAuth(req.headers || {})) {
-                    return {
-                        status: 401,
-                        content: JSON.stringify({
-                            error: 'Authentication required'
-                        }),
-                        headers: { 'Content-Type': 'application/json' }
-                    };
-                }
-                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) {
-                    return {
-                        status: 500,
-                        content: JSON.stringify({
-                            error: 'Failed to retrieve user information'
-                        }),
-                        headers: { 'Content-Type': 'application/json' }
-                    };
-                }
-                userId = userRecord.id;
+            // Authenticate user
+            const userId = await this.authenticateUser(req);
+            if (typeof userId !== 'number') {
+                return userId; // Returns error response
             }
+            // Validate request
             const { description } = req.body;
             const filePath = req.file?.path;
             const fileBuffer = req.file?.buffer;
             const filename = req.file?.originalname || req.body.filename;
-            // Support both disk storage (filePath) and memory storage (fileBuffer)
+            const fileSize = req.file?.size || fileBuffer?.length || 0;
             if (!filePath && !fileBuffer) {
-                return {
-                    status: 400,
-                    content: JSON.stringify({
-                        error: 'Missing required fields: ZIP file'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+                return badRequestResponse('Missing required field: ZIP file');
             }
             if (!description) {
-                return {
-                    status: 400,
-                    content: JSON.stringify({
-                        error: 'Missing required fields: description'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+                if (filePath)
+                    await fs.unlink(filePath).catch(() => { });
+                return badRequestResponse('Missing required field: description');
             }
             if (!filename) {
-                return {
-                    status: 400,
-                    content: JSON.stringify({
-                        error: 'Filename could not be determined from uploaded file'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+                if (filePath)
+                    await fs.unlink(filePath).catch(() => { });
+                return badRequestResponse('Filename could not be determined from uploaded file');
             }
-            // Validate ZIP file extension
             if (!filename.toLowerCase().endsWith('.zip')) {
-                return {
-                    status: 400,
-                    content: JSON.stringify({
-                        error: 'Invalid file extension. Expected: .zip'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+                if (filePath)
+                    await fs.unlink(filePath).catch(() => { });
+                return badRequestResponse('Invalid file extension. Expected: .zip');
             }
             const config = this.getConfiguration();
-            // Debug: log upload mode selection
-            console.log(`[TilesetManager] Upload: queue=${!!this.uploadQueue}, filePath=${!!filePath}, fileBuffer=${!!fileBuffer}`);
-            // ASYNC MODE: Queue job for background processing (requires disk storage)
-            if (this.uploadQueue && filePath) {
-                console.log(`[TilesetManager] Using ASYNC mode for ${filename}`);
-                return this.handleAsyncUpload(req, userId, filePath, filename, description, config);
+            const isPublic = req.body.is_public !== undefined ? Boolean(req.body.is_public) : true;
+            // Route to async or sync based on file size and queue availability
+            if (this.uploadQueue && filePath && fileSize >= ASYNC_UPLOAD_THRESHOLD) {
+                return this.handleAsyncUpload(userId, filePath, filename, description, isPublic, config);
             }
-            // SYNC MODE: Process immediately (fallback or memory buffer)
-            console.log(`[TilesetManager] Using SYNC mode for ${filename}`);
-            return this.handleSyncUpload(req, userId, filePath, fileBuffer, filename, description, config);
+            return this.handleSyncUpload(userId, filePath, fileBuffer, filename, description, isPublic, config);
         }
         catch (error) {
-            return {
-                status: 500,
-                content: JSON.stringify({
-                    error: error instanceof Error ? error.message : 'Unknown error'
-                }),
-                headers: { 'Content-Type': 'application/json' }
-            };
+            if (req.file?.path)
+                await fs.unlink(req.file.path).catch(() => { });
+            return errorResponse(error);
         }
     }
     /**
-     * Handle upload asynchronously by queuing a job
-     * @private
+     * Authenticate user from request headers.
+     * Returns user ID on success, or error response on failure.
      */
-    async handleAsyncUpload(req, userId, filePath, filename, description, config) {
-        const now = new Date();
-        // Create a pending record in the database
-        const metadata = {
-            name: config.name,
-            type: 'application/json',
-            url: '', // Will be set by worker after extraction
-            date: now,
-            description,
-            source: req.body.source || '',
-            owner_id: userId,
-            filename: filename,
-            is_public: req.body.is_public !== undefined ? Boolean(req.body.is_public) : true,
-            upload_status: 'pending'
-        };
-        const savedRecord = await this.db.save(metadata);
-        const recordId = savedRecord.id;
-        // Queue the processing job
-        const jobData = {
-            type: 'tileset',
-            recordId,
-            tempFilePath: filePath,
-            componentName: config.name,
-            userId,
-            filename,
-            description
-        };
-        // uploadQueue is guaranteed to exist here (checked in handleUpload)
-        let job;
+    async authenticateUser(req) {
+        if (AuthConfig.isAuthDisabled()) {
+            const userRecord = await this.userService.findOrCreateUser({
+                id: AuthConfig.getAnonymousUserId(),
+                roles: []
+            });
+            return userRecord.id;
+        }
+        if (!ApisixAuthParser.hasValidAuth(req.headers || {})) {
+            return unauthorizedResponse();
+        }
+        const authUser = ApisixAuthParser.parseAuthHeaders(req.headers || {});
+        if (!authUser) {
+            return unauthorizedResponse('Invalid authentication headers');
+        }
+        const userRecord = await this.userService.findOrCreateUser(authUser);
+        if (!userRecord.id) {
+            return errorResponse('Failed to retrieve user information');
+        }
+        return userRecord.id;
+    }
+    /**
+     * Queue upload for background processing. Returns HTTP 202 immediately.
+     */
+    async handleAsyncUpload(userId, filePath, filename, description, isPublic, config) {
+        let recordId = null;
         try {
-            job = await this.uploadQueue?.add(`tileset-${recordId}`, jobData, {
+            // Create pending record (url will be updated after extraction)
+            const metadata = {
+                name: config.name,
+                type: 'application/json',
+                url: '',
+                tileset_url: '',
+                date: new Date(),
+                description,
+                filename,
+                owner_id: userId,
+                is_public: isPublic,
+                upload_status: 'pending'
+            };
+            const savedRecord = await this.db.save(metadata);
+            recordId = savedRecord.id;
+            const jobData = {
+                type: 'tileset',
+                recordId,
+                tempFilePath: filePath,
+                componentName: config.name,
+                userId,
+                filename,
+                description
+            };
+            const job = await this.uploadQueue?.add(`tileset-${recordId}`, jobData, {
                 jobId: `tileset-upload-${recordId}`
             });
-            if (!job) {
+            if (!job)
                 throw new Error('Failed to queue upload job');
-            }
+            await this.db.updateById(config.name, recordId, { upload_job_id: job.id });
+            return {
+                status: 202,
+                content: JSON.stringify({
+                    message: 'Tileset upload accepted, processing in background',
+                    id: recordId,
+                    job_id: job.id,
+                    status: 'pending',
+                    status_url: `/${config.endpoint}/${recordId}/status`
+                }),
+                headers: { 'Content-Type': 'application/json' }
+            };
         }
-        catch (queueError) {
-            // Clean up: delete the DB record if queue fails
-            await this.db.delete(String(recordId), config.name).catch(() => { });
-            // Clean up temp file
+        catch (error) {
+            if (recordId !== null)
+                await this.db.delete(String(recordId), config.name).catch(() => { });
             await fs.unlink(filePath).catch(() => { });
-            throw queueError;
+            throw error;
         }
-        // Update record with job ID
-        await this.db.updateById(config.name, recordId, {
-            upload_job_id: job.id
-        });
-        return {
-            status: 202, // Accepted - processing started
-            content: JSON.stringify({
-                message: 'Tileset upload accepted, processing in background',
-                id: recordId,
-                job_id: job.id,
-                status: 'pending',
-                status_url: `/${config.endpoint}/${recordId}/status`
-            }),
-            headers: { 'Content-Type': 'application/json' }
-        };
     }
     /**
-     * Handle upload synchronously (original behavior)
-     * @private
+     * Process upload synchronously.
      */
-    async handleSyncUpload(req, userId, filePath, fileBuffer, filename, description, config) {
-        // Read ZIP file content
+    async handleSyncUpload(userId, filePath, fileBuffer, filename, description, isPublic, config) {
         let zipBuffer;
         try {
-            if (fileBuffer) {
-                zipBuffer = fileBuffer;
-            }
-            else if (filePath) {
-                zipBuffer = await fs.readFile(filePath);
-            }
-            else {
+            const readBuffer = fileBuffer || (filePath ? await fs.readFile(filePath) : null);
+            if (!readBuffer)
                 throw new Error('No file data available');
-            }
+            zipBuffer = readBuffer;
         }
         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' }
-            };
+            return errorResponse(`Failed to read uploaded file: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
         try {
-            const now = new Date();
-            // Generate unique ID for this tileset (timestamp-based)
-            const tilesetId = now.getTime().toString();
-            // Base path for storing extracted files: componentName/tilesetId
-            const basePath = `${config.name}/${tilesetId}`;
-            // Extract ZIP and store all files individually
+            // Generate unique base path using timestamp
+            const basePath = `${config.name}/${Date.now()}`;
+            // Extract ZIP and upload all files to storage
             const extractResult = await extractAndStoreArchive(zipBuffer, this.storage, basePath);
-            // Validate that we found a tileset.json
             if (!extractResult.root_file) {
-                // Clean up stored files if no tileset.json found using batch delete
-                if (extractResult.files.length > 0) {
-                    const filePaths = extractResult.files.map(file => file.path);
-                    await this.storage.deleteBatch(filePaths);
-                }
-                return {
-                    status: 400,
-                    content: JSON.stringify({
-                        error: 'Invalid tileset: no tileset.json found in the ZIP archive'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
-            }
-            // Create metadata with file_index
-            // url stores the base path for all extracted files
+                // Clean up uploaded files
+                await this.storage.deleteByPrefix(basePath).catch(() => { });
+                return badRequestResponse('Invalid tileset: no tileset.json found in the ZIP archive');
+            }
+            // Build the public URL for tileset.json
+            const tilesetPath = `${basePath}/${extractResult.root_file}`;
+            const tilesetUrl = this.storage.getPublicUrl(tilesetPath);
+            // Save metadata to database (url = basePath for deletion)
             const metadata = {
                 name: config.name,
-                type: 'application/json', // tileset.json content type
-                url: basePath, // Base path for all files (componentName/timestamp)
-                date: now,
+                type: 'application/json',
+                url: basePath,
+                tileset_url: tilesetUrl,
+                date: new Date(),
                 description,
-                source: req.body.source || '',
+                filename,
                 owner_id: userId,
-                filename: filename,
-                is_public: req.body.is_public !== undefined ? Boolean(req.body.is_public) : true,
-                file_index: {
-                    files: extractResult.files,
-                    root_file: extractResult.root_file
-                }
+                is_public: isPublic,
+                upload_status: 'completed'
             };
             const savedRecord = await this.db.save(metadata);
-            // Clean up temporary file after successful upload
-            if (filePath) {
+            // Clean up temp file
+            if (filePath)
                 await fs.unlink(filePath).catch(() => { });
-            }
-            return {
-                status: 200,
-                content: JSON.stringify({
-                    message: 'Tileset uploaded and extracted successfully',
-                    id: savedRecord.id,
-                    file_count: extractResult.file_count,
-                    root_file: extractResult.root_file,
-                    tileset_url: `/${config.endpoint}/${savedRecord.id}/files/${extractResult.root_file}`
-                }),
-                headers: { 'Content-Type': 'application/json' }
-            };
+            return successResponse({
+                message: 'Tileset uploaded successfully',
+                id: savedRecord.id,
+                tileset_url: tilesetUrl,
+                file_count: extractResult.file_count
+            });
         }
         catch (error) {
-            // Clean up temporary file even on error
-            if (filePath) {
+            if (filePath)
                 await fs.unlink(filePath).catch(() => { });
-            }
             throw error;
         }
     }
     /**
-     * Get the status of an upload job
+     * Get upload status for async uploads.
      */
     async handleGetStatus(req) {
         try {
             const { id } = req.params || {};
             if (!id) {
-                return {
-                    status: 400,
-                    content: JSON.stringify({ error: 'Asset ID is required' }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+                return badRequestResponse('Asset ID is required');
             }
             const asset = await this.getAssetById(id);
             if (!asset) {
-                return {
-                    status: 404,
-                    content: JSON.stringify({ error: 'Tileset not found' }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+                return notFoundResponse('Tileset not found');
             }
-            const config = this.getConfiguration();
             const record = asset;
-            const fileIndex = record.file_index;
-            // Determine actual status:
-            // - If upload_status is 'completed' OR
-            // - If upload_status is null/undefined BUT file_index exists (legacy sync uploads)
-            const isCompleted = record.upload_status === 'completed' ||
-                (!record.upload_status && fileIndex && fileIndex.files && fileIndex.files.length > 0);
-            if (isCompleted) {
-                const rootFile = fileIndex?.root_file || 'tileset.json';
-                return {
-                    status: 200,
-                    content: JSON.stringify({
-                        id: record.id,
-                        status: 'completed',
-                        tileset_url: `/${config.endpoint}/${record.id}/files/${rootFile}`,
-                        file_count: fileIndex?.files?.length || 0
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
-            }
-            // If no upload_status and no file_index, it's a broken record
-            if (!record.upload_status) {
-                return {
-                    status: 200,
-                    content: JSON.stringify({
-                        id: record.id,
-                        status: 'failed',
-                        error: 'Upload incomplete - no files found'
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
-            }
-            // Return current status (pending, processing, or failed)
-            return {
-                status: 200,
-                content: JSON.stringify({
+            if (record.upload_status === 'completed') {
+                return successResponse({
                     id: record.id,
-                    status: record.upload_status,
-                    job_id: record.upload_job_id,
-                    error: record.upload_error || undefined
-                }),
-                headers: { 'Content-Type': 'application/json' }
-            };
-        }
-        catch (error) {
-            return {
-                status: 500,
-                content: JSON.stringify({
-                    error: error instanceof Error ? error.message : 'Unknown error'
-                }),
-                headers: { 'Content-Type': 'application/json' }
-            };
-        }
-    }
-    /**
-     * Serve an extracted file from the tileset.
-     *
-     * This endpoint allows Cesium to load tileset.json and all referenced files
-     * (tiles, textures, etc.) using relative paths.
-     *
-     * @param req - HTTP request with params.id and params['0'] (file path)
-     * @returns DataResponse with file content
-     */
-    async handleGetFile(req) {
-        try {
-            const { id } = req.params || {};
-            // Express/ultimate-express captures wildcard path in different ways:
-            // - Express 4.x: params[0] or params['0']
-            // - Express 5.x / ultimate-express: params['*'] or via URL parsing
-            let filePath = req.params[0] || req.params['0'] || req.params['*'] || req.params.path || req.params['*0'];
-            // Fallback: extract from URL if params didn't capture it
-            if (!filePath && req.url) {
-                const match = req.url.match(/\/files\/(.+)$/);
-                if (match) {
-                    filePath = decodeURIComponent(match[1]);
-                }
-            }
-            // Another fallback: use originalUrl
-            if (!filePath && req.originalUrl) {
-                const match = req.originalUrl.match(/\/files\/(.+)$/);
-                if (match) {
-                    filePath = decodeURIComponent(match[1]);
-                }
-            }
-            if (!id) {
-                return {
-                    status: 400,
-                    content: JSON.stringify({ error: 'Asset ID is required' }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
-            }
-            if (!filePath) {
-                return {
-                    status: 400,
-                    content: JSON.stringify({ error: 'File path is required' }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+                    status: 'completed',
+                    tileset_url: record.tileset_url
+                });
             }
-            // Get asset metadata
-            const asset = await this.getAssetById(id);
-            if (!asset) {
-                return {
-                    status: 404,
-                    content: JSON.stringify({ error: 'Tileset not found' }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
-            }
-            // Verify this asset belongs to our component
-            const config = this.getConfiguration();
-            if (asset.name !== config.name) {
-                return {
-                    status: 404,
-                    content: JSON.stringify({ error: 'Tileset not found' }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
-            }
-            // Check access permissions for private assets
-            if (!asset.is_public) {
-                if (ApisixAuthParser.isAdmin(req.headers || {})) {
-                    // Admin can access everything
-                }
-                else if (!ApisixAuthParser.hasValidAuth(req.headers || {})) {
-                    return {
-                        status: 401,
-                        content: JSON.stringify({ error: 'Authentication required for private assets' }),
-                        headers: { 'Content-Type': 'application/json' }
-                    };
-                }
-                else {
-                    const authUser = ApisixAuthParser.parseAuthHeaders(req.headers || {});
-                    if (authUser) {
-                        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' }
-                            };
-                        }
-                    }
-                }
-            }
-            // Build storage path using asset.url as base path
-            // asset.url contains the base path (e.g., 'tilesets_manager/1733064000000')
-            const storagePath = `${asset.url}/${filePath}`;
-            // Retrieve file from storage
-            let fileContent;
-            try {
-                fileContent = await this.storage.retrieve(storagePath);
-            }
-            catch {
-                return {
-                    status: 404,
-                    content: JSON.stringify({ error: 'File not found' }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
-            }
-            // Determine content type based on file extension
-            const contentType = this.getContentTypeForFile(filePath);
-            return {
-                status: 200,
-                content: fileContent,
-                headers: {
-                    'Content-Type': contentType,
-                    'Access-Control-Allow-Origin': '*'
-                }
-            };
+            if (record.upload_status === 'failed') {
+                return successResponse({
+                    id: record.id,
+                    status: 'failed',
+                    error: record.upload_error || 'Upload failed'
+                });
+            }
+            return successResponse({
+                id: record.id,
+                status: record.upload_status || 'unknown',
+                job_id: record.upload_job_id
+            });
         }
         catch (error) {
-            return {
-                status: 500,
-                content: JSON.stringify({
-                    error: error instanceof Error ? error.message : 'Unknown error'
-                }),
-                headers: { 'Content-Type': 'application/json' }
-            };
+            return errorResponse(error);
         }
     }
     /**
-     * Determines the MIME content type based on file extension.
-     */
-    getContentTypeForFile(filePath) {
-        const ext = filePath.toLowerCase().split('.').pop();
-        const contentTypes = {
-            json: 'application/json',
-            b3dm: 'application/octet-stream',
-            i3dm: 'application/octet-stream',
-            pnts: 'application/octet-stream',
-            cmpt: 'application/octet-stream',
-            glb: 'model/gltf-binary',
-            gltf: 'model/gltf+json',
-            bin: 'application/octet-stream',
-            png: 'image/png',
-            jpg: 'image/jpeg',
-            jpeg: 'image/jpeg',
-            webp: 'image/webp',
-            ktx2: 'image/ktx2'
-        };
-        return contentTypes[ext || ''] || 'application/octet-stream';
-    }
-    /**
-     * Override retrieve to include tileset.json URL in the response.
+     * List all tilesets with their public URLs.
      */
     async retrieve(req) {
         try {
             const assets = await this.getAllAssets();
-            const config = this.getConfiguration();
             const isAdmin = req && ApisixAuthParser.isAdmin(req.headers || {});
             // Get authenticated user ID if available
             let authenticatedUserId = null;
@@ -587,167 +311,114 @@ export class TilesetManager extends AssetsManager {
             const visibleAssets = isAdmin
                 ? assets
                 : assets.filter(asset => asset.is_public || (authenticatedUserId !== null && asset.owner_id === authenticatedUserId));
-            // Transform to include tileset URLs
-            const assetsWithUrls = visibleAssets.map(asset => {
-                const fileIndex = asset.file_index;
-                const rootFile = fileIndex?.root_file || 'tileset.json';
-                return {
-                    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,
-                    // Tileset-specific URLs
-                    file_count: fileIndex?.files?.length || 0,
-                    root_file: rootFile,
-                    tileset_url: `/${config.endpoint}/${asset.id}/files/${rootFile}`,
-                    files_base_url: `/${config.endpoint}/${asset.id}/files`
-                };
-            });
-            return {
-                status: 200,
-                content: JSON.stringify(assetsWithUrls),
-                headers: { 'Content-Type': 'application/json' }
-            };
+            // Transform to response format
+            const response = visibleAssets.map(asset => ({
+                id: asset.id,
+                description: asset.description || '',
+                filename: asset.filename || '',
+                date: asset.date,
+                owner_id: asset.owner_id || null,
+                is_public: asset.is_public ?? true,
+                tileset_url: asset.tileset_url || '',
+                upload_status: asset.upload_status || 'completed'
+            }));
+            return successResponse(response);
         }
         catch (error) {
-            return {
-                status: 500,
-                content: JSON.stringify({
-                    error: error instanceof Error ? error.message : 'Unknown error'
-                }),
-                headers: { 'Content-Type': 'application/json' }
-            };
+            return errorResponse(error);
         }
     }
     /**
-     * Override delete to clean up all extracted files.
+     * Delete tileset and all files from storage.
      */
     async handleDelete(req) {
         try {
-            // Check authentication (skip if auth is disabled)
-            let userId;
-            if (AuthConfig.isAuthDisabled()) {
-                const anonymousUser = {
-                    id: AuthConfig.getAnonymousUserId(),
-                    roles: []
-                };
-                const userRecord = await this.userService.findOrCreateUser(anonymousUser);
-                userId = userRecord.id;
-            }
-            else {
-                if (!ApisixAuthParser.hasValidAuth(req.headers || {})) {
-                    return {
-                        status: 401,
-                        content: JSON.stringify({ error: 'Authentication required' }),
-                        headers: { 'Content-Type': 'application/json' }
-                    };
-                }
-                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) {
-                    return {
-                        status: 500,
-                        content: JSON.stringify({ error: 'Failed to retrieve user information' }),
-                        headers: { 'Content-Type': 'application/json' }
-                    };
-                }
-                userId = userRecord.id;
+            // Authenticate user
+            const userId = await this.authenticateUser(req);
+            if (typeof userId !== 'number') {
+                return userId;
             }
             const { id } = req.params || {};
             if (!id) {
-                return {
-                    status: 400,
-                    content: JSON.stringify({ error: 'Asset ID is required' }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+                return badRequestResponse('Asset ID is required');
             }
-            // Get asset metadata
             const asset = await this.getAssetById(id);
             if (!asset) {
-                return {
-                    status: 404,
-                    content: JSON.stringify({ error: 'Tileset not found' }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+                return notFoundResponse('Tileset not found');
             }
-            // Check ownership (admins can delete any asset)
+            // Check ownership (admins can delete any)
             const isAdmin = ApisixAuthParser.isAdmin(req.headers || {});
             if (!isAdmin && asset.owner_id !== null && asset.owner_id !== userId) {
+                return forbiddenResponse('You can only delete your own assets');
+            }
+            // Block deletion while upload in progress
+            if (asset.upload_status === 'pending' || asset.upload_status === 'processing') {
                 return {
-                    status: 403,
-                    content: JSON.stringify({ error: 'You can only delete your own assets' }),
+                    status: 409,
+                    content: JSON.stringify({ error: 'Cannot delete tileset while upload is in progress' }),
                     headers: { 'Content-Type': 'application/json' }
                 };
             }
-            // Delete all extracted files from storage using batch delete for performance
-            const fileIndex = asset.file_index;
-            if (fileIndex?.files && fileIndex.files.length > 0) {
-                const filePaths = fileIndex.files.map(file => file.path);
-                await this.storage.deleteBatch(filePaths);
+            // Delete all files from storage
+            // Support both new format (url = basePath) and legacy format (file_index.files)
+            const legacyFileIndex = asset.file_index;
+            if (legacyFileIndex?.files && legacyFileIndex.files.length > 0) {
+                // Legacy format: delete individual files from file_index
+                console.log(`[TilesetManager] Deleting ${legacyFileIndex.files.length} files (legacy format)`);
+                for (const file of legacyFileIndex.files) {
+                    await this.storage.delete(file.path).catch(() => {
+                        // Ignore individual file deletion errors
+                    });
+                }
+            }
+            else if (asset.url) {
+                // New format: url contains basePath, use deleteByPrefix
+                const deletedCount = await this.storage.deleteByPrefix(asset.url);
+                console.log(`[TilesetManager] Deleted ${deletedCount} files from ${asset.url}`);
             }
             // Delete database record
             await this.deleteAssetById(id);
-            return {
-                status: 200,
-                content: JSON.stringify({ message: 'Tileset deleted successfully' }),
-                headers: { 'Content-Type': 'application/json' }
-            };
+            return successResponse({ message: 'Tileset 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);
         }
     }
     /**
-     * Override getEndpoints to add the file serving endpoint.
+     * Get HTTP endpoints for this manager.
      */
     getEndpoints() {
         const config = this.getConfiguration();
-        // Get base endpoints from parent but filter out ones we override
-        const baseEndpoints = super.getEndpoints().filter(ep => 
-        // Keep all except GET /:id (we don't serve the raw asset, only files)
-        // and DELETE /:id (we override to clean up files)
-        !(ep.method === 'get' && ep.path === `/${config.endpoint}/:id`) &&
-            !(ep.method === 'delete' && ep.path === `/${config.endpoint}/:id`) &&
-            // Also remove download endpoint - not applicable for extracted tilesets
-            !(ep.method === 'get' && ep.path === `/${config.endpoint}/:id/download`));
-        // IMPORTANT: More specific routes must come BEFORE less specific ones
-        // /:id/files/* and /:id/status must be registered before /:id to avoid incorrect matching
         return [
-            // Status endpoint FIRST (most specific)
+            // Status endpoint (for async upload polling)
             {
                 method: 'get',
                 path: `/${config.endpoint}/:id/status`,
                 handler: this.handleGetStatus.bind(this),
                 responseType: 'application/json'
             },
-            // File serving endpoint (also specific)
+            // List tilesets
             {
                 method: 'get',
-                path: `/${config.endpoint}/:id/files/*`,
-                handler: this.handleGetFile.bind(this),
-                responseType: 'application/octet-stream'
+                path: `/${config.endpoint}`,
+                handler: this.retrieve.bind(this),
+                responseType: 'application/json'
+            },
+            // Upload tileset
+            {
+                method: 'post',
+                path: `/${config.endpoint}`,
+                handler: this.handleUpload.bind(this),
+                responseType: 'application/json'
+            },
+            // Update metadata
+            {
+                method: 'put',
+                path: `/${config.endpoint}/:id`,
+                handler: this.handleUpdate.bind(this),
+                responseType: 'application/json'
             },
-            // Then base endpoints (list, create, update, etc.)
-            ...baseEndpoints,
-            // Override delete to clean up files (after base to override)
+            // Delete tileset
             {
                 method: 'delete',
                 path: `/${config.endpoint}/:id`,
@@ -757,99 +428,191 @@ export class TilesetManager extends AssetsManager {
         ];
     }
     /**
-     * Override OpenAPI specification to include tileset-specific endpoints.
+     * Generate OpenAPI specification.
      */
     getOpenAPISpec() {
-        const parentSpec = super.getOpenAPISpec();
         const config = this.getConfiguration();
         const basePath = `/${config.endpoint}`;
         const tagName = config.tags?.[0] || config.name;
-        // Update POST response
-        if (parentSpec.paths[basePath]?.post?.responses?.['200']) {
-            parentSpec.paths[basePath].post.responses['200'] = {
-                description: 'Tileset uploaded and extracted successfully',
-                content: {
-                    'application/json': {
-                        schema: {
-                            type: 'object',
-                            properties: {
-                                message: { type: 'string' },
-                                file_count: { type: 'integer', description: 'Number of files extracted' },
-                                root_file: { type: 'string', description: 'Root tileset.json path' },
-                                tileset_url: { type: 'string', description: 'URL to load in Cesium' }
+        return {
+            paths: {
+                [basePath]: {
+                    get: {
+                        summary: 'List all tilesets',
+                        description: 'Returns all tilesets with their public URLs for Cesium loading',
+                        tags: [tagName],
+                        responses: {
+                            '200': {
+                                description: 'List of tilesets',
+                                content: {
+                                    'application/json': {
+                                        schema: {
+                                            type: 'array',
+                                            items: { $ref: '#/components/schemas/TilesetResponse' }
+                                        }
+                                    }
+                                }
                             }
                         }
-                    }
-                }
-            };
-        }
-        // Add file serving endpoint
-        parentSpec.paths[`${basePath}/{id}/files/{filePath}`] = {
-            get: {
-                summary: 'Get tileset file',
-                description: 'Retrieve an extracted file from the tileset (tileset.json, .b3dm, etc.)',
-                tags: [tagName],
-                parameters: [
-                    {
-                        name: 'id',
-                        in: 'path',
-                        required: true,
-                        schema: { type: 'string' },
-                        description: 'Tileset ID'
                     },
-                    {
-                        name: 'filePath',
-                        in: 'path',
-                        required: true,
-                        schema: { type: 'string' },
-                        description: 'Path to file within tileset (e.g., tileset.json, tiles/tile_0.b3dm)'
+                    post: {
+                        summary: 'Upload a tileset',
+                        description: 'Upload a ZIP file containing a 3D Tiles tileset. Files < 50MB are processed synchronously, larger files are queued.',
+                        tags: [tagName],
+                        security: [{ ApiKeyAuth: [] }],
+                        requestBody: {
+                            required: true,
+                            content: {
+                                'multipart/form-data': {
+                                    schema: {
+                                        type: 'object',
+                                        required: ['file', 'description'],
+                                        properties: {
+                                            file: {
+                                                type: 'string',
+                                                format: 'binary',
+                                                description: 'ZIP file containing tileset'
+                                            },
+                                            description: { type: 'string', description: 'Tileset description' },
+                                            is_public: {
+                                                type: 'boolean',
+                                                description: 'Whether tileset is public (default: true)'
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        responses: {
+                            '200': {
+                                description: 'Tileset uploaded successfully (sync)',
+                                content: {
+                                    'application/json': {
+                                        schema: {
+                                            type: 'object',
+                                            properties: {
+                                                message: { type: 'string' },
+                                                id: { type: 'integer' },
+                                                tileset_url: {
+                                                    type: 'string',
+                                                    description: 'Public URL to load in Cesium'
+                                                },
+                                                file_count: { type: 'integer' }
+                                            }
+                                        }
+                                    }
+                                }
+                            },
+                            '202': {
+                                description: 'Upload accepted for async processing',
+                                content: {
+                                    'application/json': {
+                                        schema: {
+                                            type: 'object',
+                                            properties: {
+                                                message: { type: 'string' },
+                                                id: { type: 'integer' },
+                                                status: { type: 'string' },
+                                                status_url: { type: 'string' }
+                                            }
+                                        }
+                                    }
+                                }
+                            },
+                            '400': { description: 'Bad request - missing fields or invalid file' },
+                            '401': { description: 'Unauthorized' }
+                        }
+                    }
+                },
+                [`${basePath}/{id}/status`]: {
+                    get: {
+                        summary: 'Get upload status',
+                        description: 'Poll the status of an async upload',
+                        tags: [tagName],
+                        parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'string' } }],
+                        responses: {
+                            '200': {
+                                description: 'Upload status',
+                                content: {
+                                    'application/json': {
+                                        schema: {
+                                            type: 'object',
+                                            properties: {
+                                                id: { type: 'integer' },
+                                                status: {
+                                                    type: 'string',
+                                                    enum: ['pending', 'processing', 'completed', 'failed']
+                                                },
+                                                tileset_url: { type: 'string' },
+                                                error: { type: 'string' }
+                                            }
+                                        }
+                                    }
+                                }
+                            },
+                            '404': { description: 'Tileset not found' }
+                        }
                     }
-                ],
-                responses: {
-                    '200': {
-                        description: 'File content',
-                        content: {
-                            'application/octet-stream': {
-                                schema: { type: 'string', format: 'binary' }
+                },
+                [`${basePath}/{id}`]: {
+                    put: {
+                        summary: 'Update tileset metadata',
+                        tags: [tagName],
+                        security: [{ ApiKeyAuth: [] }],
+                        parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'string' } }],
+                        requestBody: {
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        type: 'object',
+                                        properties: {
+                                            description: { type: 'string' },
+                                            is_public: { type: 'boolean' }
+                                        }
+                                    }
+                                }
                             }
+                        },
+                        responses: {
+                            '200': { description: 'Updated successfully' },
+                            '401': { description: 'Unauthorized' },
+                            '403': { description: 'Forbidden' },
+                            '404': { description: 'Not found' }
                         }
                     },
-                    '404': { description: 'Tileset or file not found' }
+                    delete: {
+                        summary: 'Delete tileset',
+                        description: 'Delete tileset and all files from storage',
+                        tags: [tagName],
+                        security: [{ ApiKeyAuth: [] }],
+                        parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'string' } }],
+                        responses: {
+                            '200': { description: 'Deleted successfully' },
+                            '401': { description: 'Unauthorized' },
+                            '403': { description: 'Forbidden' },
+                            '404': { description: 'Not found' },
+                            '409': { description: 'Upload in progress' }
+                        }
+                    }
+                }
+            },
+            tags: [{ name: tagName, description: config.description }],
+            schemas: {
+                TilesetResponse: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'integer' },
+                        description: { type: 'string' },
+                        filename: { type: 'string' },
+                        date: { type: 'string', format: 'date-time' },
+                        owner_id: { type: 'integer', nullable: true },
+                        is_public: { type: 'boolean' },
+                        tileset_url: { type: 'string', description: 'Public URL to load in Cesium' },
+                        upload_status: { type: 'string', enum: ['pending', 'processing', 'completed', 'failed'] }
+                    }
                 }
             }
         };
-        // Update GET list response schema
-        if (parentSpec.schemas) {
-            parentSpec.schemas.TilesetResponse = {
-                type: 'object',
-                properties: {
-                    id: { type: 'integer' },
-                    name: { type: 'string' },
-                    date: { type: 'string', format: 'date-time' },
-                    contentType: { type: 'string' },
-                    description: { type: 'string' },
-                    source: { type: 'string' },
-                    owner_id: { type: 'integer', nullable: true },
-                    filename: { type: 'string' },
-                    is_public: { type: 'boolean' },
-                    file_count: { type: 'integer', description: 'Number of files in tileset' },
-                    root_file: { type: 'string', description: 'Root tileset.json filename' },
-                    tileset_url: { type: 'string', description: 'URL to load tileset in Cesium' },
-                    files_base_url: { type: 'string', description: 'Base URL for all tileset files' }
-                }
-            };
-        }
-        if (parentSpec.paths[basePath]?.get?.responses?.['200']?.content?.['application/json']) {
-            parentSpec.paths[basePath].get.responses['200'].content['application/json'].schema = {
-                type: 'array',
-                items: { $ref: '#/components/schemas/TilesetResponse' }
-            };
-        }
-        // Remove the single asset GET endpoint since we don't serve raw assets
-        delete parentSpec.paths[`${basePath}/{id}`]?.get;
-        // Remove download endpoint
-        delete parentSpec.paths[`${basePath}/{id}/download`];
-        return parentSpec;
     }
 }
 //# sourceMappingURL=tileset_manager.js.map