alepha 0.13.0 → 0.13.2

package/dist/batch/index.d.cts

@@ -1,330 +0,0 @@
-import * as alepha1 from "alepha";
-import { Alepha, Descriptor, KIND, Static, TSchema } from "alepha";
-import { DateTimeProvider, DurationLike } from "alepha/datetime";
-import { RetryBackoffOptions, RetryDescriptorOptions, RetryProvider } from "alepha/retry";
-import * as alepha_logger0 from "alepha/logger";
-
-//#region src/batch/providers/BatchProvider.d.ts
-interface BatchOptions<TItem, TResponse = any> {
-  /**
-   * 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
-   */
-  maxSize?: number;
-  /**
-   * 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"]
-   */
-  maxDuration?: DurationLike;
-  /**
-   * 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
-   */
-  concurrency?: number;
-  /**
-   * Retry configuration for failed batch processing operations.
-   */
-  retry?: {
-    /**
-     * 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 }
-     */
-    backoff?: number | RetryBackoffOptions;
-    /**
-     * 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)
-     */
-    when?: (error: Error) => boolean;
-    /**
-     * A custom callback for when a retry attempt fails.
-     * This is called before the delay.
-     */
-    onError?: (error: Error, attempt: number) => void;
-  };
-}
-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;
-}
-/**
- * Context object that holds all state for a batch processor instance.
- */
-interface BatchContext<TItem, TResponse> {
-  options: BatchOptions<TItem, TResponse>;
-  itemStates: Map<string, BatchItemState<TItem, TResponse>>;
-  partitions: Map<string, PartitionState>;
-  activeHandlers: PromiseWithResolvers<void>[];
-  isShuttingDown: boolean;
-  isReady: boolean;
-  alepha: Alepha;
-}
-/**
- * Service for batch processing operations.
- * Provides methods to manage batches of items with automatic flushing based on size or time.
- */
-declare class BatchProvider {
-  protected readonly log: alepha_logger0.Logger;
-  protected readonly dateTime: DateTimeProvider;
-  protected readonly retryProvider: RetryProvider;
-  /**
-   * 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.
-   */
-  protected getMaxSize<TItem, TResponse>(context: BatchContext<TItem, TResponse>): number;
-  /**
-   * Get the effective concurrency for a context.
-   */
-  protected getConcurrency<TItem, TResponse>(context: BatchContext<TItem, TResponse>): number;
-  /**
-   * 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
-   */
-  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<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
-   */
-  status<TItem, TResponse>(context: BatchContext<TItem, TResponse>, id: string): {
-    status: "pending" | "processing";
-  } | {
-    status: "completed";
-    result: TResponse;
-  } | {
-    status: "failed";
-    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
-   */
-  clearCompleted<TItem, TResponse>(context: BatchContext<TItem, TResponse>, status?: "completed" | "failed"): number;
-  /**
-   * Flush all partitions or a specific partition.
-   */
-  flush<TItem, TResponse>(context: BatchContext<TItem, TResponse>, partitionKey?: string): Promise<void>;
-  /**
-   * 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.
-   */
-  markReady<TItem, TResponse>(context: BatchContext<TItem, TResponse>): Promise<void>;
-  /**
-   * 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.
-   */
-  protected startProcessing<TItem, TResponse>(context: BatchContext<TItem, TResponse>): Promise<void>;
-}
-//#endregion
-//#region src/batch/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 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.
-   */
-  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">;
-}
-declare class BatchDescriptor<TItem extends TSchema, TResponse = any> extends Descriptor<BatchDescriptorOptions<TItem, TResponse>> {
-  protected readonly batchProvider: BatchProvider;
-  protected readonly context: BatchContext<Static<TItem>, TResponse>;
-  constructor(...args: ConstructorParameters<typeof Descriptor<BatchDescriptorOptions<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 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
-   */
-  clearCompleted(status?: "completed" | "failed"): number;
-  protected readonly onReady: alepha1.HookDescriptor<"ready">;
-  protected readonly dispose: alepha1.HookDescriptor<"stop">;
-}
-//#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.");
- *
- *       // 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}
- * @see {@link BatchProvider}
- * @module alepha.batch
- */
-declare const AlephaBatch: alepha1.Service<alepha1.Module>;
-//#endregion
-export { $batch, AlephaBatch, BatchContext, BatchDescriptor, BatchDescriptorOptions, type BatchItemState, type BatchItemStatus, BatchOptions, BatchProvider, PartitionState };
-//# sourceMappingURL=index.d.cts.map

package/dist/bin/index.cjs

@@ -1,17 +0,0 @@
-#!/usr/bin/env node
-require("tsx");
-let alepha = require("alepha");
-let alepha_cli = require("alepha/cli");
-
-//#region src/bin/index.ts
-const alepha$1 = alepha.Alepha.create({ env: {
-	LOG_LEVEL: "alepha.core:warn,info",
-	LOG_FORMAT: "raw",
-	CLI_NAME: "alepha",
-	CLI_DESCRIPTION: `Alepha CLI v${alepha_cli.version} - Create and manage Alepha projects.`
-} });
-alepha$1.with(alepha_cli.AlephaCli);
-(0, alepha.run)(alepha$1);
-
-//#endregion
-//# sourceMappingURL=index.cjs.map

package/dist/bin/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","names":["alepha","Alepha","version","AlephaCli"],"sources":["../../src/bin/index.ts"],"sourcesContent":["#!/usr/bin/env node\nimport \"tsx\";\nimport { Alepha, run } from \"alepha\";\nimport { AlephaCli, version } from \"alepha/cli\";\n\nconst alepha = Alepha.create({\n  env: {\n    LOG_LEVEL: \"alepha.core:warn,info\",\n    LOG_FORMAT: \"raw\",\n    CLI_NAME: \"alepha\",\n    CLI_DESCRIPTION: `Alepha CLI v${version} - Create and manage Alepha projects.`,\n  },\n});\n\nalepha.with(AlephaCli);\n\nrun(alepha);\n"],"mappings":";;;;;;AAKA,MAAMA,WAASC,cAAO,OAAO,EAC3B,KAAK;CACH,WAAW;CACX,YAAY;CACZ,UAAU;CACV,iBAAiB,eAAeC,mBAAQ;CACzC,EACF,CAAC;AAEFF,SAAO,KAAKG,qBAAU;gBAElBH,SAAO"}

package/dist/bin/index.d.cts

@@ -1 +0,0 @@
-export { };

package/dist/bucket/index.cjs

@@ -1,303 +0,0 @@
-let alepha = require("alepha");
-let alepha_file = require("alepha/file");
-let node_crypto = require("node:crypto");
-let node_fs = require("node:fs");
-let node_fs_promises = require("node:fs/promises");
-let node_os = require("node:os");
-let node_path = require("node:path");
-let alepha_logger = require("alepha/logger");
-
-//#region src/bucket/errors/InvalidFileError.ts
-var InvalidFileError = class extends Error {
-	status = 400;
-};
-
-//#endregion
-//#region src/bucket/providers/FileStorageProvider.ts
-var FileStorageProvider = class {};
-
-//#endregion
-//#region src/bucket/errors/FileNotFoundError.ts
-var FileNotFoundError = class extends alepha.AlephaError {
-	status = 404;
-};
-
-//#endregion
-//#region src/bucket/providers/MemoryFileStorageProvider.ts
-var MemoryFileStorageProvider = class {
-	files = {};
-	fileSystem = (0, alepha.$inject)(alepha_file.FileSystemProvider);
-	fileDetector = (0, alepha.$inject)(alepha_file.FileDetector);
-	async upload(bucketName, file, fileId) {
-		fileId ??= this.createId();
-		this.files[`${bucketName}/${fileId}`] = this.fileSystem.createFile({
-			stream: file.stream(),
-			name: file.name,
-			type: file.type,
-			size: file.size
-		});
-		return fileId;
-	}
-	async download(bucketName, fileId) {
-		const fileKey = `${bucketName}/${fileId}`;
-		const file = this.files[fileKey];
-		if (!file) throw new FileNotFoundError(`File with ID ${fileId} not found.`);
-		return file;
-	}
-	async exists(bucketName, fileId) {
-		return `${bucketName}/${fileId}` in this.files;
-	}
-	async delete(bucketName, fileId) {
-		const fileKey = `${bucketName}/${fileId}`;
-		if (!(fileKey in this.files)) throw new FileNotFoundError(`File with ID ${fileId} not found.`);
-		delete this.files[fileKey];
-	}
-	createId() {
-		return (0, node_crypto.randomUUID)();
-	}
-};
-
-//#endregion
-//#region src/bucket/descriptors/$bucket.ts
-/**
-* Creates a bucket descriptor for file storage and management with configurable validation.
-*
-* Provides a comprehensive file storage system that handles uploads, downloads, validation,
-* and management across multiple storage backends with MIME type and size limit controls.
-*
-* **Key Features**
-* - Multi-provider support (filesystem, cloud storage, in-memory)
-* - Automatic MIME type and file size validation
-* - Event integration for file operations monitoring
-* - Flexible per-bucket and per-operation configuration
-* - Smart file type and size detection
-*
-* **Common Use Cases**
-* - User profile pictures and document uploads
-* - Product images and media management
-* - Document storage and retrieval systems
-*
-* @example
-* ```ts
-* class MediaService {
-*   images = $bucket({
-*     name: "user-images",
-*     mimeTypes: ["image/jpeg", "image/png", "image/gif"],
-*     maxSize: 5 // 5MB limit
-*   });
-*
-*   documents = $bucket({
-*     name: "documents",
-*     mimeTypes: ["application/pdf", "text/plain"],
-*     maxSize: 50 // 50MB limit
-*   });
-*
-*   async uploadProfileImage(file: FileLike, userId: string): Promise<string> {
-*     const fileId = await this.images.upload(file);
-*     await this.userService.updateProfileImage(userId, fileId);
-*     return fileId;
-*   }
-*
-*   async downloadDocument(documentId: string): Promise<FileLike> {
-*     return await this.documents.download(documentId);
-*   }
-*
-*   async deleteDocument(documentId: string): Promise<void> {
-*     await this.documents.delete(documentId);
-*   }
-* }
-* ```
-*/
-const $bucket = (options) => (0, alepha.createDescriptor)(BucketDescriptor, options);
-var BucketDescriptor = class extends alepha.Descriptor {
-	provider = this.$provider();
-	fileSystem = (0, alepha.$inject)(alepha_file.FileSystemProvider);
-	get name() {
-		return this.options.name ?? `${this.config.propertyKey}`;
-	}
-	/**
-	* Uploads a file to the bucket.
-	*/
-	async upload(file, options) {
-		if (file instanceof File) file = this.fileSystem.createFile({ file });
-		options = {
-			...this.options,
-			...options
-		};
-		const mimeTypes = options.mimeTypes ?? void 0;
-		const maxSize = options.maxSize ?? 10;
-		if (mimeTypes) {
-			const mimeType = file.type || "application/octet-stream";
-			if (!mimeTypes.includes(mimeType)) throw new InvalidFileError(`MIME type ${mimeType} is not allowed in bucket ${this.name}`);
-		}
-		if (file.size > maxSize * 1024 * 1024) throw new InvalidFileError(`File size ${file.size} exceeds the maximum size of ${this.options.maxSize} MB in bucket ${this.name}`);
-		const id = await this.provider.upload(this.name, file);
-		await this.alepha.events.emit("bucket:file:uploaded", {
-			id,
-			bucket: this,
-			file,
-			options
-		});
-		return id;
-	}
-	/**
-	* Delete permanently a file from the bucket.
-	*/
-	async delete(fileId, skipHook = false) {
-		await this.provider.delete(this.name, fileId);
-		if (skipHook) return;
-		await this.alepha.events.emit("bucket:file:deleted", {
-			id: fileId,
-			bucket: this
-		});
-	}
-	/**
-	* Checks if a file exists in the bucket.
-	*/
-	async exists(fileId) {
-		return this.provider.exists(this.name, fileId);
-	}
-	/**
-	* Downloads a file from the bucket.
-	*/
-	async download(fileId) {
-		return this.provider.download(this.name, fileId);
-	}
-	$provider() {
-		if (!this.options.provider) return this.alepha.inject(FileStorageProvider);
-		if (this.options.provider === "memory") return this.alepha.inject(MemoryFileStorageProvider);
-		return this.alepha.inject(this.options.provider);
-	}
-};
-$bucket[alepha.KIND] = BucketDescriptor;
-
-//#endregion
-//#region src/bucket/providers/LocalFileStorageProvider.ts
-/**
-* Local file storage configuration atom
-*/
-const localFileStorageOptions = (0, alepha.$atom)({
-	name: "alepha.bucket.local.options",
-	schema: alepha.t.object({ storagePath: alepha.t.string({ description: "Directory path where files will be stored" }) }),
-	default: { storagePath: "node_modules/.alepha/buckets" }
-});
-var LocalFileStorageProvider = class {
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	log = (0, alepha_logger.$logger)();
-	fileDetector = (0, alepha.$inject)(alepha_file.FileDetector);
-	fileSystemProvider = (0, alepha.$inject)(alepha_file.FileSystemProvider);
-	options = (0, alepha.$use)(localFileStorageOptions);
-	get storagePath() {
-		return this.options.storagePath;
-	}
-	onConfigure = (0, alepha.$hook)({
-		on: "configure",
-		handler: async () => {
-			if (this.alepha.isTest() && this.storagePath === localFileStorageOptions.options.default.storagePath) this.alepha.state.set(localFileStorageOptions, { storagePath: (0, node_path.join)((0, node_os.tmpdir)(), `alepha-test-${Date.now()}`) });
-		}
-	});
-	onStart = (0, alepha.$hook)({
-		on: "start",
-		handler: async () => {
-			try {
-				await (0, node_fs_promises.mkdir)(this.storagePath, { recursive: true });
-			} catch {}
-			for (const bucket of this.alepha.descriptors($bucket)) {
-				if (bucket.provider !== this) continue;
-				await (0, node_fs_promises.mkdir)((0, node_path.join)(this.storagePath, bucket.name), { recursive: true });
-				this.log.debug(`Bucket '${bucket.name}' at ${this.storagePath} OK`);
-			}
-		}
-	});
-	async upload(bucketName, file, fileId) {
-		fileId ??= this.createId(file.type);
-		this.log.trace(`Uploading file to ${bucketName}`);
-		await this.fileSystemProvider.writeFile(this.path(bucketName, fileId), file);
-		return fileId;
-	}
-	async download(bucketName, fileId) {
-		const filePath = this.path(bucketName, fileId);
-		try {
-			const stats = await (0, node_fs_promises.stat)(filePath);
-			const mimeType = this.fileDetector.getContentType(fileId);
-			return this.fileSystemProvider.createFile({
-				stream: (0, node_fs.createReadStream)(filePath),
-				name: fileId,
-				type: mimeType,
-				size: stats.size
-			});
-		} catch (error) {
-			if (this.isErrorNoEntry(error)) throw new FileNotFoundError(`File with ID ${fileId} not found.`);
-			throw new alepha.AlephaError("Invalid file operation", { cause: error });
-		}
-	}
-	async exists(bucketName, fileId) {
-		try {
-			await (0, node_fs_promises.stat)(this.path(bucketName, fileId));
-			return true;
-		} catch (error) {
-			if (this.isErrorNoEntry(error)) return false;
-			throw new alepha.AlephaError("Error checking file existence", { cause: error });
-		}
-	}
-	async delete(bucketName, fileId) {
-		try {
-			return await (0, node_fs_promises.unlink)(this.path(bucketName, fileId));
-		} catch (error) {
-			if (this.isErrorNoEntry(error)) throw new FileNotFoundError(`File with ID ${fileId} not found.`);
-			throw new alepha.AlephaError("Error deleting file", { cause: error });
-		}
-	}
-	stat(bucket, fileId) {
-		return (0, node_fs_promises.stat)(this.path(bucket, fileId));
-	}
-	createId(mimeType) {
-		const ext = this.fileDetector.getExtensionFromMimeType(mimeType);
-		return `${(0, node_crypto.randomUUID)()}.${ext}`;
-	}
-	path(bucket, fileId = "") {
-		return (0, node_path.join)(this.storagePath, bucket, fileId);
-	}
-	isErrorNoEntry(error) {
-		return error instanceof Error && "code" in error && error.code === "ENOENT";
-	}
-};
-
-//#endregion
-//#region src/bucket/index.ts
-/**
-* Provides file storage capabilities through declarative bucket descriptors with support for multiple storage backends.
-*
-* The bucket module enables unified file operations across different storage systems using the `$bucket` descriptor
-* on class properties. It abstracts storage provider differences, offering consistent APIs for local filesystem,
-* cloud storage, or in-memory storage for testing environments.
-*
-* @see {@link $bucket}
-* @see {@link FileStorageProvider}
-* @module alepha.bucket
-*/
-const AlephaBucket = (0, alepha.$module)({
-	name: "alepha.bucket",
-	descriptors: [$bucket],
-	services: [
-		FileStorageProvider,
-		MemoryFileStorageProvider,
-		LocalFileStorageProvider
-	],
-	register: (alepha$1) => alepha$1.with({
-		optional: true,
-		provide: FileStorageProvider,
-		use: alepha$1.isTest() ? MemoryFileStorageProvider : LocalFileStorageProvider
-	})
-});
-
-//#endregion
-exports.$bucket = $bucket;
-exports.AlephaBucket = AlephaBucket;
-exports.BucketDescriptor = BucketDescriptor;
-exports.FileNotFoundError = FileNotFoundError;
-exports.FileStorageProvider = FileStorageProvider;
-exports.LocalFileStorageProvider = LocalFileStorageProvider;
-exports.MemoryFileStorageProvider = MemoryFileStorageProvider;
-exports.localFileStorageOptions = localFileStorageOptions;
-//# sourceMappingURL=index.cjs.map