alepha 0.10.7 → 0.11.1

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

package/bucket.d.ts

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

package/command.d.ts

@@ -1,13 +1,13 @@
 import * as _alepha_core1 from "alepha";
 import { Alepha, AlephaError, Async, Descriptor, KIND, Static, TObject, TSchema, TString } from "alepha";
-import * as _alepha_logger0 from "alepha/logger";
+import * as _alepha_logger1 from "alepha/logger";
 import * as fs from "node:fs/promises";
 import { glob } from "node:fs/promises";
 import * as readline_promises0 from "readline/promises";
 import * as typebox0 from "typebox";
 
 //#region src/helpers/Asker.d.ts
-interface AskOptions<T$1 extends TSchema = TString> {
+interface AskOptions<T extends TSchema = TString> {
   /**
    * Response schema expected.
    *
@@ -26,18 +26,18 @@ interface AskOptions<T$1 extends TSchema = TString> {
    *
    * @default TString
    */
-  schema?: T$1;
+  schema?: T;
   /**
    * Custom validation function.
    * Throws an AlephaError in case of validation failure.
    */
-  validate?: (value: Static<T$1>) => void;
+  validate?: (value: Static<T>) => void;
 }
 interface AskMethod {
   <T extends TSchema = TString>(question: string, options?: AskOptions<T>): Promise<Static<T>>;
 }
 declare class Asker {
-  protected readonly log: _alepha_logger0.Logger;
+  protected readonly log: _alepha_logger1.Logger;
   readonly ask: AskMethod;
   protected readonly alepha: Alepha;
   constructor();
@@ -67,7 +67,7 @@ interface RunnerMethod {
   cp: (source: string, dest: string, options?: RunOptions) => Promise<string>;
 }
 declare class Runner {
-  protected readonly log: _alepha_logger0.Logger;
+  protected readonly log: _alepha_logger1.Logger;
   protected readonly timers: Timer[];
   protected readonly startTime: number;
   readonly run: RunnerMethod;
@@ -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$1 extends TObject, A$1 extends TSchema> {
+interface CommandDescriptorOptions<T extends TObject, A extends TSchema> {
   /**
    * The handler function to execute when the command is matched.
    */
-  handler: (args: CommandHandlerArgs<T$1, A$1>) => Async<void>;
+  handler: (args: CommandHandlerArgs<T, A>) => Async<void>;
   /**
    * The name of the command. If omitted, the property key is used.
    *
@@ -121,7 +121,7 @@ interface CommandDescriptorOptions<T$1 extends TObject, A$1 extends TSchema> {
   /**
    * A TypeBox object schema defining the flags for the command.
    */
-  flags?: T$1;
+  flags?: T;
   /**
    * An optional TypeBox schema defining the arguments for the command.
    *
@@ -138,20 +138,20 @@ interface CommandDescriptorOptions<T$1 extends TObject, A$1 extends TSchema> {
    * args: t.tuple([t.text(), t.optional(t.number())])
    * my-cli command <arg1: string> [arg2: number]
    */
-  args?: A$1;
+  args?: A;
   /**
    * If false, skip summary message at the end of the command execution.
    */
   summary?: boolean;
 }
-declare class CommandDescriptor<T$1 extends TObject = TObject, A$1 extends TSchema = TSchema> extends Descriptor<CommandDescriptorOptions<T$1, A$1>> {
+declare class CommandDescriptor<T extends TObject = TObject, A extends TSchema = TSchema> extends Descriptor<CommandDescriptorOptions<T, A>> {
   readonly flags: TObject<{}>;
   readonly aliases: string[];
   get name(): string;
 }
-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>;
+interface CommandHandlerArgs<T extends TObject, A extends TSchema = TSchema> {
+  flags: Static<T>;
+  args: A extends TSchema ? Static<A> : Array<string>;
   run: RunnerMethod;
   ask: AskMethod;
   glob: typeof glob;
@@ -177,7 +177,7 @@ declare class CliProvider {
     CLI_DESCRIPTION: string;
   };
   protected readonly alepha: Alepha;
-  protected readonly log: _alepha_logger0.Logger;
+  protected readonly log: _alepha_logger1.Logger;
   protected readonly runner: Runner;
   protected readonly asker: Asker;
   options: {