alepha 0.10.5 → 0.10.7

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

@@ -281,7 +281,7 @@ declare const $batch: {
   <TItem extends TSchema, TResponse>(options: BatchDescriptorOptions<TItem, TResponse>): BatchDescriptor<TItem, TResponse>;
   [KIND]: typeof BatchDescriptor;
 };
-interface BatchDescriptorOptions<TItem extends TSchema, TResponse = any> {
+interface BatchDescriptorOptions<TItem$1 extends TSchema, TResponse$1 = any> {
   /**
    * TypeBox schema for validating each item added to the batch.
    *
@@ -308,7 +308,7 @@ interface BatchDescriptorOptions<TItem extends TSchema, TResponse = any> {
    * })
    * ```
    */
-  schema: TItem;
+  schema: TItem$1;
   /**
    * The batch processing handler function that processes arrays of validated items.
    *
@@ -369,7 +369,7 @@ interface BatchDescriptorOptions<TItem extends TSchema, TResponse = any> {
    * }
    * ```
    */
-  handler: (items: Static<TItem>[]) => TResponse;
+  handler: (items: Static<TItem$1>[]) => TResponse$1;
   /**
    * Maximum number of items to collect before automatically flushing the batch.
    *
@@ -463,7 +463,7 @@ interface BatchDescriptorOptions<TItem extends TSchema, TResponse = any> {
    * }
    * ```
    */
-  partitionBy?: (item: Static<TItem>) => string;
+  partitionBy?: (item: Static<TItem$1>) => string;
   /**
    * Maximum number of batch handlers that can execute simultaneously.
    *
@@ -526,19 +526,19 @@ interface BatchDescriptorOptions<TItem extends TSchema, TResponse = any> {
    * }
    * ```
    */
-  retry?: Omit<RetryDescriptorOptions<() => Array<Static<TItem>>>, "handler">;
+  retry?: Omit<RetryDescriptorOptions<() => Array<Static<TItem$1>>>, "handler">;
 }
-declare class BatchDescriptor<TItem extends TSchema, TResponse = any> extends Descriptor<BatchDescriptorOptions<TItem, TResponse>> {
+declare class BatchDescriptor<TItem$1 extends TSchema, TResponse$1 = any> extends Descriptor<BatchDescriptorOptions<TItem$1, TResponse$1>> {
   protected readonly log: _alepha_logger0.Logger;
   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<[], "Encode", {}, {}, TItem$1>[]) => TResponse$1>;
   /**
    * Pushes an item into the batch. The item will be processed
    * asynchronously with other items when the batch is flushed.
    */
-  push(item: Static<TItem>): Promise<TResponse>;
+  push(item: Static<TItem$1>): Promise<TResponse$1>;
   flush(partitionKey?: string): Promise<void>;
   protected flushPartition(partitionKey: string): Promise<void>;
   protected readonly dispose: _alepha_core1.HookDescriptor<"stop">;

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;

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$1 = any, TParameter$1 extends any[] = any[]> {
   /**
    * The cache name. This is useful for invalidating multiple caches at once.
    *
@@ -197,12 +197,12 @@ interface CacheDescriptorOptions<TReturn, TParameter extends any[] = any[]> {
   /**
    * Function which returns cached data.
    */
-  handler?: (...args: TParameter) => TReturn;
+  handler?: (...args: TParameter$1) => TReturn$1;
   /**
    * The key generator for the cache.
    * If not provided, the arguments will be json.stringify().
    */
-  key?: (...args: TParameter) => string;
+  key?: (...args: TParameter$1) => string;
   /**
    * The store provider for the cache.
    * If not provided, the default store provider will be used.
@@ -220,7 +220,7 @@ interface CacheDescriptorOptions<TReturn, TParameter extends any[] = any[]> {
    */
   disabled?: boolean;
 }
-declare class CacheDescriptor<TReturn = any, TParameter extends any[] = any[]> extends Descriptor<CacheDescriptorOptions<TReturn, TParameter>> {
+declare class CacheDescriptor<TReturn$1 = any, TParameter$1 extends any[] = any[]> extends Descriptor<CacheDescriptorOptions<TReturn$1, TParameter$1>> {
   protected readonly env: {
     CACHE_ENABLED: boolean;
     CACHE_DEFAULT_TTL: number;
@@ -235,20 +235,20 @@ declare class CacheDescriptor<TReturn = any, TParameter extends any[] = any[]> e
     STRING: number;
   };
   get container(): string;
-  run(...args: TParameter): Promise<TReturn>;
-  key(...args: TParameter): string;
+  run(...args: TParameter$1): Promise<TReturn$1>;
+  key(...args: TParameter$1): string;
   invalidate(...keys: string[]): Promise<void>;
-  set(key: string, value: TReturn, ttl?: DurationLike): Promise<void>;
-  get(key: string): Promise<TReturn | undefined>;
-  protected serialize<TReturn>(value: TReturn): Uint8Array;
-  protected deserialize<TReturn>(uint8Array: Uint8Array): Promise<TReturn>;
+  set(key: string, value: TReturn$1, ttl?: DurationLike): Promise<void>;
+  get(key: string): Promise<TReturn$1 | undefined>;
+  protected serialize<TReturn>(value: TReturn$1): Uint8Array;
+  protected deserialize<TReturn>(uint8Array: Uint8Array): Promise<TReturn$1>;
   protected $provider(): CacheProvider;
 }
-interface CacheDescriptorFn<TReturn = any, TParameter extends any[] = any[]> extends CacheDescriptor<TReturn, TParameter> {
+interface CacheDescriptorFn<TReturn$1 = any, TParameter$1 extends any[] = any[]> extends CacheDescriptor<TReturn$1, TParameter$1> {
   /**
    * Run the cache descriptor with the provided arguments.
    */
-  (...args: TParameter): Promise<TReturn>;
+  (...args: TParameter$1): Promise<TReturn$1>;
 }
 //#endregion
 //#region src/providers/MemoryCacheProvider.d.ts

package/command.d.ts

@@ -7,7 +7,7 @@ import * as readline_promises0 from "readline/promises";
 import * as typebox0 from "typebox";
 
 //#region src/helpers/Asker.d.ts
-interface AskOptions<T extends TSchema = TString> {
+interface AskOptions<T$1 extends TSchema = TString> {
   /**
    * Response schema expected.
    *
@@ -26,12 +26,12 @@ interface AskOptions<T extends TSchema = TString> {
    *
    * @default TString
    */
-  schema?: T;
+  schema?: T$1;
   /**
    * Custom validation function.
    * Throws an AlephaError in case of validation failure.
    */
-  validate?: (value: Static<T>) => void;
+  validate?: (value: Static<T$1>) => void;
 }
 interface AskMethod {
   <T extends TSchema = TString>(question: string, options?: AskOptions<T>): Promise<Static<T>>;
@@ -99,11 +99,11 @@ declare const $command: {
   <T extends TObject, A extends TSchema>(options: CommandDescriptorOptions<T, A>): CommandDescriptor<T, A>;
   [KIND]: typeof CommandDescriptor;
 };
-interface CommandDescriptorOptions<T extends TObject, A extends TSchema> {
+interface CommandDescriptorOptions<T$1 extends TObject, A$1 extends TSchema> {
   /**
    * The handler function to execute when the command is matched.
    */
-  handler: (args: CommandHandlerArgs<T, A>) => Async<void>;
+  handler: (args: CommandHandlerArgs<T$1, A$1>) => Async<void>;
   /**
    * The name of the command. If omitted, the property key is used.
    *
@@ -121,7 +121,7 @@ interface CommandDescriptorOptions<T extends TObject, A extends TSchema> {
   /**
    * A TypeBox object schema defining the flags for the command.
    */
-  flags?: T;
+  flags?: T$1;
   /**
    * An optional TypeBox schema defining the arguments for the command.
    *
@@ -138,20 +138,20 @@ interface CommandDescriptorOptions<T extends TObject, A extends TSchema> {
    * args: t.tuple([t.text(), t.optional(t.number())])
    * my-cli command <arg1: string> [arg2: number]
    */
-  args?: A;
+  args?: A$1;
   /**
    * If false, skip summary message at the end of the command execution.
    */
   summary?: boolean;
 }
-declare class CommandDescriptor<T extends TObject = TObject, A extends TSchema = TSchema> extends Descriptor<CommandDescriptorOptions<T, A>> {
+declare class CommandDescriptor<T$1 extends TObject = TObject, A$1 extends TSchema = TSchema> extends Descriptor<CommandDescriptorOptions<T$1, A$1>> {
   readonly flags: TObject<{}>;
   readonly aliases: string[];
   get name(): string;
 }
-interface CommandHandlerArgs<T extends TObject, A extends TSchema = TSchema> {
-  flags: Static<T>;
-  args: A extends TSchema ? Static<A> : undefined;
+interface CommandHandlerArgs<T$1 extends TObject, A$1 extends TSchema = TSchema> {
+  flags: Static<T$1>;
+  args: A$1 extends TSchema ? Static<A$1> : Array<string>;
   run: RunnerMethod;
   ask: AskMethod;
   glob: typeof glob;