digitaltwin-core 0.13.1 → 0.13.3

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,123 +63,101 @@ 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
+     * Handle tileset upload.
      *
-     * 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
-     *
-     * @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');
             }
             // Authenticate user
-            let userId;
-            if (AuthConfig.isAuthDisabled()) {
-                const userRecord = await this.userService.findOrCreateUser({
-                    id: AuthConfig.getAnonymousUserId(),
-                    roles: []
-                });
-                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;
+            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;
-            // Cleanup temp file and return error response
-            const cleanupAndReturn = async (status, error) => {
+            const fileSize = req.file?.size || fileBuffer?.length || 0;
+            if (!filePath && !fileBuffer) {
+                return badRequestResponse('Missing required field: ZIP file');
+            }
+            if (!description) {
                 if (filePath)
                     await fs.unlink(filePath).catch(() => { });
-                return { status, content: JSON.stringify({ error }), headers: { 'Content-Type': 'application/json' } };
-            };
-            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: description');
+            }
+            if (!filename) {
+                if (filePath)
+                    await fs.unlink(filePath).catch(() => { });
+                return badRequestResponse('Filename could not be determined from uploaded file');
+            }
+            if (!filename.toLowerCase().endsWith('.zip')) {
+                if (filePath)
+                    await fs.unlink(filePath).catch(() => { });
+                return badRequestResponse('Invalid file extension. Expected: .zip');
             }
-            if (!description)
-                return cleanupAndReturn(400, 'Missing required fields: description');
-            if (!filename)
-                return cleanupAndReturn(400, 'Filename could not be determined from uploaded file');
-            if (!filename.toLowerCase().endsWith('.zip'))
-                return cleanupAndReturn(400, 'Invalid file extension. Expected: .zip');
             const config = this.getConfiguration();
-            // Route to async or sync handler based on queue availability
-            if (this.uploadQueue && filePath) {
-                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);
             }
-            return this.handleSyncUpload(req, userId, filePath, fileBuffer, filename, description, config);
+            return this.handleSyncUpload(userId, filePath, fileBuffer, filename, description, isPublic, config);
         }
         catch (error) {
             if (req.file?.path)
                 await fs.unlink(req.file.path).catch(() => { });
-            return {
-                status: 500,
-                content: JSON.stringify({ error: error instanceof Error ? error.message : 'Unknown error' }),
-                headers: { 'Content-Type': 'application/json' }
-            };
+            return errorResponse(error);
+        }
+    }
+    /**
+     * Authenticate user from request headers.
+     * Returns user ID on success, or error response on failure.
+     */
+    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(req, userId, filePath, filename, description, config) {
+    async handleAsyncUpload(userId, filePath, filename, description, isPublic, config) {
         let recordId = null;
         try {
-            // Create pending record - will be updated by worker when complete
+            // Create pending record (url will be updated after extraction)
             const metadata = {
                 name: config.name,
                 type: 'application/json',
                 url: '',
+                tileset_url: '',
                 date: new Date(),
                 description,
-                source: req.body.source || '',
-                owner_id: userId,
                 filename,
-                is_public: req.body.is_public !== undefined ? Boolean(req.body.is_public) : true,
+                owner_id: userId,
+                is_public: isPublic,
                 upload_status: 'pending'
             };
             const savedRecord = await this.db.save(metadata);
@@ -204,7 +190,6 @@ export class TilesetManager extends AssetsManager {
             };
         }
         catch (error) {
-            // Cleanup on failure: remove DB record and temp file
             if (recordId !== null)
                 await this.db.delete(String(recordId), config.name).catch(() => { });
             await fs.unlink(filePath).catch(() => { });
@@ -212,64 +197,55 @@ export class TilesetManager extends AssetsManager {
         }
     }
     /**
-     * Process upload synchronously (fallback when queue unavailable).
+     * Process upload synchronously.
      */
-    async handleSyncUpload(req, userId, filePath, fileBuffer, filename, description, config) {
+    async handleSyncUpload(userId, filePath, fileBuffer, filename, description, isPublic, config) {
         let zipBuffer;
         try {
-            zipBuffer = fileBuffer || (filePath ? await fs.readFile(filePath) : null);
-            if (!zipBuffer)
+            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();
-            const basePath = `${config.name}/${now.getTime()}`;
+            // 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);
             if (!extractResult.root_file) {
-                if (extractResult.files.length > 0) {
-                    await this.storage.deleteBatch(extractResult.files.map(f => f.path));
-                }
-                return {
-                    status: 400,
-                    content: JSON.stringify({ error: 'Invalid tileset: no tileset.json found in the ZIP archive' }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+                // 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',
                 url: basePath,
-                date: now,
+                tileset_url: tilesetUrl,
+                date: new Date(),
                 description,
-                source: req.body.source || '',
-                owner_id: userId,
                 filename,
-                is_public: req.body.is_public !== undefined ? Boolean(req.body.is_public) : true,
-                file_index: { files: extractResult.files, root_file: extractResult.root_file }
+                owner_id: userId,
+                is_public: isPublic,
+                upload_status: 'completed'
             };
             const savedRecord = await this.db.save(metadata);
+            // 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) {
             if (filePath)
@@ -278,190 +254,49 @@ export class TilesetManager extends AssetsManager {
         }
     }
     /**
-     * Get upload status for polling. Returns: pending | processing | completed | failed
+     * 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;
-            // Completed if upload_status says so, or legacy sync upload with file_index
-            const isCompleted = record.upload_status === 'completed' ||
-                (!record.upload_status && fileIndex?.files && fileIndex.files.length > 0);
-            if (isCompleted) {
-                return {
-                    status: 200,
-                    content: JSON.stringify({
-                        id: record.id,
-                        status: 'completed',
-                        tileset_url: `/${config.endpoint}/${record.id}/files/${fileIndex?.root_file || 'tileset.json'}`,
-                        file_count: fileIndex?.files?.length || 0
-                    }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
-            }
-            // Broken record: no status and no files
-            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 {
-                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 extracted tileset file (tileset.json, .b3dm, textures, etc.)
-     */
-    async handleGetFile(req) {
-        try {
-            const { id } = req.params || {};
-            // Extract file path from wildcard param (Express 4.x/5.x compatibility)
-            let filePath = req.params[0] || req.params['0'] || req.params['*'] || req.params.path || req.params['*0'];
-            if (!filePath && req.url) {
-                const match = req.url.match(/\/files\/(.+)$/);
-                if (match)
-                    filePath = decodeURIComponent(match[1]);
-            }
-            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' }
-                };
-            const asset = await this.getAssetById(id);
-            const config = this.getConfiguration();
-            if (!asset || asset.name !== config.name) {
-                return {
-                    status: 404,
-                    content: JSON.stringify({ error: 'Tileset not found' }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
-            }
-            // Check access for private assets
-            if (!asset.is_public && !ApisixAuthParser.isAdmin(req.headers || {})) {
-                if (!ApisixAuthParser.hasValidAuth(req.headers || {})) {
-                    return {
-                        status: 401,
-                        content: JSON.stringify({ error: 'Authentication required for private assets' }),
-                        headers: { 'Content-Type': 'application/json' }
-                    };
-                }
-                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' }
-                        };
-                    }
-                }
-            }
-            const storagePath = `${asset.url}/${filePath}`;
-            let fileContent;
-            try {
-                fileContent = await this.storage.retrieve(storagePath);
+                    status: 'completed',
+                    tileset_url: record.tileset_url
+                });
             }
-            catch {
-                return {
-                    status: 404,
-                    content: JSON.stringify({ error: 'File not found' }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+            if (record.upload_status === 'failed') {
+                return successResponse({
+                    id: record.id,
+                    status: 'failed',
+                    error: record.upload_error || 'Upload failed'
+                });
             }
-            return {
-                status: 200,
-                content: fileContent,
-                headers: { 'Content-Type': this.getContentTypeForFile(filePath), 'Access-Control-Allow-Origin': '*' }
-            };
+            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;
@@ -476,109 +311,48 @@ 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);
         }
     }
     /**
-     * Delete tileset and all extracted files from storage.
+     * Delete tileset and all files from storage.
      */
     async handleDelete(req) {
         try {
             // Authenticate user
-            let userId;
-            if (AuthConfig.isAuthDisabled()) {
-                const userRecord = await this.userService.findOrCreateUser({
-                    id: AuthConfig.getAnonymousUserId(),
-                    roles: []
-                });
-                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;
+            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' }
-                };
+            if (!id) {
+                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' }
-                };
+            if (!asset) {
+                return notFoundResponse('Tileset not found');
+            }
             // Check ownership (admins can delete any)
             const isAdmin = ApisixAuthParser.isAdmin(req.headers || {});
             if (!isAdmin && asset.owner_id !== null && asset.owner_id !== userId) {
-                return {
-                    status: 403,
-                    content: JSON.stringify({ error: 'You can only delete your own assets' }),
-                    headers: { 'Content-Type': 'application/json' }
-                };
+                return forbiddenResponse('You can only delete your own assets');
             }
-            // Block deletion while upload in progress to prevent orphan files
-            const record = asset;
-            if (record.upload_status === 'pending' || record.upload_status === 'processing') {
+            // Block deletion while upload in progress
+            if (asset.upload_status === 'pending' || asset.upload_status === 'processing') {
                 return {
                     status: 409,
                     content: JSON.stringify({ error: 'Cannot delete tileset while upload is in progress' }),
@@ -586,58 +360,65 @@ export class TilesetManager extends AssetsManager {
                 };
             }
             // Delete all files from storage
-            const fileIndex = asset.file_index;
-            if (fileIndex?.files?.length) {
-                await this.storage.deleteBatch(fileIndex.files.map(f => f.path));
+            // 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'
             },
-            // Then base endpoints (list, create, update, etc.)
-            ...baseEndpoints,
-            // Override delete to clean up files (after base to override)
+            // 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'
+            },
+            // Delete tileset
             {
                 method: 'delete',
                 path: `/${config.endpoint}/:id`,
@@ -647,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' }
+                        }
                     }
-                ],
-                responses: {
-                    '200': {
-                        description: 'File content',
-                        content: {
-                            'application/octet-stream': {
-                                schema: { type: 'string', format: 'binary' }
+                },
+                [`${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' }
+                        }
+                    }
+                },
+                [`${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