alepha 0.11.9 → 0.11.10

package/api/users.js

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

package/api/verifications.cjs

@@ -1,8 +0,0 @@
-'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

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

package/api/verifications.js

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

package/batch.cjs

@@ -1,8 +0,0 @@
-'use strict';
-var m = require('@alepha/batch');
-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/batch.d.ts

@@ -1,154 +0,0 @@
-import * as _alepha_core1 from "alepha";
-import { Descriptor, KIND, Static, TSchema } from "alepha";
-import { DateTimeProvider, DurationLike } from "alepha/datetime";
-import * as _alepha_logger0 from "alepha/logger";
-import * as _alepha_retry0 from "alepha/retry";
-import { RetryDescriptorOptions } from "alepha/retry";
-import * as typebox0 from "typebox";
-
-//#region src/descriptors/$batch.d.ts
-/**
- * Creates a batch processing descriptor for efficient grouping and processing of multiple operations.
- */
-declare const $batch: {
-  <TItem extends TSchema, TResponse>(options: BatchDescriptorOptions<TItem, TResponse>): BatchDescriptor<TItem, TResponse>;
-  [KIND]: typeof BatchDescriptor;
-};
-interface BatchDescriptorOptions<TItem extends TSchema, TResponse = any> {
-  /**
-   * TypeBox schema for validating each item added to the batch.
-   */
-  schema: TItem;
-  /**
-   * 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.
-   */
-  maxSize?: number;
-  /**
-   * 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.
-   */
-  partitionBy?: (item: Static<TItem>) => string;
-  /**
-   * Maximum number of batch handlers that can execute simultaneously.
-   */
-  concurrency?: number;
-  /**
-   * Retry configuration for failed batch processing operations.
-   */
-  retry?: Omit<RetryDescriptorOptions<() => Array<Static<TItem>>>, "handler">;
-}
-type BatchItemStatus = "pending" | "processing" | "completed" | "failed";
-interface BatchItemState<TItem, TResponse> {
-  id: string;
-  item: TItem;
-  partitionKey: string;
-  status: BatchItemStatus;
-  result?: TResponse;
-  error?: Error;
-  promise?: Promise<TResponse>;
-  resolve?: (value: TResponse) => void;
-  reject?: (error: Error) => void;
-}
-interface PartitionState {
-  itemIds: string[];
-  timeout?: {
-    clear: () => void;
-  };
-  flushing: boolean;
-}
-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 itemStates: Map<string, BatchItemState<typebox0.StaticType<[], "Decode", {}, {}, TItem>, TResponse>>;
-  protected readonly partitions: Map<string, PartitionState>;
-  protected activeHandlers: PromiseWithResolvers<void>[];
-  protected isShuttingDown: boolean;
-  protected get maxSize(): number;
-  protected get concurrency(): number;
-  protected get maxDuration(): DurationLike;
-  protected retry: _alepha_retry0.RetryDescriptorFn<(items: typebox0.StaticType<[], "Decode", {}, {}, 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.
-   */
-  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(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
-   */
-  status(id: string): {
-    status: "pending" | "processing";
-  } | {
-    status: "completed";
-    result: TResponse;
-  } | {
-    status: "failed";
-    error: Error;
-  } | undefined;
-  flush(partitionKey?: string): Promise<void>;
-  protected flushPartition(partitionKey: string): Promise<void>;
-  protected readonly dispose: _alepha_core1.HookDescriptor<"stop">;
-}
-//#endregion
-//#region src/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.");
- *
- *       // optionally wait for processing to complete
- *       await this.logBatch.wait(id1);
- *
- *       // or check the status
- *       const status = this.logBatch.status(id2);
- *       console.log(status?.status); // "pending" | "processing" | "completed" | "failed"
- *     },
- *   });
- * }
- * ```
- *
- * @see {@link $batch}
- * @module alepha.batch
- */
-declare const AlephaBatch: _alepha_core1.Service<_alepha_core1.Module>;
-//#endregion
-export { $batch, AlephaBatch, BatchDescriptor, BatchDescriptorOptions, BatchItemState, BatchItemStatus };
-//# sourceMappingURL=index.d.ts.map

package/batch.js

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

package/bucket.cjs

@@ -1,8 +0,0 @@
-'use strict';
-var m = require('@alepha/bucket');
-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]; }
-	});
-});