alepha 0.8.1 → 0.9.1

package/cache.d.ts

@@ -1,122 +1,122 @@
-import { Alepha, HookDescriptor, KIND, Logger, Module, OPTIONS, Static, TBoolean, TNumber, TObject, TOptional, TString } from "alepha";
+import * as _alepha_core0$1 from "alepha";
+import * as _alepha_core0 from "alepha";
+import { Descriptor, InstantiableClass, KIND } from "alepha";
 import { DateTimeProvider, DurationLike, Timeout } from "alepha/datetime";
 
 //#region src/providers/CacheProvider.d.ts
-
 /**
-* Cache provider interface.
-*
-* All methods are asynchronous and return promises.
-* Values are stored as Uint8Array.
-*/
+ * Cache provider interface.
+ *
+ * All methods are asynchronous and return promises.
+ * Values are stored as Uint8Array.
+ */
 declare abstract class CacheProvider {
   /**
-  * Get the value of a key.
-  *
-  * @param name Cache name, used to group keys. Should be Redis-like "some:group:name" format.
-  * @param key The key of the value to get.
-  *
-  * @return The value of the key, or undefined if the key does not exist.
-  */
+   * Get the value of a key.
+   *
+   * @param name Cache name, used to group keys. Should be Redis-like "some:group:name" format.
+   * @param key The key of the value to get.
+   *
+   * @return The value of the key, or undefined if the key does not exist.
+   */
   abstract get(name: string, key: string): Promise<Uint8Array | undefined>;
   /**
-  * Set the string value of a key.
-  *
-  * @param name Cache name, used to group keys. Should be Redis-like "some:group:name" format.
-  * @param key The key of the value to set.
-  * @param value The value to set.
-  * @param ttl The time-to-live of the key, in milliseconds.
-  *
-  * @return The value of the key.
-  */
+   * Set the string value of a key.
+   *
+   * @param name Cache name, used to group keys. Should be Redis-like "some:group:name" format.
+   * @param key The key of the value to set.
+   * @param value The value to set.
+   * @param ttl The time-to-live of the key, in milliseconds.
+   *
+   * @return The value of the key.
+   */
   abstract set(name: string, key: string, value: Uint8Array, ttl?: number): Promise<Uint8Array>;
   /**
-  * Remove the specified keys.
-  *
-  * @param name Cache name, used to group keys. Should be Redis-like "some:group:name" format.
-  * @param keys The keys to delete.
-  */
+   * Remove the specified keys.
+   *
+   * @param name Cache name, used to group keys. Should be Redis-like "some:group:name" format.
+   * @param keys The keys to delete.
+   */
   abstract del(name: string, ...keys: string[]): Promise<void>;
   abstract has(name: string, key: string): Promise<boolean>;
-  abstract keys(name: string): Promise<string[]>;
+  abstract keys(name: string, filter?: string): Promise<string[]>;
 }
+//# sourceMappingURL=CacheProvider.d.ts.map
 //#endregion
 //#region src/descriptors/$cache.d.ts
-declare const KEY = "CACHE";
 /**
-* Cache Descriptor
-*/
+ * Creates a cache storage or a cache function.
+ */
 declare const $cache: {
-  <TReturn = string, TParameter extends any[] = any[]>(options?: CacheDescriptorOptions<TReturn, TParameter>): CacheDescriptor<TReturn, TParameter>;
-  [KIND]: string;
+  <TReturn = string, TParameter extends any[] = any[]>(options?: CacheDescriptorOptions<TReturn, TParameter>): CacheDescriptorFn<TReturn, TParameter>;
+  [KIND]: typeof CacheDescriptor;
 };
-// ---------------------------------------------------------------------------------------------------------------------
 interface CacheDescriptorOptions<TReturn, TParameter extends any[] = any[]> {
   /**
-  * The cache name. This is useful for invalidating multiple caches at once.
-  *
-  * Store key as `cache:$name:$key`.
-  *
-  * @default ClassName:methodName
-  */
+   * The cache name. This is useful for invalidating multiple caches at once.
+   *
+   * Store key as `cache:$name:$key`.
+   *
+   * @default Name of the key of the class.
+   */
   name?: string;
   /**
-  * Function which returns cached data.
-  * @param args Arguments for handler.
-  */
+   * Function which returns cached data.
+   */
   handler?: (...args: TParameter) => TReturn;
   /**
-  * The key generator for the cache.
-  * If not provided, the arguments will be json.stringify().
-  */
+   * The key generator for the cache.
+   * If not provided, the arguments will be json.stringify().
+   */
   key?: (...args: TParameter) => string;
   /**
-  * The store provider for the cache.
-  * If not provided, the default store provider will be used.
-  */
-  provider?: CacheProvider | (() => CacheProvider) | "memory";
+   * The store provider for the cache.
+   * If not provided, the default store provider will be used.
+   */
+  provider?: InstantiableClass<CacheProvider> | "memory";
   /**
-  * The time-to-live for the cache in seconds.
-  * Set 0 to skip expiration.
-  *
-  * @default 300 (5 minutes).
-  */
+   * The time-to-live for the cache in seconds.
+   * Set 0 to skip expiration.
+   *
+   * @default 300 (5 minutes).
+   */
   ttl?: DurationLike;
   /**
-  * If the cache is disabled.
-  */
+   * If the cache is disabled.
+   */
   disabled?: boolean;
 }
-interface CacheDescriptor<TReturn = any, TParameter extends any[] = any[]> {
-  [KIND]: typeof KEY;
-  [OPTIONS]: CacheDescriptorOptions<TReturn, TParameter>;
+declare class CacheDescriptor<TReturn = any, TParameter extends any[] = any[]> extends Descriptor<CacheDescriptorOptions<TReturn, TParameter>> {
+  protected readonly env: {
+    CACHE_ENABLED: boolean;
+    CACHE_DEFAULT_TTL: number;
+  };
+  protected readonly dateTimeProvider: DateTimeProvider;
+  protected readonly provider: CacheProvider;
+  protected encoder: TextEncoder;
+  protected decoder: TextDecoder;
+  protected codes: {
+    BINARY: number;
+    JSON: number;
+    STRING: number;
+  };
+  get container(): string;
+  run(...args: TParameter): Promise<TReturn>;
+  key(...args: TParameter): 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>;
+  protected $provider(): CacheProvider;
+}
+interface CacheDescriptorFn<TReturn = any, TParameter extends any[] = any[]> extends CacheDescriptor<TReturn, TParameter> {
   /**
-  * Cache handler.
-  */
+   * Run the cache descriptor with the provided arguments.
+   */
   (...args: TParameter): Promise<TReturn>;
-  /**
-  * Cache key generator.
-  */
-  key: (...args: TParameter) => string;
-  /**
-  * Invalidate cache by keys.
-  */
-  invalidate: (...keys: string[]) => Promise<void>;
-  /**
-  * Set cache with key, value and ttl.
-  *
-  * @param key
-  * @param value
-  * @param ttl
-  */
-  set: (key: string, value: TReturn, ttl?: DurationLike) => Promise<void>;
-  /**
-  * Get cache by key.
-  *
-  * @param key
-  */
-  get: (key: string) => Promise<TReturn | undefined>;
 }
+//# sourceMappingURL=$cache.d.ts.map
 //#endregion
 //#region src/providers/MemoryCacheProvider.d.ts
 type CacheName = string;
@@ -127,167 +127,30 @@ type CacheValue = {
 };
 declare class MemoryCacheProvider implements CacheProvider {
   protected readonly dateTimeProvider: DateTimeProvider;
-  protected readonly log: Logger;
+  protected readonly log: _alepha_core0$1.Logger;
   protected store: Record<CacheName, Record<CacheKey, CacheValue>>;
   get(name: string, key: string): Promise<Uint8Array | undefined>;
   set(name: string, key: string, value: Uint8Array, ttl?: number): Promise<Uint8Array>;
   del(name: string, ...keys: string[]): Promise<void>;
   has(name: string, key: string): Promise<boolean>;
-  keys(name: string): Promise<string[]>;
-}
-//#endregion
-//#region src/providers/CacheDescriptorProvider.d.ts
-declare const envSchema: TObject<{
-  CACHE_DEFAULT_TTL: TNumber;
-  CACHE_PREFIX: TOptional<TString>;
-  CACHE_ENABLED: TBoolean;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema>> {}
-}
-declare class CacheDescriptorProvider {
-  protected readonly alepha: Alepha;
-  protected readonly cacheProvider: CacheProvider;
-  protected readonly memoryCacheProvider: MemoryCacheProvider;
-  protected readonly dateTimeProvider: DateTimeProvider;
-  protected readonly env: Static<typeof envSchema>;
-  protected readonly caches: Cache[];
-  protected encoder: TextEncoder;
-  protected decoder: TextDecoder;
-  protected codes: {
-    BINARY: number;
-    JSON: number;
-    STRING: number;
-  };
-  protected readonly configure: HookDescriptor<"configure">;
-  register(cache: Cache): Cache;
-  processDescriptors(): void;
-  getCaches(): Cache[];
-  /**
-  * Clear all cache entries.
-  */
-  clear(): Promise<void>;
-  /**
-  * Get the store provider for the given cache options.
-  *
-  * @param options
-  */
-  provider(options: Pick<CacheDescriptorOptions<any[], any>, "provider">): CacheProvider;
-  /**
-  * Get the cache key for the given state and arguments.
-  */
-  key(cache: Cache, ...args: any[]): string;
-  /**
-  * Invalidate the cache for the given state and arguments.
-  */
-  invalidate(cache: Cache, ...keys: string[]): Promise<void>;
-  /**
-  * Run the cache handler with the given state and arguments.
-  * You must run on a $cache with a handler defined.
-  */
-  run<TReturn, TParameter extends any[]>(cache: Cache<TReturn, TParameter>, ...args: TParameter): Promise<TReturn>;
-  get<TReturn>(cache: Cache<TReturn>, key: string): Promise<TReturn | undefined>;
-  /**
-  * Manually set a value in the cache.
-  * It's used by .run() method, but you will need it when you don't have cache handler defined.
-  *
-  * @param cache Cache object with all configuration and options (even TTL).
-  * @param key Cache key, build with .key() method or manually.
-  * @param value Value to store in cache.
-  * @param ttl Override cache.ttl option.
-  */
-  set<TReturn>(cache: Cache<TReturn>, key: string, value: TReturn, ttl?: DurationLike): Promise<void>;
-  protected serialize<TReturn>(value: TReturn): Uint8Array;
-  protected deserialize<TReturn>(uint8Array: Uint8Array): Promise<TReturn>;
-}
-interface Cache<TReturn = any, TParameter extends any[] = any[]> {
-  name: string;
-  options: CacheDescriptorOptions<TReturn, TParameter>;
+  keys(name: string, filter?: string): Promise<string[]>;
 }
 //#endregion
 //#region src/index.d.ts
-// ---------------------------------------------------------------------------------------------------------------------
 /**
-* Provides high-performance caching capabilities for Alepha applications with configurable TTL and multiple storage backends.
-*
-* The cache module enables declarative caching through the `$cache` descriptor, allowing you to cache method results,
-* API responses, or computed values with automatic invalidation and type safety. It supports both in-memory and
-* persistent storage backends for different performance and durability requirements.
-*
-* **Key Features:**
-* - Declarative caching with `$cache` descriptor on class properties
-* - Configurable TTL (time-to-live) with duration literals
-* - Custom key generation and automatic serialization
-* - Multiple storage backends (memory, Redis, etc.)
-* - Cache invalidation and manual cache operations
-* - Type-safe operations with full TypeScript support
-*
-* **Basic Usage:**
-* ```ts
-* import { Alepha, run } from "alepha";
-* import { AlephaCache, $cache } from "alepha/cache";
-*
-* class UserService {
-*   getUserData = $cache({
-*     key: (userId: string) => `user:${userId}`,
-*     ttl: [1, "hour"],
-*     handler: async (userId: string) => {
-*       // This will be cached for 1 hour
-*       return await fetchUserFromDatabase(userId);
-*     },
-*   });
-*
-*   getUserProfile = $cache({
-*     provider: "memory",
-*     ttl: [5, "minutes"],
-*     handler: async (userId: string) => {
-*       return await buildUserProfile(userId);
-*     },
-*   });
-* }
-*
-* const alepha = Alepha.create()
-*   .with(AlephaCache)
-*   .with(UserService);
-*
-* run(alepha);
-* ```
-*
-* **Cache Operations:**
-* ```ts
-* class ProductService {
-*   productCache = $cache({
-*     handler: async (productId: string) => {
-*       return await getProduct(productId);
-*     },
-*   });
-*
-*   async getProduct(id: string) {
-*     // Get from cache or compute
-*     return await this.productCache(id);
-*   }
-*
-*   async updateProduct(id: string, data: any) {
-*     await updateProductInDb(id, data);
-*     // Invalidate cache
-*     await this.productCache.invalidate(this.productCache.key(id));
-*   }
-*
-*   async warmUpCache(id: string, data: any) {
-*     // Manually set cache
-*     await this.productCache.set(this.productCache.key(id), data, [30, "minutes"]);
-*   }
-* }
-* ```
-*
-* @see {@link $cache}
-* @see {@link CacheProvider}
-* @module alepha.cache
-*/
-declare class AlephaCache implements Module {
-  readonly name = "alepha.cache";
-  readonly $services: (alepha: Alepha) => Alepha;
-}
+ * Provides high-performance caching capabilities for Alepha applications with configurable TTL and multiple storage backends.
+ *
+ * The cache module enables declarative caching through the `$cache` descriptor, allowing you to cache method results,
+ * API responses, or computed values with automatic invalidation and type safety. It supports both in-memory and
+ * persistent storage backends for different performance and durability requirements.
+ *
+ * @see {@link $cache}
+ * @see {@link CacheProvider}
+ * @module alepha.cache
+ */
+declare const AlephaCache: _alepha_core0.ModuleDescriptor;
+//# sourceMappingURL=index.d.ts.map
+
 //#endregion
-export { $cache, AlephaCache, Cache, CacheDescriptor, CacheDescriptorOptions, CacheDescriptorProvider, CacheProvider, MemoryCacheProvider };
+export { $cache, AlephaCache, CacheDescriptor, CacheDescriptorFn, CacheDescriptorOptions, CacheProvider, MemoryCacheProvider };
 //# sourceMappingURL=index.d.ts.map

package/command.d.ts

@@ -1,6 +1,9 @@
-import { Alepha, AlephaError, Async, HookDescriptor, KIND, Logger, Module, OPTIONS, Static, TObject, TProperties, TSchema, TString } from "alepha";
+import * as _alepha_core0$1 from "alepha";
+import * as _alepha_core0 from "alepha";
+import { Alepha, AlephaError, Async, Descriptor, KIND, Logger, Static, TObject, TSchema } from "alepha";
 import * as fs from "node:fs/promises";
 import { glob } from "node:fs/promises";
+import * as _sinclair_typebox0 from "@sinclair/typebox";
 
 //#region src/helpers/Runner.d.ts
 type Task = {
@@ -14,6 +17,9 @@ interface Timer {
 interface RunnerMethod {
   (cmd: string | Array<string | Task>, fn?: () => any): Promise<string>;
   rm: (glob: string | string[]) => Promise<string>;
+  cp: (source: string, dest: string, options?: {
+    alias?: string;
+  }) => Promise<string>;
 }
 declare class Runner {
   protected readonly log: Logger;
@@ -21,107 +27,100 @@ declare class Runner {
   protected readonly startTime: number;
   readonly run: RunnerMethod;
   constructor(log: Logger);
+  protected createRunMethod(): RunnerMethod;
   protected exec(cmd: string): Promise<string>;
   /**
-  * Executes one or more tasks.
-  *
-  * @param task - A single task or an array of tasks to run in parallel.
-  */
+   * Executes one or more tasks.
+   *
+   * @param task - A single task or an array of tasks to run in parallel.
+   */
   protected execute(task: Task | Task[]): Promise<string>;
   /**
-  * Prints a summary of all executed tasks and their durations.
-  */
+   * Prints a summary of all executed tasks and their durations.
+   */
   summary(): void;
   protected executeTask(task: Task): Promise<string>;
   protected renderTable(data: string[][]): void;
 }
 //#endregion
 //#region src/descriptors/$command.d.ts
-declare const KEY = "COMMAND";
 /**
-* Declares a CLI command.
-*
-* This descriptor allows you to define a command, its flags, and its handler
-* within your Alepha application structure.
-*/
+ * Declares a CLI command.
+ *
+ * This descriptor allows you to define a command, its flags, and its handler
+ * within your Alepha application structure.
+ */
 declare const $command: {
   <T extends TObject>(options: CommandDescriptorOptions<T>): CommandDescriptor<T>;
-  [KIND]: string;
+  [KIND]: typeof CommandDescriptor;
 };
 interface CommandDescriptorOptions<T extends TObject> {
   /**
-  * The handler function to execute when the command is matched.
-  */
-  handler: (args: {
-    flags: Static<T>;
-    run: RunnerMethod;
-    glob: typeof glob;
-    fs: typeof fs;
-  }) => Async<void>;
+   * The handler function to execute when the command is matched.
+   */
+  handler: (args: CommandHandlerArgs<T>) => Async<void>;
   /**
-  * The name of the command. If omitted, the property key is used.
-  *
-  * An empty string "" denotes the root command.
-  */
+   * The name of the command. If omitted, the property key is used.
+   *
+   * An empty string "" denotes the root command.
+   */
   name?: string;
   /**
-  * A short description of the command, shown in the help message.
-  */
+   * A short description of the command, shown in the help message.
+   */
   description?: string;
   /**
-  * An array of alternative names for the command.
-  */
+   * An array of alternative names for the command.
+   */
   aliases?: string[];
   /**
-  * A TypeBox object schema defining the flags for the command.
-  */
+   * A TypeBox object schema defining the flags for the command.
+   */
   flags?: T;
 }
-interface CommandDescriptor<T extends TObject> {
-  [KIND]: typeof KEY;
-  [OPTIONS]: CommandDescriptorOptions<T>;
-  /**
-  * Executes the command. This is a placeholder and will be replaced by the provider.
-  */
-  (flags: Static<T>): Promise<void>;
+declare class CommandDescriptor<T extends TObject = TObject> extends Descriptor<CommandDescriptorOptions<T>> {
+  readonly flags: TObject<{}>;
+  readonly aliases: string[];
+  get name(): string;
+}
+interface CommandHandlerArgs<T extends TObject> {
+  flags: Static<T>;
+  run: RunnerMethod;
+  glob: typeof glob;
+  fs: typeof fs;
 }
+//# sourceMappingURL=$command.d.ts.map
 //#endregion
 //#region src/errors/CommandError.d.ts
 declare class CommandError extends AlephaError {}
+//# sourceMappingURL=CommandError.d.ts.map
 //#endregion
-//#region src/providers/CommandDescriptorProvider.d.ts
-interface Command {
-  key: string;
-  name: string;
-  description?: string;
-  aliases: string[];
-  flags: TObject<TProperties>;
-  handler: (flags: any) => Promise<void>;
-}
+//#region src/providers/CliProvider.d.ts
 declare const envSchema: TObject<{
-  CLI_NAME: TString;
-  CLI_DESCRIPTION: TString;
+  CLI_NAME: _alepha_core0$1.TString;
+  CLI_DESCRIPTION: _alepha_core0$1.TString;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
 }
-declare class CommandDescriptorProvider {
+declare class CliProvider {
   protected readonly env: Static<typeof envSchema>;
   protected readonly alepha: Alepha;
   protected readonly log: Logger;
-  protected commands: Command[];
   options: {
     name: string;
     description: string;
     argv: string[];
   };
-  protected readonly globalFlags: Record<string, {
-    aliases: string[];
-    description: string;
-    schema: TSchema;
-  }>;
-  protected readonly onConfigure: HookDescriptor<"configure">;
-  protected readonly onReady: HookDescriptor<"ready">;
+  protected readonly globalFlags: {
+    help: {
+      aliases: string[];
+      description: string;
+      schema: _sinclair_typebox0.TBoolean;
+    };
+  };
+  protected readonly onReady: _alepha_core0$1.HookDescriptor<"ready">;
+  get commands(): CommandDescriptor<any>[];
   private findCommand;
   protected parseCommandFlags(argv: string[], schema: TObject): Record<string, any>;
   protected parseFlags(argv: string[], flagDefs: {
@@ -135,18 +134,28 @@ declare class CommandDescriptorProvider {
 }
 //#endregion
 //#region src/index.d.ts
-// ---------------------------------------------------------------------------------------------------------------------
 /**
-*This module provides a powerful way to build command-line interfaces
-* directly within your Alepha application, using declarative descriptors.
-*
-* @see {@link $command}
-* @module alepha.command
-*/
-declare class AlephaCommand implements Module {
-  readonly name = "alepha.command";
-  readonly $services: (alepha: Alepha) => Alepha;
+ * This module provides a powerful way to build command-line interfaces
+ * directly within your Alepha application, using declarative descriptors.
+ *
+ * It allows you to define commands using the `$command` descriptor.
+ *
+ * @see {@link $command}
+ * @module alepha.command
+ */
+declare const AlephaCommand: _alepha_core0.ModuleDescriptor;
+declare module "@sinclair/typebox" {
+  interface StringOptions {
+    /**
+     * Additional aliases for the flags.
+     *
+     * @module alepha.command
+     */
+    aliases?: string[];
+  }
 }
+//# sourceMappingURL=index.d.ts.map
+
 //#endregion
-export { $command, AlephaCommand, CommandDescriptor, CommandDescriptorOptions, CommandDescriptorProvider, CommandError, Runner, RunnerMethod, Task };
+export { $command, AlephaCommand, CliProvider, CommandDescriptor, CommandDescriptorOptions, CommandError, CommandHandlerArgs, Runner, RunnerMethod, Task };
 //# sourceMappingURL=index.d.ts.map