@cepseudo/assets 1.0.0

package/dist/assets_manager.d.ts

@@ -0,0 +1,643 @@
+import type { Component, Servable, AssetsManagerConfiguration, DataResponse, HttpMethod, OpenAPIDocumentable, OpenAPIComponentSpec, DataRecord, AuthResult, TypedRequest } from '@cepseudo/shared';
+import type { StorageService } from '@cepseudo/storage';
+import type { DatabaseAdapter, MetadataRow } from '@cepseudo/database';
+import { AuthMiddleware, type HeadersLike } from '@cepseudo/auth';
+import { PresignedUploadService } from './presigned_upload_service.js';
+/**
+ * Extended metadata row for assets with additional fields.
+ * This will be stored as separate columns in the database table.
+ *
+ * @interface AssetMetadataRow
+ * @extends {MetadataRow}
+ *
+ * @example
+ * ```typescript
+ * const assetMeta: AssetMetadataRow = {
+ *   name: 'gltf',
+ *   type: 'model/gltf-binary',
+ *   url: '/storage/gltf/model.glb',
+ *   date: new Date(),
+ *   description: '3D building model',
+ *   source: 'https://example.com/data-source',
+ *   owner_id: 123,
+ *   filename: 'building.glb',
+ *   is_public: true
+ * }
+ * ```
+ */
+export interface AssetMetadataRow extends MetadataRow {
+    /** Human-readable description of the asset */
+    description: string;
+    /** Source URL for data provenance and licensing compliance (must be valid URL) */
+    source: string;
+    /** ID of the user who owns this asset (for access control) */
+    owner_id: number | null;
+    /** Original filename provided by the user */
+    filename: string;
+    /** Whether the asset is publicly accessible (true) or private (false) */
+    is_public: boolean;
+}
+/**
+ * Request payload for creating a new asset.
+ *
+ * @interface CreateAssetRequest
+ *
+ * @example
+ * ```typescript
+ * const request: CreateAssetRequest = {
+ *   description: '3D model of building',
+ *   source: 'https://city-data.example.com/buildings',
+ *   owner_id: 'user123',
+ *   filename: 'building.glb',
+ *   file: fileBuffer,
+ *   is_public: true
+ * }
+ * ```
+ */
+export interface CreateAssetRequest {
+    /** Human-readable description of the asset */
+    description: string;
+    /** Source URL for data provenance (validated as proper URL) */
+    source: string;
+    /** Owner user ID for access control (can be null) */
+    owner_id: number | null;
+    /** Original filename */
+    filename: string;
+    /** File content as Buffer */
+    file: Buffer;
+    /** Whether the asset is publicly accessible (default: true) */
+    is_public?: boolean;
+}
+/**
+ * Request payload for updating asset metadata.
+ *
+ * @interface UpdateAssetRequest
+ *
+ * @example
+ * ```typescript
+ * const updates: UpdateAssetRequest = {
+ *   description: 'Updated building model with new textures',
+ *   source: 'https://updated-source.example.com',
+ *   is_public: false
+ * }
+ * ```
+ */
+export interface UpdateAssetRequest {
+    /** Updated description (optional) */
+    description?: string;
+    /** Updated source URL (optional, validated if provided) */
+    source?: string;
+    /** Updated visibility (optional) */
+    is_public?: boolean;
+}
+/**
+ * Abstract base class for Assets Manager components with authentication and access control.
+ *
+ * Provides secure file upload, storage, and retrieval capabilities following the Digital Twin framework patterns.
+ * Each concrete implementation manages a specific type of asset and creates its own database table.
+ *
+ * ## Authentication & Authorization
+ *
+ * - **Write Operations** (POST, PUT, DELETE): Require authentication via Apache APISIX headers
+ * - **User Management**: Automatically creates/updates user records from Keycloak data
+ * - **Access Control**: Users can only modify/delete their own assets (ownership-based)
+ * - **Resource Linking**: Assets are automatically linked to their owners via user_id foreign key
+ *
+ * ## Required Headers for Authenticated Endpoints
+ *
+ * - `x-user-id`: Keycloak user UUID (required)
+ * - `x-user-roles`: Comma-separated list of user roles (optional)
+ *
+ * These headers are automatically added by Apache APISIX after successful Keycloak authentication.
+ *
+ * @abstract
+ * @class AssetsManager
+ * @implements {Component}
+ * @implements {Servable}
+ *
+ * @example
+ * ```typescript
+ * // Create concrete implementations for different asset types
+ * class GLTFAssetsManager extends AssetsManager {
+ *   getConfiguration() {
+ *     return { name: 'gltf', description: 'GLTF 3D models manager', ... }
+ *   }
+ * }
+ *
+ * class PointCloudAssetsManager extends AssetsManager {
+ *   getConfiguration() {
+ *     return { name: 'pointcloud', description: 'Point cloud data manager', ... }
+ *   }
+ * }
+ *
+ * // Usage in engine
+ * const gltfManager = new GLTFAssetsManager()
+ * gltfManager.setDependencies(database, storage)
+ *
+ * // Each creates its own table and endpoints:
+ * // - GLTFAssetsManager → table 'gltf', endpoints /gltf/*
+ * // - PointCloudAssetsManager → table 'pointcloud', endpoints /pointcloud/*
+ * ```
+ *
+ * @remarks
+ * Asset metadata is stored as dedicated columns in the database table:
+ * - id, name, url, date (standard columns)
+ * - description, source, owner_id, filename (asset-specific columns)
+ *
+ * Each concrete AssetsManager creates its own table based on the configuration name.
+ */
+export declare abstract class AssetsManager implements Component, Servable, OpenAPIDocumentable {
+    protected db: DatabaseAdapter;
+    protected storage: StorageService;
+    protected authMiddleware: AuthMiddleware;
+    protected presignedService: PresignedUploadService;
+    /**
+     * Injects dependencies into the assets manager.
+     *
+     * Called by the framework during component initialization.
+     *
+     * @param {DatabaseAdapter} db - The database adapter for metadata storage
+     * @param {StorageService} storage - The storage service for file persistence
+     * @param {AuthMiddleware} [authMiddleware] - Optional auth middleware for authentication (created automatically if not provided)
+     *
+     * @example
+     * ```typescript
+     * // Standard usage (AuthMiddleware created automatically)
+     * const assetsManager = new MyAssetsManager()
+     * assetsManager.setDependencies(databaseAdapter, storageService)
+     *
+     * // For testing (inject mock AuthMiddleware)
+     * assetsManager.setDependencies(databaseAdapter, storageService, mockAuthMiddleware)
+     * ```
+     */
+    setDependencies(db: DatabaseAdapter, storage: StorageService, authMiddleware?: AuthMiddleware): void;
+    /**
+     * Returns the configuration of the assets manager.
+     *
+     * Must be implemented by subclasses to define the asset type,
+     * table name, and content types.
+     *
+     * @abstract
+     * @returns {ComponentConfiguration} The component configuration
+     *
+     * @example
+     * ```typescript
+     * class GLTFAssetsManager extends AssetsManager {
+     *   getConfiguration(): ComponentConfiguration {
+     *     return {
+     *       name: 'gltf',
+     *       description: 'GLTF 3D models manager',
+     *       contentType: 'model/gltf-binary',
+     *       tags: ['assets', '3d', 'gltf']
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    abstract getConfiguration(): AssetsManagerConfiguration;
+    /**
+     * Validates that a source string is a valid URL.
+     *
+     * Used internally to ensure data provenance URLs are properly formatted.
+     *
+     * @private
+     * @param {string} source - The source URL to validate
+     * @returns {boolean} True if the source is a valid URL, false otherwise
+     *
+     * @example
+     * ```typescript
+     * this.validateSourceURL('https://example.com/data') // returns true
+     * this.validateSourceURL('not-a-url') // returns false
+     * ```
+     */
+    private validateSourceURL;
+    /**
+     * Validates that a filename has the correct extension as configured.
+     *
+     * Used internally to ensure uploaded files match the expected extension.
+     *
+     * @private
+     * @param {string} filename - The filename to validate
+     * @returns {boolean} True if the filename has the correct extension or no extension is configured, false otherwise
+     *
+     * @example
+     * ```typescript
+     * // If config.extension = '.glb'
+     * this.validateFileExtension('model.glb') // returns true
+     * this.validateFileExtension('model.json') // returns false
+     * this.validateFileExtension('model') // returns false
+     *
+     * // If config.extension is undefined
+     * this.validateFileExtension('any-file.ext') // returns true
+     * ```
+     */
+    protected validateFileExtension(filename: string): boolean;
+    /**
+     * Validates that a string is valid base64-encoded data.
+     *
+     * Used internally to ensure file data in batch uploads is properly base64-encoded
+     * before attempting to decode it.
+     *
+     * @private
+     * @param {any} data - Data to validate as base64
+     * @returns {boolean} True if data is a valid base64 string, false otherwise
+     *
+     * @example
+     * ```typescript
+     * this.validateBase64('SGVsbG8gV29ybGQ=') // returns true
+     * this.validateBase64('not-base64!@#') // returns false
+     * this.validateBase64(123) // returns false (not a string)
+     * this.validateBase64('') // returns false (empty string)
+     * ```
+     */
+    private validateBase64;
+    /**
+     * Authenticates a request and returns the user record.
+     *
+     * This method consolidates the authentication flow:
+     * 1. Validates APISIX headers are present
+     * 2. Parses authentication headers
+     * 3. Finds or creates user record in database
+     *
+     * @param req - HTTP request object
+     * @returns AuthResult with either userRecord on success or DataResponse on failure
+     *
+     * @example
+     * ```typescript
+     * const authResult = await this.authenticateRequest(req)
+     * if (!authResult.success) {
+     *     return authResult.response
+     * }
+     * const userRecord = authResult.userRecord
+     * ```
+     */
+    protected authenticateRequest(req: TypedRequest): Promise<AuthResult>;
+    /**
+     * Extracts upload data from multipart form request.
+     *
+     * @param req - HTTP request object with body and file
+     * @returns UploadData object with extracted fields
+     */
+    private extractUploadData;
+    /**
+     * Validates required fields for asset upload and returns validated data.
+     *
+     * @param data - Upload data to validate
+     * @returns UploadValidationResult with validated data on success or error response on failure
+     */
+    private validateUploadFields;
+    /**
+     * Reads file content from temporary upload path.
+     *
+     * @param filePath - Path to temporary file
+     * @returns Buffer with file content
+     * @throws Error if file cannot be read
+     */
+    private readTempFile;
+    /**
+     * Cleans up temporary file after processing.
+     * Logs cleanup errors but doesn't throw.
+     *
+     * @param filePath - Path to temporary file
+     */
+    private cleanupTempFile;
+    /**
+     * Validates ownership of an asset.
+     *
+     * Admins can modify any asset. Regular users can only modify their own assets
+     * or assets with no owner (owner_id = null).
+     *
+     * @param asset - Asset record to check
+     * @param userId - User ID to validate against
+     * @param headers - HTTP request headers (optional, for admin check)
+     * @returns DataResponse with error if not owner/admin, undefined if valid
+     */
+    protected validateOwnership(asset: DataRecord, userId: number, headers?: HeadersLike): DataResponse | undefined;
+    /**
+     * Checks if a user can access a private asset.
+     *
+     * @param asset - Asset record to check
+     * @param req - HTTP request for authentication context
+     * @returns DataResponse with error if access denied, undefined if allowed
+     */
+    private checkPrivateAssetAccess;
+    /**
+     * Fetches an asset by ID with full access control validation.
+     *
+     * This method consolidates the common logic for retrieving an asset:
+     * 1. Validates that ID is provided
+     * 2. Fetches the asset from database
+     * 3. Verifies the asset belongs to this component
+     * 4. Checks access permissions for private assets
+     *
+     * @param req - HTTP request with params.id
+     * @returns Object with asset on success, or DataResponse on failure
+     */
+    private fetchAssetWithAccessCheck;
+    /**
+     * Upload a new asset file with metadata.
+     *
+     * Stores the file using the storage service and saves metadata to the database.
+     * Asset metadata is stored as dedicated columns in the database table.
+     *
+     * @param {CreateAssetRequest} request - The asset upload request
+     * @throws {Error} If source URL is invalid
+     *
+     * @example
+     * ```typescript
+     * await assetsManager.uploadAsset({
+     *   description: '3D building model',
+     *   source: 'https://city-data.example.com/buildings',
+     *   owner_id: 'user123',
+     *   filename: 'building.glb',
+     *   file: fileBuffer,
+     *   is_public: true
+     * })
+     * ```
+     */
+    uploadAsset(request: CreateAssetRequest): Promise<void>;
+    /**
+     * Retrieve all assets for this component (like other components).
+     *
+     * Returns a JSON list of all assets with their metadata, following the
+     * framework pattern but adapted for assets management.
+     *
+     * Access control:
+     * - Unauthenticated users: Can only see public assets
+     * - Authenticated users: Can see public assets + their own private assets
+     * - Admin users: Can see all assets (public and private from all users)
+     *
+     * @returns {Promise<DataResponse>} JSON response with all assets
+     */
+    retrieve(req?: TypedRequest): Promise<DataResponse>;
+    /**
+     * Gets the authenticated user's database ID from request headers.
+     *
+     * @param req - HTTP request object
+     * @returns User ID or null if not authenticated
+     */
+    private getAuthenticatedUserId;
+    /**
+     * Formats assets for API response with metadata and URLs.
+     *
+     * @param assets - Array of asset records
+     * @returns Formatted assets array ready for JSON serialization
+     */
+    private formatAssetsForResponse;
+    /**
+     * Get all assets for this component type.
+     *
+     * Retrieves all assets managed by this component, with their metadata.
+     * Uses a very old start date to get all records.
+     *
+     * @returns {Promise<DataRecord[]>} Array of all asset records
+     *
+     * @example
+     * ```typescript
+     * const allAssets = await assetsManager.getAllAssets()
+     * // Returns: [{ id, name, type, url, date, contentType }, ...]
+     * ```
+     */
+    getAllAssets(): Promise<DataRecord[]>;
+    /**
+     * Get asset by specific ID.
+     *
+     * @param {string} id - The asset ID to retrieve
+     * @returns {Promise<DataRecord | undefined>} The asset record or undefined if not found
+     *
+     * @example
+     * ```typescript
+     * const asset = await assetsManager.getAssetById('123')
+     * if (asset) {
+     *   const fileData = await asset.data()
+     * }
+     * ```
+     */
+    getAssetById(id: string): Promise<DataRecord | undefined>;
+    /**
+     * Update asset metadata by ID.
+     *
+     * Updates the metadata (description, source, and/or visibility) of a specific asset.
+     * Asset metadata is stored as dedicated columns in the database.
+     *
+     * @param {string} id - The ID of the asset to update
+     * @param {UpdateAssetRequest} updates - The metadata updates to apply
+     * @throws {Error} If source URL is invalid or asset not found
+     *
+     * @example
+     * ```typescript
+     * await assetsManager.updateAssetMetadata('123', {
+     *   description: 'Updated building model with new textures',
+     *   source: 'https://updated-source.example.com',
+     *   is_public: false
+     * })
+     * ```
+     */
+    updateAssetMetadata(id: string, updates: UpdateAssetRequest): Promise<void>;
+    /**
+     * Delete asset by ID.
+     *
+     * Removes a specific asset.
+     *
+     * @param {string} id - The ID of the asset to delete
+     * @throws {Error} If asset not found or doesn't belong to this component
+     *
+     * @example
+     * ```typescript
+     * await assetsManager.deleteAssetById('123')
+     * ```
+     */
+    deleteAssetById(id: string): Promise<void>;
+    /**
+     * Delete latest asset (simplified)
+     *
+     * Removes the most recently uploaded asset for this component type.
+     *
+     * @throws {Error} If no assets exist to delete
+     *
+     * @example
+     * ```typescript
+     * await assetsManager.deleteLatestAsset()
+     * ```
+     */
+    deleteLatestAsset(): Promise<void>;
+    /**
+     * Upload multiple assets in batch for better performance
+     *
+     * @param {CreateAssetRequest[]} requests - Array of asset upload requests
+     * @throws {Error} If any source URL is invalid
+     *
+     * @example
+     * ```typescript
+     * await assetsManager.uploadAssetsBatch([
+     *   { description: 'Model 1', source: 'https://example.com/1', file: buffer1, ... },
+     *   { description: 'Model 2', source: 'https://example.com/2', file: buffer2, ... }
+     * ])
+     * ```
+     */
+    uploadAssetsBatch(requests: CreateAssetRequest[]): Promise<void>;
+    /**
+     * Delete multiple assets by IDs in batch
+     *
+     * @param {string[]} ids - Array of asset IDs to delete
+     * @throws {Error} If any asset not found or doesn't belong to this component
+     */
+    deleteAssetsBatch(ids: string[]): Promise<void>;
+    /**
+     * Get endpoints following the framework pattern
+     */
+    /**
+     * Get HTTP endpoints exposed by this assets manager.
+     *
+     * Returns the standard CRUD endpoints following the framework pattern.
+     *
+     * @returns {Array} Array of endpoint descriptors with methods, paths, and handlers
+     *
+     * @example
+     * ```typescript
+     * // For a manager with assetType: 'gltf', provides:
+     * GET    /gltf         - Get all assets
+     * POST   /gltf/upload  - Upload new asset
+     * GET    /gltf/123     - Get specific asset
+     * PUT    /gltf/123     - Update asset metadata
+     * GET    /gltf/123/download - Download asset
+     * DELETE /gltf/123     - Delete asset
+     * ```
+     */
+    getEndpoints(): Array<{
+        method: HttpMethod;
+        path: string;
+        handler: (req: TypedRequest) => Promise<DataResponse>;
+        responseType?: string;
+    }>;
+    /**
+     * Returns the OpenAPI specification for this assets manager's endpoints.
+     *
+     * Generates documentation for all CRUD endpoints including batch operations.
+     * Can be overridden by subclasses for more detailed specifications.
+     *
+     * @returns {OpenAPIComponentSpec} OpenAPI paths, tags, and schemas for this assets manager
+     */
+    getOpenAPISpec(): OpenAPIComponentSpec;
+    /**
+     * Handle presigned upload URL request.
+     * Delegates to PresignedUploadService.
+     */
+    handlePresignedUploadRequest(req: TypedRequest): Promise<DataResponse>;
+    /**
+     * Handle presigned upload confirmation.
+     * Delegates to PresignedUploadService.
+     */
+    handleUploadConfirm(req: TypedRequest): Promise<DataResponse>;
+    /**
+     * Handle single asset upload via HTTP POST (multipart/form-data).
+     */
+    handleUpload(req: TypedRequest): Promise<DataResponse>;
+    /**
+     * Handle update endpoint (PUT).
+     *
+     * Updates metadata for a specific asset by ID.
+     *
+     * @param {any} req - HTTP request object with params.id and body containing updates
+     * @returns {Promise<DataResponse>} HTTP response
+     *
+     * @example
+     * ```typescript
+     * // PUT /gltf/123
+     * // Body: { "description": "Updated model", "source": "https://new-source.com" }
+     * ```
+     */
+    handleUpdate(req: TypedRequest): Promise<DataResponse>;
+    /**
+     * Handle get asset endpoint (GET).
+     *
+     * Returns the file content of a specific asset by ID for display/use in front-end.
+     * No download headers - just the raw file content.
+     *
+     * Access control:
+     * - Public assets: Accessible to everyone
+     * - Private assets: Accessible only to owner
+     * - Admin users: Can access all assets (public and private)
+     *
+     * @param {any} req - HTTP request object with params.id
+     * @returns {Promise<DataResponse>} HTTP response with file content
+     *
+     * @example
+     * ```typescript
+     * // GET /gltf/123
+     * // Returns the .glb file content for display in 3D viewer
+     * ```
+     */
+    handleGetAsset(req: TypedRequest): Promise<DataResponse>;
+    /**
+     * Handle download endpoint (GET).
+     *
+     * Downloads the file content of a specific asset by ID with download headers.
+     * Forces browser to download the file rather than display it.
+     *
+     * Access control:
+     * - Public assets: Accessible to everyone
+     * - Private assets: Accessible only to owner
+     * - Admin users: Can download all assets (public and private)
+     *
+     * @param {any} req - HTTP request object with params.id
+     * @returns {Promise<DataResponse>} HTTP response with file content and download headers
+     *
+     * @example
+     * ```typescript
+     * // GET /gltf/123/download
+     * // Returns the .glb file with download headers - browser will save it
+     * ```
+     */
+    handleDownload(req: TypedRequest): Promise<DataResponse>;
+    /**
+     * Handle delete endpoint (DELETE).
+     *
+     * Deletes a specific asset by ID.
+     *
+     * @param {any} req - HTTP request object with params.id
+     * @returns {Promise<DataResponse>} HTTP response
+     *
+     * @example
+     * ```typescript
+     * // DELETE /gltf/123
+     * ```
+     */
+    handleDelete(req: TypedRequest): Promise<DataResponse>;
+    /**
+     * Handle batch upload endpoint
+     */
+    handleUploadBatch(req: TypedRequest): Promise<DataResponse>;
+    /**
+     * Validates all requests in a batch upload.
+     *
+     * @param requests - Array of upload requests to validate
+     * @returns DataResponse with error if validation fails, undefined if valid
+     */
+    private validateBatchRequests;
+    /**
+     * Processes batch upload requests.
+     *
+     * @param requests - Array of upload requests
+     * @param ownerId - Owner user ID
+     * @returns Array of results for each upload
+     */
+    private processBatchUploads;
+    /**
+     * Handle batch delete endpoint
+     */
+    handleDeleteBatch(req: TypedRequest): Promise<DataResponse>;
+    /**
+     * Processes batch delete requests.
+     *
+     * Admins can delete any asset. Regular users can only delete their own assets
+     * or assets with no owner.
+     *
+     * @param ids - Array of asset IDs to delete
+     * @param userId - User ID for ownership validation
+     * @param headers - HTTP request headers (for admin check)
+     * @returns Array of results for each deletion
+     */
+    private processBatchDeletes;
+}
+//# sourceMappingURL=assets_manager.d.ts.map

package/dist/assets_manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assets_manager.d.ts","sourceRoot":"","sources":["../src/assets_manager.ts"],"names":[],"mappings":"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"}