alepha 0.10.6 → 0.11.0

package/api/verifications.cjs

@@ -0,0 +1,8 @@
+'use strict';
+var m = require('@alepha/api-verifications');
+Object.keys(m).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return m[k]; }
+	});
+});

package/api/verifications.d.ts

@@ -0,0 +1 @@
+export * from '@alepha/api-verifications';

package/api/verifications.js

@@ -0,0 +1 @@
+export * from '@alepha/api-verifications'

package/batch.d.ts

@@ -533,7 +533,7 @@ declare class BatchDescriptor<TItem extends TSchema, TResponse = any> extends De
   protected readonly dateTime: DateTimeProvider;
   protected readonly partitions: Map<any, any>;
   protected activeHandlers: PromiseWithResolvers<void>[];
-  protected retry: _alepha_retry0.RetryDescriptorFn<(items: typebox0.StaticType<[], "Encode", {}, {}, TItem>[]) => TResponse>;
+  protected retry: _alepha_retry0.RetryDescriptorFn<(items: typebox0.StaticType<[], "Decode", {}, {}, TItem>[]) => TResponse>;
   /**
    * Pushes an item into the batch. The item will be processed
    * asynchronously with other items when the batch is flushed.

package/bucket.d.ts

@@ -187,200 +187,6 @@ declare class MemoryFileStorageProvider implements FileStorageProvider {
  *   }
  * }
  * ```
- *
- * @example
- * **Cloud storage integration with custom provider:**
- * ```ts
- * class ProductImageService {
- *   productImages = $bucket({
- *     name: "product-images",
- *     provider: S3FileStorageProvider, // Use AWS S3 for production storage
- *     description: "Product catalog images and thumbnails",
- *     mimeTypes: ["image/jpeg", "image/png", "image/webp"],
- *     maxSize: 10 // 10MB for high-quality product images
- *   });
- *
- *   thumbnails = $bucket({
- *     name: "product-thumbnails",
- *     provider: S3FileStorageProvider,
- *     description: "Generated product thumbnail images",
- *     mimeTypes: ["image/jpeg", "image/webp"],
- *     maxSize: 1 // 1MB for thumbnails
- *   });
- *
- *   async uploadProductImage(productId: string, file: FileLike): Promise<{ imageId: string; thumbnailId: string }> {
- *     try {
- *       // Upload original image
- *       const imageId = await this.productImages.upload(file);
- *
- *       // Generate and upload thumbnail
- *       const thumbnailFile = await this.imageProcessor.generateThumbnail(file, {
- *         width: 300,
- *         height: 300,
- *         format: 'webp',
- *         quality: 80
- *       });
- *
- *       const thumbnailId = await this.thumbnails.upload(thumbnailFile);
- *
- *       // Update product in database
- *       await this.database.products.update(productId, {
- *         imageId,
- *         thumbnailId,
- *         imageUpdatedAt: new Date()
- *       });
- *
- *       console.log(`Product images uploaded for ${productId}: image=${imageId}, thumbnail=${thumbnailId}`);
- *
- *       return { imageId, thumbnailId };
- *
- *     } catch (error) {
- *       console.error(`Failed to upload product image for ${productId}`, error);
- *       throw error;
- *     }
- *   }
- *
- *   async getProductImage(productId: string, thumbnail: boolean = false): Promise<FileLike> {
- *     const product = await this.database.products.findById(productId);
- *     if (!product) {
- *       throw new Error(`Product ${productId} not found`);
- *     }
- *
- *     const imageId = thumbnail ? product.thumbnailId : product.imageId;
- *     if (!imageId) {
- *       throw new Error(`Product ${productId} has no ${thumbnail ? 'thumbnail' : 'image'}`);
- *     }
- *
- *     const bucket = thumbnail ? this.thumbnails : this.productImages;
- *     return await bucket.download(imageId);
- *   }
- * }
- * ```
- *
- * @example
- * **Temporary file processing with memory storage:**
- * ```ts
- * class FileProcessingService {
- *   tempFiles = $bucket({
- *     name: "temp-processing",
- *     provider: "memory", // Use in-memory storage for temporary files
- *     description: "Temporary files during processing workflows",
- *     maxSize: 100 // Large limit for processing workflows
- *   });
- *
- *   async processDataFile(inputFile: FileLike, transformations: string[]): Promise<FileLike> {
- *     let currentFile = inputFile;
- *     const intermediateFiles: string[] = [];
- *
- *     try {
- *       // Upload initial file to temp storage
- *       let currentFileId = await this.tempFiles.upload(currentFile);
- *       intermediateFiles.push(currentFileId);
- *
- *       // Apply each transformation
- *       for (const transformation of transformations) {
- *         console.log(`Applying transformation: ${transformation}`);
- *
- *         // Download current file
- *         currentFile = await this.tempFiles.download(currentFileId);
- *
- *         // Apply transformation
- *         const transformedFile = await this.applyTransformation(currentFile, transformation);
- *
- *         // Upload transformed file
- *         currentFileId = await this.tempFiles.upload(transformedFile);
- *         intermediateFiles.push(currentFileId);
- *       }
- *
- *       // Download final result
- *       const finalFile = await this.tempFiles.download(currentFileId);
- *
- *       console.log(`File processing completed with ${transformations.length} transformations`);
- *       return finalFile;
- *
- *     } finally {
- *       // Clean up all intermediate files
- *       for (const fileId of intermediateFiles) {
- *         try {
- *           await this.tempFiles.delete(fileId);
- *         } catch (error) {
- *           console.warn(`Failed to clean up temp file ${fileId}:`, error.message);
- *         }
- *       }
- *       console.log(`Cleaned up ${intermediateFiles.length} temporary files`);
- *     }
- *   }
- * }
- * ```
- *
- * @example
- * **File validation with dynamic configuration:**
- * ```ts
- * class UserContentService {
- *   userContent = $bucket({
- *     name: "user-content",
- *     description: "User-generated content with flexible validation"
- *     // Base configuration - can be overridden per operation
- *   });
- *
- *   async uploadUserFile(file: FileLike, userId: string, contentType: 'avatar' | 'document' | 'media'): Promise<string> {
- *     // Dynamic validation based on content type
- *     const validationConfig = this.getValidationConfig(contentType, userId);
- *
- *     try {
- *       // Upload with specific validation rules
- *       const fileId = await this.userContent.upload(file, validationConfig);
- *
- *       // Log upload for audit trail
- *       await this.auditLogger.log({
- *         action: 'file_upload',
- *         userId,
- *         fileId,
- *         contentType,
- *         fileName: file.name,
- *         fileSize: file.size,
- *         mimeType: file.type
- *       });
- *
- *       return fileId;
- *
- *     } catch (error) {
- *       console.error(`File upload failed for user ${userId}`, {
- *         contentType,
- *         fileName: file.name,
- *         error: error.message
- *       });
- *       throw error;
- *     }
- *   }
- *
- *   private getValidationConfig(contentType: string, userId: string) {
- *     const baseConfig = {
- *       avatar: {
- *         mimeTypes: ['image/jpeg', 'image/png'],
- *         maxSize: 2 // 2MB for avatars
- *       },
- *       document: {
- *         mimeTypes: ['application/pdf', 'text/plain'],
- *         maxSize: 10 // 10MB for documents
- *       },
- *       media: {
- *         mimeTypes: ['image/jpeg', 'image/png', 'video/mp4'],
- *         maxSize: 50 // 50MB for media files
- *       }
- *     };
- *
- *     const config = baseConfig[contentType];
- *
- *     // Premium users get higher limits
- *     if (this.userService.isPremium(userId)) {
- *       config.maxSize *= 2;
- *     }
- *
- *     return config;
- *   }
- * }
- * ```
  */
 declare const $bucket: {
   (options: BucketDescriptorOptions): BucketDescriptor;
@@ -528,7 +334,7 @@ declare class BucketDescriptor extends Descriptor<BucketDescriptorOptions> {
   /**
    * Delete permanently a file from the bucket.
    */
-  delete(fileId: string): Promise<void>;
+  delete(fileId: string, skipHook?: boolean): Promise<void>;
   /**
    * Checks if a file exists in the bucket.
    */

package/cache.d.ts

@@ -185,7 +185,7 @@ declare const $cache: {
   <TReturn = string, TParameter extends any[] = any[]>(options?: CacheDescriptorOptions<TReturn, TParameter>): CacheDescriptorFn<TReturn, TParameter>;
   [KIND]: typeof CacheDescriptor;
 };
-interface CacheDescriptorOptions<TReturn, TParameter extends any[] = any[]> {
+interface CacheDescriptorOptions<TReturn = any, TParameter extends any[] = any[]> {
   /**
    * The cache name. This is useful for invalidating multiple caches at once.
    *