alepha 0.15.0 → 0.15.2

package/dist/batch/index.d.ts

@@ -1,4 +1,4 @@
-import * as alepha1 from "alepha";
+import * as alepha2 from "alepha";
 import { Alepha, KIND, Primitive, Static, TSchema } from "alepha";
 import { DateTimeProvider, DurationLike } from "alepha/datetime";
 import * as alepha_logger0 from "alepha/logger";
@@ -7,69 +7,69 @@ import { RetryBackoffOptions, RetryPrimitiveOptions, RetryProvider } from "aleph
 //#region ../../src/batch/providers/BatchProvider.d.ts
 interface BatchOptions<TItem, TResponse = any> {
   /**
-       * The batch processing handler function that processes arrays of validated items.
-       */
+   * The batch processing handler function that processes arrays of validated items.
+   */
   handler: (items: TItem[]) => TResponse;
   /**
-       * Maximum number of items to collect before automatically flushing the batch.
-       *
-       * @default 10
-       */
+   * Maximum number of items to collect before automatically flushing the batch.
+   *
+   * @default 10
+   */
   maxSize?: number;
   /**
-       * Maximum number of items that can be queued in a single partition.
-       * If exceeded, push() will throw an error.
-       */
+   * Maximum number of items that can be queued in a single partition.
+   * If exceeded, push() will throw an error.
+   */
   maxQueueSize?: number;
   /**
-       * Maximum time to wait before flushing a batch, even if it hasn't reached maxSize.
-       *
-       * @default [1, "second"]
-       */
+   * Maximum time to wait before flushing a batch, even if it hasn't reached maxSize.
+   *
+   * @default [1, "second"]
+   */
   maxDuration?: DurationLike;
   /**
-       * Function to determine partition keys for grouping items into separate batches.
-       */
+   * Function to determine partition keys for grouping items into separate batches.
+   */
   partitionBy?: (item: TItem) => string;
   /**
-       * Maximum number of batch handlers that can execute simultaneously.
-       *
-       * @default 1
-       */
+   * Maximum number of batch handlers that can execute simultaneously.
+   *
+   * @default 1
+   */
   concurrency?: number;
   /**
-       * Retry configuration for failed batch processing operations.
-       */
+   * Retry configuration for failed batch processing operations.
+   */
   retry?: {
     /**
-             * The maximum number of attempts.
-             *
-             * @default 3
-             */
+     * The maximum number of attempts.
+     *
+     * @default 3
+     */
     max?: number;
     /**
-             * The backoff strategy for delays between retries.
-             * Can be a fixed number (in ms) or a configuration object for exponential backoff.
-             *
-             * @default { initial: 200, factor: 2, jitter: true }
-             */
+     * The backoff strategy for delays between retries.
+     * Can be a fixed number (in ms) or a configuration object for exponential backoff.
+     *
+     * @default { initial: 200, factor: 2, jitter: true }
+     */
     backoff?: number | RetryBackoffOptions;
     /**
-             * An overall time limit for all retry attempts combined.
-             *
-             * e.g., `[5, 'seconds']`
-             */
+     * An overall time limit for all retry attempts combined.
+     *
+     * e.g., `[5, 'seconds']`
+     */
     maxDuration?: DurationLike;
     /**
-             * A function that determines if a retry should be attempted based on the error.
-             *
-             * @default (error) => true (retries on any error)
-             */
+     * A function that determines if a retry should be attempted based on the error.
+     *
+     * @default (error) => true (retries on any error)
+     */
     when?: (error: Error) => boolean;
     /**
-             * A custom callback for when a retry attempt fails.
-             * This is called before the delay.
-             */
+     * A custom callback for when a retry attempt fails.
+     * This is called before the delay.
+     */
     onError?: (error: Error, attempt: number) => void;
   };
 }
@@ -113,41 +113,49 @@ declare class BatchProvider {
   protected readonly dateTime: DateTimeProvider;
   protected readonly retryProvider: RetryProvider;
   /**
-       * Creates a new batch context with the given options.
-       */
+   * All active batch contexts managed by this provider.
+   */
+  protected readonly contexts: Set<BatchContext<any, any>>;
+  /**
+   * Creates a new batch context with the given options.
+   */
   createContext<TItem, TResponse>(alepha: Alepha, options: BatchOptions<TItem, TResponse>): BatchContext<TItem, TResponse>;
   /**
-       * Get the effective maxSize for a context.
-       */
+   * Shutdown hook - flushes all batch contexts on application stop.
+   */
+  protected readonly onStop: alepha2.HookPrimitive<"stop">;
+  /**
+   * Get the effective maxSize for a context.
+   */
   protected getMaxSize<TItem, TResponse>(context: BatchContext<TItem, TResponse>): number;
   /**
-       * Get the effective concurrency for a context.
-       */
+   * Get the effective concurrency for a context.
+   */
   protected getConcurrency<TItem, TResponse>(context: BatchContext<TItem, TResponse>): number;
   /**
-       * Get the effective maxDuration for a context.
-       */
+   * Get the effective maxDuration for a context.
+   */
   protected getMaxDuration<TItem, TResponse>(context: BatchContext<TItem, TResponse>): DurationLike;
   /**
-       * Pushes an item into the batch and returns immediately with a unique ID.
-       * The item will be processed asynchronously with other items when the batch is flushed.
-       * Use wait(id) to get the processing result.
-       *
-       * @throws Error if maxQueueSize is exceeded
-       */
+   * Pushes an item into the batch and returns immediately with a unique ID.
+   * The item will be processed asynchronously with other items when the batch is flushed.
+   * Use wait(id) to get the processing result.
+   *
+   * @throws Error if maxQueueSize is exceeded
+   */
   push<TItem, TResponse>(context: BatchContext<TItem, TResponse>, item: TItem): string;
   /**
-       * Wait for a specific item to be processed and get its result.
-       * @param id The item ID returned from push()
-       * @returns The processing result
-       * @throws If the item doesn't exist or processing failed
-       */
+   * Wait for a specific item to be processed and get its result.
+   * @param id The item ID returned from push()
+   * @returns The processing result
+   * @throws If the item doesn't exist or processing failed
+   */
   wait<TItem, TResponse>(context: BatchContext<TItem, TResponse>, id: string): Promise<TResponse>;
   /**
-       * Get the current status of an item.
-       * @param id The item ID returned from push()
-       * @returns Status information or undefined if item doesn't exist
-       */
+   * Get the current status of an item.
+   * @param id The item ID returned from push()
+   * @returns Status information or undefined if item doesn't exist
+   */
   status<TItem, TResponse>(context: BatchContext<TItem, TResponse>, id: string): {
     status: "pending" | "processing";
   } | {
@@ -158,36 +166,36 @@ declare class BatchProvider {
     error: Error;
   } | undefined;
   /**
-       * Clears completed and failed items from the context to free memory.
-       * Returns the number of items cleared.
-       *
-       * @param context The batch context
-       * @param status Optional: only clear items with this specific status ('completed' or 'failed')
-       * @returns The number of items cleared
-       */
+   * Clears completed and failed items from the context to free memory.
+   * Returns the number of items cleared.
+   *
+   * @param context The batch context
+   * @param status Optional: only clear items with this specific status ('completed' or 'failed')
+   * @returns The number of items cleared
+   */
   clearCompleted<TItem, TResponse>(context: BatchContext<TItem, TResponse>, status?: "completed" | "failed"): number;
   /**
-       * Flush all partitions or a specific partition.
-       */
+   * Flush all partitions or a specific partition.
+   */
   flush<TItem, TResponse>(context: BatchContext<TItem, TResponse>, partitionKey?: string): Promise<void>;
   /**
-       * Flush a specific partition.
-       */
+   * Flush a specific partition.
+   */
   protected flushPartition<TItem, TResponse>(context: BatchContext<TItem, TResponse>, partitionKey: string, limit?: number): Promise<void>;
   /**
-       * Mark the context as ready and start processing buffered items.
-       * Called after the "ready" hook.
-       */
+   * Mark the context as ready and start processing buffered items.
+   * Called after the "ready" hook.
+   */
   markReady<TItem, TResponse>(context: BatchContext<TItem, TResponse>): Promise<void>;
   /**
-       * Mark the context as shutting down and flush all remaining items.
-       */
+   * Mark the context as shutting down and flush all remaining items.
+   */
   shutdown<TItem, TResponse>(context: BatchContext<TItem, TResponse>): Promise<void>;
   /**
-       * Called after the "ready" hook to start processing buffered items that were
-       * pushed during startup. This checks all partitions and starts timeouts/flushes
-       * for items that were accumulated before the app was ready.
-       */
+   * Called after the "ready" hook to start processing buffered items that were
+   * pushed during startup. This checks all partitions and starts timeouts/flushes
+   * for items that were accumulated before the app was ready.
+   */
   protected startProcessing<TItem, TResponse>(context: BatchContext<TItem, TResponse>): Promise<void>;
 }
 //#endregion
@@ -201,37 +209,37 @@ declare const $batch: {
 };
 interface BatchPrimitiveOptions<TItem extends TSchema, TResponse = any> {
   /**
-       * TypeBox schema for validating each item added to the batch.
-       */
+   * TypeBox schema for validating each item added to the batch.
+   */
   schema: TItem;
   /**
-       * The batch processing handler function that processes arrays of validated items.
-       */
+   * The batch processing handler function that processes arrays of validated items.
+   */
   handler: (items: Static<TItem>[]) => TResponse;
   /**
-       * Maximum number of items to collect before automatically flushing the batch.
-       */
+   * Maximum number of items to collect before automatically flushing the batch.
+   */
   maxSize?: number;
   /**
-       * Maximum number of items that can be queued in a single partition.
-       * If exceeded, push() will throw an error.
-       */
+   * Maximum number of items that can be queued in a single partition.
+   * If exceeded, push() will throw an error.
+   */
   maxQueueSize?: number;
   /**
-       * Maximum time to wait before flushing a batch, even if it hasn't reached maxSize.
-       */
+   * Maximum time to wait before flushing a batch, even if it hasn't reached maxSize.
+   */
   maxDuration?: DurationLike;
   /**
-       * Function to determine partition keys for grouping items into separate batches.
-       */
+   * Function to determine partition keys for grouping items into separate batches.
+   */
   partitionBy?: (item: Static<TItem>) => string;
   /**
-       * Maximum number of batch handlers that can execute simultaneously.
-       */
+   * Maximum number of batch handlers that can execute simultaneously.
+   */
   concurrency?: number;
   /**
-       * Retry configuration for failed batch processing operations.
-       */
+   * Retry configuration for failed batch processing operations.
+   */
   retry?: Omit<RetryPrimitiveOptions<() => Array<Static<TItem>>>, "handler">;
 }
 declare class BatchPrimitive<TItem extends TSchema, TResponse = any> extends Primitive<BatchPrimitiveOptions<TItem, TResponse>> {
@@ -239,23 +247,23 @@ declare class BatchPrimitive<TItem extends TSchema, TResponse = any> extends Pri
   protected readonly context: BatchContext<Static<TItem>, TResponse>;
   constructor(...args: ConstructorParameters<typeof Primitive<BatchPrimitiveOptions<TItem, TResponse>>>);
   /**
-       * Pushes an item into the batch and returns immediately with a unique ID.
-       * The item will be processed asynchronously with other items when the batch is flushed.
-       * Use wait(id) to get the processing result.
-       */
+   * Pushes an item into the batch and returns immediately with a unique ID.
+   * The item will be processed asynchronously with other items when the batch is flushed.
+   * Use wait(id) to get the processing result.
+   */
   push(item: Static<TItem>): Promise<string>;
   /**
-       * Wait for a specific item to be processed and get its result.
-       * @param id The item ID returned from push()
-       * @returns The processing result
-       * @throws If the item doesn't exist or processing failed
-       */
+   * Wait for a specific item to be processed and get its result.
+   * @param id The item ID returned from push()
+   * @returns The processing result
+   * @throws If the item doesn't exist or processing failed
+   */
   wait(id: string): Promise<TResponse>;
   /**
-       * Get the current status of an item.
-       * @param id The item ID returned from push()
-       * @returns Status information or undefined if item doesn't exist
-       */
+   * Get the current status of an item.
+   * @param id The item ID returned from push()
+   * @returns Status information or undefined if item doesn't exist
+   */
   status(id: string): {
     status: "pending" | "processing";
   } | {
@@ -266,65 +274,37 @@ declare class BatchPrimitive<TItem extends TSchema, TResponse = any> extends Pri
     error: Error;
   } | undefined;
   /**
-       * Flush all partitions or a specific partition.
-       */
+   * Flush all partitions or a specific partition.
+   */
   flush(partitionKey?: string): Promise<void>;
   /**
-       * Clears completed and failed items from memory.
-       * Call this periodically in long-running applications to prevent memory leaks.
-       *
-       * @param status Optional: only clear items with this specific status ('completed' or 'failed')
-       * @returns The number of items cleared
-       */
+   * Clears completed and failed items from memory.
+   * Call this periodically in long-running applications to prevent memory leaks.
+   *
+   * @param status Optional: only clear items with this specific status ('completed' or 'failed')
+   * @returns The number of items cleared
+   */
   clearCompleted(status?: "completed" | "failed"): number;
-  protected readonly onReady: alepha1.HookPrimitive<"ready">;
-  protected readonly dispose: alepha1.HookPrimitive<"stop">;
+  protected readonly onReady: alepha2.HookPrimitive<"ready">;
 }
 //#endregion
 //#region ../../src/batch/index.d.ts
 /**
- * This module allows you to group multiple asynchronous operations into a single "batch," which is then processed together.
- * This is an essential pattern for improving performance, reducing I/O, and interacting efficiently with rate-limited APIs or databases.
- *
- * ```ts
- * import { Alepha, $hook, run, t } from "alepha";
- * import { $batch } from "alepha/batch";
- *
- * class LoggingService {
- *   // define the batch processor
- *   logBatch = $batch({
- *     schema: t.text(),
- *     maxSize: 10,
- *     maxDuration: [5, "seconds"],
- *     handler: async (items) => {
- *       console.log(`[BATCH LOG] Processing ${items.length} events:`, items);
- *     },
- *   });
- *
- *   // example of how to use it
- *   onReady = $hook({
- *     on: "ready",
- *     handler: async () => {
- *       // push() returns an ID immediately
- *       const id1 = await this.logBatch.push("Application started.");
- *       const id2 = await this.logBatch.push("User authenticated.");
+ * | type | quality | stability |
+ * |------|---------|-----------|
+ * | backend | standard | stable |
  *
- *       // optionally wait for processing to complete
- *       await this.logBatch.wait(id1);
+ * Batch accumulation and processing.
  *
- *       // or check the status
- *       const status = this.logBatch.status(id2);
- *       console.log(status?.status); // "pending" | "processing" | "completed" | "failed"
- *     },
- *   });
- * }
- * ```
+ * **Features:**
+ * - Batch accumulator with handler
+ * - Configurable batch size
+ * - Time-based triggers
+ * - Status tracking
  *
- * @see {@link $batch}
- * @see {@link BatchProvider}
  * @module alepha.batch
  */
-declare const AlephaBatch: alepha1.Service<alepha1.Module>;
+declare const AlephaBatch: alepha2.Service<alepha2.Module>;
 //#endregion
 export { $batch, AlephaBatch, BatchContext, type BatchItemState, type BatchItemStatus, BatchOptions, BatchPrimitive, BatchPrimitiveOptions, BatchProvider, PartitionState };
 //# sourceMappingURL=index.d.ts.map

package/dist/batch/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/batch/providers/BatchProvider.ts","../../src/batch/primitives/$batch.ts","../../src/batch/index.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/batch/providers/BatchProvider.ts","../../src/batch/primitives/$batch.ts","../../src/batch/index.ts"],"mappings":"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"}

package/dist/batch/index.js

@@ -13,10 +13,14 @@ var BatchProvider = class {
 	dateTime = $inject(DateTimeProvider);
 	retryProvider = $inject(RetryProvider);
 	/**
+	* All active batch contexts managed by this provider.
+	*/
+	contexts = /* @__PURE__ */ new Set();
+	/**
 	* Creates a new batch context with the given options.
 	*/
 	createContext(alepha, options) {
-		return {
+		const context = {
 			options,
 			itemStates: /* @__PURE__ */ new Map(),
 			partitions: /* @__PURE__ */ new Map(),
@@ -25,8 +29,25 @@ var BatchProvider = class {
 			isReady: false,
 			alepha
 		};
+		this.contexts.add(context);
+		return context;
 	}
 	/**
+	* Shutdown hook - flushes all batch contexts on application stop.
+	*/
+	onStop = $hook({
+		on: "stop",
+		priority: "first",
+		handler: async () => {
+			if (this.contexts.size === 0) return;
+			this.log.debug(`Shutting down ${this.contexts.size} batch context(s)...`);
+			const promises = [];
+			for (const context of this.contexts) promises.push(this.shutdown(context));
+			await Promise.all(promises);
+			this.log.debug("All batch contexts shut down");
+		}
+	});
+	/**
 	* Get the effective maxSize for a context.
 	*/
 	getMaxSize(context) {
@@ -334,58 +355,24 @@ var BatchPrimitive = class extends Primitive {
 			await this.batchProvider.markReady(this.context);
 		}
 	});
-	dispose = $hook({
-		on: "stop",
-		priority: "first",
-		handler: async () => {
-			await this.batchProvider.shutdown(this.context);
-		}
-	});
 };
 $batch[KIND] = BatchPrimitive;
 
 //#endregion
 //#region ../../src/batch/index.ts
 /**
-* This module allows you to group multiple asynchronous operations into a single "batch," which is then processed together.
-* This is an essential pattern for improving performance, reducing I/O, and interacting efficiently with rate-limited APIs or databases.
-*
-* ```ts
-* import { Alepha, $hook, run, t } from "alepha";
-* import { $batch } from "alepha/batch";
-*
-* class LoggingService {
-*   // define the batch processor
-*   logBatch = $batch({
-*     schema: t.text(),
-*     maxSize: 10,
-*     maxDuration: [5, "seconds"],
-*     handler: async (items) => {
-*       console.log(`[BATCH LOG] Processing ${items.length} events:`, items);
-*     },
-*   });
-*
-*   // example of how to use it
-*   onReady = $hook({
-*     on: "ready",
-*     handler: async () => {
-*       // push() returns an ID immediately
-*       const id1 = await this.logBatch.push("Application started.");
-*       const id2 = await this.logBatch.push("User authenticated.");
+* | type | quality | stability |
+* |------|---------|-----------|
+* | backend | standard | stable |
 *
-*       // optionally wait for processing to complete
-*       await this.logBatch.wait(id1);
+* Batch accumulation and processing.
 *
-*       // or check the status
-*       const status = this.logBatch.status(id2);
-*       console.log(status?.status); // "pending" | "processing" | "completed" | "failed"
-*     },
-*   });
-* }
-* ```
+* **Features:**
+* - Batch accumulator with handler
+* - Configurable batch size
+* - Time-based triggers
+* - Status tracking
 *
-* @see {@link $batch}
-* @see {@link BatchProvider}
 * @module alepha.batch
 */
 const AlephaBatch = $module({