alepha 0.13.0 → 0.13.1

package/dist/bucket/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","names":["AlephaError","FileSystemProvider","FileDetector","Descriptor","FileSystemProvider","KIND","t","Alepha","FileDetector","FileSystemProvider","AlephaError","alepha"],"sources":["../../src/bucket/errors/InvalidFileError.ts","../../src/bucket/providers/FileStorageProvider.ts","../../src/bucket/errors/FileNotFoundError.ts","../../src/bucket/providers/MemoryFileStorageProvider.ts","../../src/bucket/descriptors/$bucket.ts","../../src/bucket/providers/LocalFileStorageProvider.ts","../../src/bucket/index.ts"],"sourcesContent":["export class InvalidFileError extends Error {\n  public readonly status = 400;\n}\n","import type { FileLike } from \"alepha\";\n\nexport abstract class FileStorageProvider {\n  /**\n   * Uploads a file to the storage.\n   *\n   * @param bucketName - Container name\n   * @param file - File to upload\n   * @param fileId - Optional file identifier. If not provided, a unique ID will be generated.\n   * @return The identifier of the uploaded file.\n   */\n  abstract upload(\n    bucketName: string,\n    file: FileLike,\n    fileId?: string,\n  ): Promise<string>;\n\n  /**\n   * Downloads a file from the storage.\n   *\n   * @param bucketName - Container name\n   * @param fileId - Identifier of the file to download\n   * @return The downloaded file as a FileLike object.\n   */\n  abstract download(bucketName: string, fileId: string): Promise<FileLike>;\n\n  /**\n   * Check if fileId exists in the storage bucket.\n   *\n   * @param bucketName - Container name\n   * @param fileId - Identifier of the file to stream\n   * @return True is the file exists, false otherwise.\n   */\n  abstract exists(bucketName: string, fileId: string): Promise<boolean>;\n\n  /**\n   * Delete permanently a file from the storage.\n   *\n   * @param bucketName - Container name\n   * @param fileId - Identifier of the file to delete\n   */\n  abstract delete(bucketName: string, fileId: string): Promise<void>;\n}\n","import { AlephaError } from \"alepha\";\n\nexport class FileNotFoundError extends AlephaError {\n  public readonly status = 404;\n}\n","import { randomUUID } from \"node:crypto\";\nimport { $inject, type FileLike } from \"alepha\";\nimport { FileDetector, FileSystemProvider } from \"alepha/file\";\nimport { FileNotFoundError } from \"../errors/FileNotFoundError.ts\";\nimport type { FileStorageProvider } from \"./FileStorageProvider.ts\";\n\nexport class MemoryFileStorageProvider implements FileStorageProvider {\n  public readonly files: Record<string, FileLike> = {};\n  protected readonly fileSystem = $inject(FileSystemProvider);\n  protected readonly fileDetector = $inject(FileDetector);\n\n  public async upload(\n    bucketName: string,\n    file: FileLike,\n    fileId?: string,\n  ): Promise<string> {\n    fileId ??= this.createId();\n\n    this.files[`${bucketName}/${fileId}`] = this.fileSystem.createFile({\n      stream: file.stream(),\n      name: file.name,\n      type: file.type,\n      size: file.size,\n    });\n\n    return fileId;\n  }\n\n  public async download(bucketName: string, fileId: string): Promise<FileLike> {\n    const fileKey = `${bucketName}/${fileId}`;\n    const file = this.files[fileKey];\n\n    if (!file) {\n      throw new FileNotFoundError(`File with ID ${fileId} not found.`);\n    }\n\n    return file;\n  }\n\n  public async exists(bucketName: string, fileId: string): Promise<boolean> {\n    return `${bucketName}/${fileId}` in this.files;\n  }\n\n  public async delete(bucketName: string, fileId: string): Promise<void> {\n    const fileKey = `${bucketName}/${fileId}`;\n    if (!(fileKey in this.files)) {\n      throw new FileNotFoundError(`File with ID ${fileId} not found.`);\n    }\n\n    delete this.files[fileKey];\n  }\n\n  protected createId(): string {\n    return randomUUID();\n  }\n}\n","import {\n  $inject,\n  createDescriptor,\n  Descriptor,\n  type FileLike,\n  KIND,\n  type Service,\n} from \"alepha\";\nimport { FileSystemProvider } from \"alepha/file\";\nimport { InvalidFileError } from \"../errors/InvalidFileError.ts\";\nimport { FileStorageProvider } from \"../providers/FileStorageProvider.ts\";\nimport { MemoryFileStorageProvider } from \"../providers/MemoryFileStorageProvider.ts\";\n\n/**\n * Creates a bucket descriptor for file storage and management with configurable validation.\n *\n * Provides a comprehensive file storage system that handles uploads, downloads, validation,\n * and management across multiple storage backends with MIME type and size limit controls.\n *\n * **Key Features**\n * - Multi-provider support (filesystem, cloud storage, in-memory)\n * - Automatic MIME type and file size validation\n * - Event integration for file operations monitoring\n * - Flexible per-bucket and per-operation configuration\n * - Smart file type and size detection\n *\n * **Common Use Cases**\n * - User profile pictures and document uploads\n * - Product images and media management\n * - Document storage and retrieval systems\n *\n * @example\n * ```ts\n * class MediaService {\n *   images = $bucket({\n *     name: \"user-images\",\n *     mimeTypes: [\"image/jpeg\", \"image/png\", \"image/gif\"],\n *     maxSize: 5 // 5MB limit\n *   });\n *\n *   documents = $bucket({\n *     name: \"documents\",\n *     mimeTypes: [\"application/pdf\", \"text/plain\"],\n *     maxSize: 50 // 50MB limit\n *   });\n *\n *   async uploadProfileImage(file: FileLike, userId: string): Promise<string> {\n *     const fileId = await this.images.upload(file);\n *     await this.userService.updateProfileImage(userId, fileId);\n *     return fileId;\n *   }\n *\n *   async downloadDocument(documentId: string): Promise<FileLike> {\n *     return await this.documents.download(documentId);\n *   }\n *\n *   async deleteDocument(documentId: string): Promise<void> {\n *     await this.documents.delete(documentId);\n *   }\n * }\n * ```\n */\nexport const $bucket = (options: BucketDescriptorOptions) =>\n  createDescriptor(BucketDescriptor, options);\n\nexport interface BucketDescriptorOptions extends BucketFileOptions {\n  /**\n   * File storage provider configuration for the bucket.\n   *\n   * Options:\n   * - **\"memory\"**: In-memory storage (default for development, lost on restart)\n   * - **Service<FileStorageProvider>**: Custom provider class (e.g., S3FileStorageProvider, AzureBlobProvider)\n   * - **undefined**: Uses the default file storage provider from dependency injection\n   *\n   * **Provider Selection Guidelines**:\n   * - **Development**: Use \"memory\" for fast, simple testing without external dependencies\n   * - **Production**: Use cloud providers (S3, Azure Blob, Google Cloud Storage) for scalability\n   * - **Local deployment**: Use filesystem providers for on-premise installations\n   * - **Hybrid**: Use different providers for different bucket types (temp files vs permanent storage)\n   *\n   * **Provider Capabilities**:\n   * - File persistence and durability guarantees\n   * - Scalability and performance characteristics\n   * - Geographic distribution and CDN integration\n   * - Cost implications for storage and bandwidth\n   * - Backup and disaster recovery features\n   *\n   * @default Uses injected FileStorageProvider\n   * @example \"memory\"\n   * @example S3FileStorageProvider\n   * @example AzureBlobStorageProvider\n   */\n  provider?: Service<FileStorageProvider> | \"memory\";\n\n  /**\n   * Unique name identifier for the bucket.\n   *\n   * This name is used for:\n   * - Storage backend organization and partitioning\n   * - File path generation and URL construction\n   * - Logging, monitoring, and debugging\n   * - Access control and permissions management\n   * - Backup and replication configuration\n   *\n   * **Naming Conventions**:\n   * - Use lowercase with hyphens for consistency\n   * - Include purpose or content type in the name\n   * - Avoid spaces and special characters\n   * - Consider environment prefixes for deployment isolation\n   *\n   * If not provided, defaults to the property key where the bucket is declared.\n   *\n   * @example \"user-avatars\"\n   * @example \"product-images\"\n   * @example \"legal-documents\"\n   * @example \"temp-processing-files\"\n   */\n  name?: string;\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport interface BucketFileOptions {\n  /**\n   * Human-readable description of the bucket's purpose and contents.\n   *\n   * Used for:\n   * - Documentation generation and API references\n   * - Developer onboarding and system understanding\n   * - Monitoring dashboards and admin interfaces\n   * - Compliance and audit documentation\n   *\n   * **Description Best Practices**:\n   * - Explain what types of files this bucket stores\n   * - Mention any special handling or processing requirements\n   * - Include information about retention policies if applicable\n   * - Note any compliance or security considerations\n   *\n   * @example \"User profile pictures and avatar images\"\n   * @example \"Product catalog images with automated thumbnail generation\"\n   * @example \"Legal documents requiring long-term retention\"\n   * @example \"Temporary files for data processing workflows\"\n   */\n  description?: string;\n\n  /**\n   * Array of allowed MIME types for files uploaded to this bucket.\n   *\n   * When specified, only files with these exact MIME types will be accepted.\n   * Files with disallowed MIME types will be rejected with an InvalidFileError.\n   *\n   * **MIME Type Categories**:\n   * - Images: \"image/jpeg\", \"image/png\", \"image/gif\", \"image/webp\", \"image/svg+xml\"\n   * - Documents: \"application/pdf\", \"text/plain\", \"text/csv\"\n   * - Office: \"application/msword\", \"application/vnd.openxmlformats-officedocument.wordprocessingml.document\"\n   * - Archives: \"application/zip\", \"application/x-tar\", \"application/gzip\"\n   * - Media: \"video/mp4\", \"audio/mpeg\", \"audio/wav\"\n   *\n   * **Security Considerations**:\n   * - Always validate MIME types for user uploads\n   * - Be cautious with executable file types\n   * - Consider using allow-lists rather than deny-lists\n   * - Remember that MIME types can be spoofed by malicious users\n   *\n   * If not specified, all MIME types are allowed (not recommended for user uploads).\n   *\n   * @example [\"image/jpeg\", \"image/png\"] // Only JPEG and PNG images\n   * @example [\"application/pdf\", \"text/plain\"] // Documents only\n   * @example [\"video/mp4\", \"video/webm\"] // Video files\n   */\n  mimeTypes?: string[];\n\n  /**\n   * Maximum file size allowed in megabytes (MB).\n   *\n   * Files larger than this limit will be rejected with an InvalidFileError.\n   * This helps prevent:\n   * - Storage quota exhaustion\n   * - Memory issues during file processing\n   * - Long upload times and timeouts\n   * - Abuse of storage resources\n   *\n   * **Size Guidelines by File Type**:\n   * - Profile images: 1-5 MB\n   * - Product photos: 5-10 MB\n   * - Documents: 10-50 MB\n   * - Video files: 50-500 MB\n   * - Data files: 100-1000 MB\n   *\n   * **Considerations**:\n   * - Consider your storage costs and limits\n   * - Factor in network upload speeds for users\n   * - Account for processing requirements (thumbnails, compression)\n   * - Set reasonable limits based on actual use cases\n   *\n   * @default 10 MB\n   *\n   * @example 1    // 1MB for small images\n   * @example 25   // 25MB for documents\n   * @example 100  // 100MB for media files\n   */\n  maxSize?: number;\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport class BucketDescriptor extends Descriptor<BucketDescriptorOptions> {\n  public readonly provider = this.$provider();\n  private readonly fileSystem = $inject(FileSystemProvider);\n\n  public get name() {\n    return this.options.name ?? `${this.config.propertyKey}`;\n  }\n\n  /**\n   * Uploads a file to the bucket.\n   */\n  public async upload(\n    file: FileLike,\n    options?: BucketFileOptions,\n  ): Promise<string> {\n    if (file instanceof File) {\n      // our createFile is smarter than the browser's File constructor\n      // by doing this, we can guess the MIME type and size!\n      file = this.fileSystem.createFile({ file });\n    }\n\n    options = {\n      ...this.options,\n      ...options,\n    };\n\n    const mimeTypes = options.mimeTypes ?? undefined;\n    const maxSize = options.maxSize ?? 10; // Default to 10 MB if not specified\n\n    if (mimeTypes) {\n      const mimeType = file.type || \"application/octet-stream\";\n      if (!mimeTypes.includes(mimeType)) {\n        throw new InvalidFileError(\n          `MIME type ${mimeType} is not allowed in bucket ${this.name}`,\n        );\n      }\n    }\n\n    // check size in bytes, convert MB to bytes\n    if (file.size > maxSize * 1024 * 1024) {\n      throw new InvalidFileError(\n        `File size ${file.size} exceeds the maximum size of ${this.options.maxSize} MB in bucket ${this.name}`,\n      );\n    }\n\n    const id = await this.provider.upload(this.name, file);\n\n    await this.alepha.events.emit(\"bucket:file:uploaded\", {\n      id,\n      bucket: this,\n      file,\n      options,\n    });\n\n    return id;\n  }\n\n  /**\n   * Delete permanently a file from the bucket.\n   */\n  public async delete(fileId: string, skipHook = false): Promise<void> {\n    await this.provider.delete(this.name, fileId);\n\n    if (skipHook) {\n      return;\n    }\n\n    await this.alepha.events.emit(\"bucket:file:deleted\", {\n      id: fileId,\n      bucket: this,\n    });\n  }\n\n  /**\n   * Checks if a file exists in the bucket.\n   */\n  public async exists(fileId: string): Promise<boolean> {\n    return this.provider.exists(this.name, fileId);\n  }\n\n  /**\n   * Downloads a file from the bucket.\n   */\n  public async download(fileId: string): Promise<FileLike> {\n    return this.provider.download(this.name, fileId);\n  }\n\n  protected $provider() {\n    if (!this.options.provider) {\n      return this.alepha.inject(FileStorageProvider);\n    }\n    if (this.options.provider === \"memory\") {\n      return this.alepha.inject(MemoryFileStorageProvider);\n    }\n    return this.alepha.inject(this.options.provider);\n  }\n}\n\n$bucket[KIND] = BucketDescriptor;\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport interface BucketFileOptions {\n  /**\n   * Optional description of the bucket.\n   */\n  description?: string;\n\n  /**\n   * Allowed MIME types.\n   */\n  mimeTypes?: string[];\n\n  /**\n   * Maximum size of the files in the bucket.\n   *\n   * @default 10\n   */\n  maxSize?: number;\n}\n","import { randomUUID } from \"node:crypto\";\nimport type * as fs from \"node:fs\";\nimport { createReadStream } from \"node:fs\";\nimport { mkdir, stat, unlink } from \"node:fs/promises\";\nimport { tmpdir } from \"node:os\";\nimport { join } from \"node:path\";\nimport {\n  $atom,\n  $hook,\n  $inject,\n  $use,\n  Alepha,\n  AlephaError,\n  type FileLike,\n  type Static,\n  t,\n} from \"alepha\";\nimport { FileDetector, FileSystemProvider } from \"alepha/file\";\nimport { $logger } from \"alepha/logger\";\nimport { $bucket } from \"../descriptors/$bucket.ts\";\nimport { FileNotFoundError } from \"../errors/FileNotFoundError.ts\";\nimport type { FileStorageProvider } from \"./FileStorageProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Local file storage configuration atom\n */\nexport const localFileStorageOptions = $atom({\n  name: \"alepha.bucket.local.options\",\n  schema: t.object({\n    storagePath: t.string({\n      description: \"Directory path where files will be stored\",\n    }),\n  }),\n  default: {\n    storagePath: \"node_modules/.alepha/buckets\",\n  },\n});\n\nexport type LocalFileStorageProviderOptions = Static<\n  typeof localFileStorageOptions.schema\n>;\n\ndeclare module \"alepha\" {\n  interface State {\n    [localFileStorageOptions.key]: LocalFileStorageProviderOptions;\n  }\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport class LocalFileStorageProvider implements FileStorageProvider {\n  protected readonly alepha = $inject(Alepha);\n  protected readonly log = $logger();\n  protected readonly fileDetector = $inject(FileDetector);\n  protected readonly fileSystemProvider = $inject(FileSystemProvider);\n  protected readonly options = $use(localFileStorageOptions);\n\n  protected get storagePath(): string {\n    return this.options.storagePath;\n  }\n\n  protected readonly onConfigure = $hook({\n    on: \"configure\",\n    handler: async () => {\n      if (\n        this.alepha.isTest() &&\n        this.storagePath === localFileStorageOptions.options.default.storagePath\n      ) {\n        this.alepha.state.set(localFileStorageOptions, {\n          storagePath: join(tmpdir(), `alepha-test-${Date.now()}`),\n        });\n      }\n    },\n  });\n\n  protected readonly onStart = $hook({\n    on: \"start\",\n    handler: async () => {\n      try {\n        await mkdir(this.storagePath, { recursive: true });\n      } catch {}\n\n      for (const bucket of this.alepha.descriptors($bucket)) {\n        if (bucket.provider !== this) {\n          continue;\n        }\n\n        await mkdir(join(this.storagePath, bucket.name), {\n          recursive: true,\n        });\n\n        this.log.debug(`Bucket '${bucket.name}' at ${this.storagePath} OK`);\n      }\n    },\n  });\n\n  public async upload(\n    bucketName: string,\n    file: FileLike,\n    fileId?: string,\n  ): Promise<string> {\n    fileId ??= this.createId(file.type);\n\n    this.log.trace(`Uploading file to ${bucketName}`);\n\n    await this.fileSystemProvider.writeFile(\n      this.path(bucketName, fileId),\n      file,\n    );\n\n    return fileId;\n  }\n\n  public async download(bucketName: string, fileId: string): Promise<FileLike> {\n    const filePath = this.path(bucketName, fileId);\n\n    try {\n      const stats = await stat(filePath);\n      const mimeType = this.fileDetector.getContentType(fileId);\n\n      return this.fileSystemProvider.createFile({\n        stream: createReadStream(filePath),\n        name: fileId,\n        type: mimeType,\n        size: stats.size,\n      });\n    } catch (error) {\n      if (this.isErrorNoEntry(error)) {\n        throw new FileNotFoundError(`File with ID ${fileId} not found.`);\n      }\n      throw new AlephaError(\"Invalid file operation\", { cause: error });\n    }\n  }\n\n  public async exists(bucketName: string, fileId: string): Promise<boolean> {\n    try {\n      await stat(this.path(bucketName, fileId));\n      return true;\n    } catch (error) {\n      if (this.isErrorNoEntry(error)) {\n        return false;\n      }\n      throw new AlephaError(\"Error checking file existence\", { cause: error });\n    }\n  }\n\n  public async delete(bucketName: string, fileId: string): Promise<void> {\n    try {\n      return await unlink(this.path(bucketName, fileId));\n    } catch (error) {\n      if (this.isErrorNoEntry(error)) {\n        throw new FileNotFoundError(`File with ID ${fileId} not found.`);\n      }\n      throw new AlephaError(\"Error deleting file\", { cause: error });\n    }\n  }\n\n  protected stat(bucket: string, fileId: string): Promise<fs.Stats> {\n    return stat(this.path(bucket, fileId));\n  }\n\n  protected createId(mimeType: string): string {\n    const ext = this.fileDetector.getExtensionFromMimeType(mimeType);\n    return `${randomUUID()}.${ext}`;\n  }\n\n  protected path(bucket: string, fileId = \"\"): string {\n    return join(this.storagePath, bucket, fileId);\n  }\n\n  protected isErrorNoEntry(error: unknown): boolean {\n    return error instanceof Error && \"code\" in error && error.code === \"ENOENT\";\n  }\n}\n","import { $module, type FileLike } from \"alepha\";\nimport {\n  $bucket,\n  type BucketDescriptor,\n  type BucketFileOptions,\n} from \"./descriptors/$bucket.ts\";\nimport { FileStorageProvider } from \"./providers/FileStorageProvider.ts\";\nimport { LocalFileStorageProvider } from \"./providers/LocalFileStorageProvider.ts\";\nimport { MemoryFileStorageProvider } from \"./providers/MemoryFileStorageProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport * from \"./descriptors/$bucket.ts\";\nexport * from \"./errors/FileNotFoundError.ts\";\nexport * from \"./providers/FileStorageProvider.ts\";\nexport * from \"./providers/LocalFileStorageProvider.ts\";\nexport * from \"./providers/MemoryFileStorageProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\ndeclare module \"alepha\" {\n  interface Hooks {\n    /**\n     * Triggered when a file is uploaded to a bucket.\n     * Can be used to perform actions after a file is uploaded, like creating a database record!\n     */\n    \"bucket:file:uploaded\": {\n      id: string;\n      file: FileLike;\n      bucket: BucketDescriptor;\n      options: BucketFileOptions;\n    };\n    /**\n     * Triggered when a file is deleted from a bucket.\n     */\n    \"bucket:file:deleted\": {\n      id: string;\n      bucket: BucketDescriptor;\n    };\n  }\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Provides file storage capabilities through declarative bucket descriptors with support for multiple storage backends.\n *\n * The bucket module enables unified file operations across different storage systems using the `$bucket` descriptor\n * on class properties. It abstracts storage provider differences, offering consistent APIs for local filesystem,\n * cloud storage, or in-memory storage for testing environments.\n *\n * @see {@link $bucket}\n * @see {@link FileStorageProvider}\n * @module alepha.bucket\n */\nexport const AlephaBucket = $module({\n  name: \"alepha.bucket\",\n  descriptors: [$bucket],\n  services: [\n    FileStorageProvider,\n    MemoryFileStorageProvider,\n    LocalFileStorageProvider,\n  ],\n  register: (alepha) =>\n    alepha.with({\n      optional: true,\n      provide: FileStorageProvider,\n      use: alepha.isTest()\n        ? MemoryFileStorageProvider\n        : LocalFileStorageProvider,\n    }),\n});\n"],"mappings":"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"}

package/dist/bucket/index.d.cts

@@ -1,355 +0,0 @@
-import * as alepha1 from "alepha";
-import { Alepha, AlephaError, Descriptor, FileLike, KIND, Service, Static } from "alepha";
-import { FileDetector, FileSystemProvider } from "alepha/file";
-import * as alepha_logger0 from "alepha/logger";
-import * as fs from "node:fs";
-
-//#region src/bucket/providers/FileStorageProvider.d.ts
-declare abstract class FileStorageProvider {
-  /**
-   * Uploads a file to the storage.
-   *
-   * @param bucketName - Container name
-   * @param file - File to upload
-   * @param fileId - Optional file identifier. If not provided, a unique ID will be generated.
-   * @return The identifier of the uploaded file.
-   */
-  abstract upload(bucketName: string, file: FileLike, fileId?: string): Promise<string>;
-  /**
-   * Downloads a file from the storage.
-   *
-   * @param bucketName - Container name
-   * @param fileId - Identifier of the file to download
-   * @return The downloaded file as a FileLike object.
-   */
-  abstract download(bucketName: string, fileId: string): Promise<FileLike>;
-  /**
-   * Check if fileId exists in the storage bucket.
-   *
-   * @param bucketName - Container name
-   * @param fileId - Identifier of the file to stream
-   * @return True is the file exists, false otherwise.
-   */
-  abstract exists(bucketName: string, fileId: string): Promise<boolean>;
-  /**
-   * Delete permanently a file from the storage.
-   *
-   * @param bucketName - Container name
-   * @param fileId - Identifier of the file to delete
-   */
-  abstract delete(bucketName: string, fileId: string): Promise<void>;
-}
-//#endregion
-//#region src/bucket/providers/MemoryFileStorageProvider.d.ts
-declare class MemoryFileStorageProvider implements FileStorageProvider {
-  readonly files: Record<string, FileLike>;
-  protected readonly fileSystem: FileSystemProvider;
-  protected readonly fileDetector: FileDetector;
-  upload(bucketName: string, file: FileLike, fileId?: string): Promise<string>;
-  download(bucketName: string, fileId: string): Promise<FileLike>;
-  exists(bucketName: string, fileId: string): Promise<boolean>;
-  delete(bucketName: string, fileId: string): Promise<void>;
-  protected createId(): string;
-}
-//#endregion
-//#region src/bucket/descriptors/$bucket.d.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);
- *   }
- * }
- * ```
- */
-declare const $bucket: {
-  (options: BucketDescriptorOptions): BucketDescriptor;
-  [KIND]: typeof BucketDescriptor;
-};
-interface BucketDescriptorOptions extends BucketFileOptions {
-  /**
-   * File storage provider configuration for the bucket.
-   *
-   * Options:
-   * - **"memory"**: In-memory storage (default for development, lost on restart)
-   * - **Service<FileStorageProvider>**: Custom provider class (e.g., S3FileStorageProvider, AzureBlobProvider)
-   * - **undefined**: Uses the default file storage provider from dependency injection
-   *
-   * **Provider Selection Guidelines**:
-   * - **Development**: Use "memory" for fast, simple testing without external dependencies
-   * - **Production**: Use cloud providers (S3, Azure Blob, Google Cloud Storage) for scalability
-   * - **Local deployment**: Use filesystem providers for on-premise installations
-   * - **Hybrid**: Use different providers for different bucket types (temp files vs permanent storage)
-   *
-   * **Provider Capabilities**:
-   * - File persistence and durability guarantees
-   * - Scalability and performance characteristics
-   * - Geographic distribution and CDN integration
-   * - Cost implications for storage and bandwidth
-   * - Backup and disaster recovery features
-   *
-   * @default Uses injected FileStorageProvider
-   * @example "memory"
-   * @example S3FileStorageProvider
-   * @example AzureBlobStorageProvider
-   */
-  provider?: Service<FileStorageProvider> | "memory";
-  /**
-   * Unique name identifier for the bucket.
-   *
-   * This name is used for:
-   * - Storage backend organization and partitioning
-   * - File path generation and URL construction
-   * - Logging, monitoring, and debugging
-   * - Access control and permissions management
-   * - Backup and replication configuration
-   *
-   * **Naming Conventions**:
-   * - Use lowercase with hyphens for consistency
-   * - Include purpose or content type in the name
-   * - Avoid spaces and special characters
-   * - Consider environment prefixes for deployment isolation
-   *
-   * If not provided, defaults to the property key where the bucket is declared.
-   *
-   * @example "user-avatars"
-   * @example "product-images"
-   * @example "legal-documents"
-   * @example "temp-processing-files"
-   */
-  name?: string;
-}
-interface BucketFileOptions {
-  /**
-   * Human-readable description of the bucket's purpose and contents.
-   *
-   * Used for:
-   * - Documentation generation and API references
-   * - Developer onboarding and system understanding
-   * - Monitoring dashboards and admin interfaces
-   * - Compliance and audit documentation
-   *
-   * **Description Best Practices**:
-   * - Explain what types of files this bucket stores
-   * - Mention any special handling or processing requirements
-   * - Include information about retention policies if applicable
-   * - Note any compliance or security considerations
-   *
-   * @example "User profile pictures and avatar images"
-   * @example "Product catalog images with automated thumbnail generation"
-   * @example "Legal documents requiring long-term retention"
-   * @example "Temporary files for data processing workflows"
-   */
-  description?: string;
-  /**
-   * Array of allowed MIME types for files uploaded to this bucket.
-   *
-   * When specified, only files with these exact MIME types will be accepted.
-   * Files with disallowed MIME types will be rejected with an InvalidFileError.
-   *
-   * **MIME Type Categories**:
-   * - Images: "image/jpeg", "image/png", "image/gif", "image/webp", "image/svg+xml"
-   * - Documents: "application/pdf", "text/plain", "text/csv"
-   * - Office: "application/msword", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
-   * - Archives: "application/zip", "application/x-tar", "application/gzip"
-   * - Media: "video/mp4", "audio/mpeg", "audio/wav"
-   *
-   * **Security Considerations**:
-   * - Always validate MIME types for user uploads
-   * - Be cautious with executable file types
-   * - Consider using allow-lists rather than deny-lists
-   * - Remember that MIME types can be spoofed by malicious users
-   *
-   * If not specified, all MIME types are allowed (not recommended for user uploads).
-   *
-   * @example ["image/jpeg", "image/png"] // Only JPEG and PNG images
-   * @example ["application/pdf", "text/plain"] // Documents only
-   * @example ["video/mp4", "video/webm"] // Video files
-   */
-  mimeTypes?: string[];
-  /**
-   * Maximum file size allowed in megabytes (MB).
-   *
-   * Files larger than this limit will be rejected with an InvalidFileError.
-   * This helps prevent:
-   * - Storage quota exhaustion
-   * - Memory issues during file processing
-   * - Long upload times and timeouts
-   * - Abuse of storage resources
-   *
-   * **Size Guidelines by File Type**:
-   * - Profile images: 1-5 MB
-   * - Product photos: 5-10 MB
-   * - Documents: 10-50 MB
-   * - Video files: 50-500 MB
-   * - Data files: 100-1000 MB
-   *
-   * **Considerations**:
-   * - Consider your storage costs and limits
-   * - Factor in network upload speeds for users
-   * - Account for processing requirements (thumbnails, compression)
-   * - Set reasonable limits based on actual use cases
-   *
-   * @default 10 MB
-   *
-   * @example 1    // 1MB for small images
-   * @example 25   // 25MB for documents
-   * @example 100  // 100MB for media files
-   */
-  maxSize?: number;
-}
-declare class BucketDescriptor extends Descriptor<BucketDescriptorOptions> {
-  readonly provider: FileStorageProvider | MemoryFileStorageProvider;
-  private readonly fileSystem;
-  get name(): string;
-  /**
-   * Uploads a file to the bucket.
-   */
-  upload(file: FileLike, options?: BucketFileOptions): Promise<string>;
-  /**
-   * Delete permanently a file from the bucket.
-   */
-  delete(fileId: string, skipHook?: boolean): Promise<void>;
-  /**
-   * Checks if a file exists in the bucket.
-   */
-  exists(fileId: string): Promise<boolean>;
-  /**
-   * Downloads a file from the bucket.
-   */
-  download(fileId: string): Promise<FileLike>;
-  protected $provider(): FileStorageProvider | MemoryFileStorageProvider;
-}
-interface BucketFileOptions {
-  /**
-   * Optional description of the bucket.
-   */
-  description?: string;
-  /**
-   * Allowed MIME types.
-   */
-  mimeTypes?: string[];
-  /**
-   * Maximum size of the files in the bucket.
-   *
-   * @default 10
-   */
-  maxSize?: number;
-}
-//#endregion
-//#region src/bucket/errors/FileNotFoundError.d.ts
-declare class FileNotFoundError extends AlephaError {
-  readonly status = 404;
-}
-//#endregion
-//#region src/bucket/providers/LocalFileStorageProvider.d.ts
-/**
- * Local file storage configuration atom
- */
-declare const localFileStorageOptions: alepha1.Atom<alepha1.TObject<{
-  storagePath: alepha1.TString;
-}>, "alepha.bucket.local.options">;
-type LocalFileStorageProviderOptions = Static<typeof localFileStorageOptions.schema>;
-declare module "alepha" {
-  interface State {
-    [localFileStorageOptions.key]: LocalFileStorageProviderOptions;
-  }
-}
-declare class LocalFileStorageProvider implements FileStorageProvider {
-  protected readonly alepha: Alepha;
-  protected readonly log: alepha_logger0.Logger;
-  protected readonly fileDetector: FileDetector;
-  protected readonly fileSystemProvider: FileSystemProvider;
-  protected readonly options: Readonly<{
-    storagePath: string;
-  }>;
-  protected get storagePath(): string;
-  protected readonly onConfigure: alepha1.HookDescriptor<"configure">;
-  protected readonly onStart: alepha1.HookDescriptor<"start">;
-  upload(bucketName: string, file: FileLike, fileId?: string): Promise<string>;
-  download(bucketName: string, fileId: string): Promise<FileLike>;
-  exists(bucketName: string, fileId: string): Promise<boolean>;
-  delete(bucketName: string, fileId: string): Promise<void>;
-  protected stat(bucket: string, fileId: string): Promise<fs.Stats>;
-  protected createId(mimeType: string): string;
-  protected path(bucket: string, fileId?: string): string;
-  protected isErrorNoEntry(error: unknown): boolean;
-}
-//#endregion
-//#region src/bucket/index.d.ts
-declare module "alepha" {
-  interface Hooks {
-    /**
-     * Triggered when a file is uploaded to a bucket.
-     * Can be used to perform actions after a file is uploaded, like creating a database record!
-     */
-    "bucket:file:uploaded": {
-      id: string;
-      file: FileLike;
-      bucket: BucketDescriptor;
-      options: BucketFileOptions;
-    };
-    /**
-     * Triggered when a file is deleted from a bucket.
-     */
-    "bucket:file:deleted": {
-      id: string;
-      bucket: BucketDescriptor;
-    };
-  }
-}
-/**
- * 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
- */
-declare const AlephaBucket: alepha1.Service<alepha1.Module>;
-//#endregion
-export { $bucket, AlephaBucket, BucketDescriptor, BucketDescriptorOptions, BucketFileOptions, FileNotFoundError, FileStorageProvider, LocalFileStorageProvider, LocalFileStorageProviderOptions, MemoryFileStorageProvider, localFileStorageOptions };
-//# sourceMappingURL=index.d.cts.map

package/dist/cache/index.cjs

@@ -1,241 +0,0 @@
-let alepha = require("alepha");
-let alepha_datetime = require("alepha/datetime");
-let alepha_logger = require("alepha/logger");
-
-//#region src/cache/errors/CacheError.ts
-var CacheError = class extends alepha.AlephaError {};
-
-//#endregion
-//#region src/cache/providers/CacheProvider.ts
-/**
-* Cache provider interface.
-*
-* All methods are asynchronous and return promises.
-* Values are stored as Uint8Array.
-*/
-var CacheProvider = class {};
-
-//#endregion
-//#region src/cache/providers/MemoryCacheProvider.ts
-var MemoryCacheProvider = class {
-	dateTimeProvider = (0, alepha.$inject)(alepha_datetime.DateTimeProvider);
-	log = (0, alepha_logger.$logger)();
-	store = {};
-	async get(name, key) {
-		return this.store[name]?.[key]?.data;
-	}
-	async set(name, key, value, ttl) {
-		if (this.store[name] == null) this.store[name] = {};
-		this.store[name][key] ??= {};
-		this.store[name][key].data = value;
-		this.log.debug(`Setting cache for name`, {
-			name,
-			key,
-			ttl
-		});
-		if (this.store[name][key].timeout) {
-			this.dateTimeProvider.clearTimeout(this.store[name][key].timeout);
-			this.store[name][key].timeout = void 0;
-		}
-		if (ttl) this.store[name][key].timeout = this.dateTimeProvider.createTimeout(() => this.del(name, key), ttl);
-		return this.store[name][key].data;
-	}
-	async del(name, ...keys) {
-		if (keys.length === 0) {
-			this.log.debug(`Deleting all cache for name`, { name });
-			if (this.store[name]) for (const key of Object.keys(this.store[name])) {
-				const timeout = this.store[name][key]?.timeout;
-				if (timeout) this.dateTimeProvider.clearTimeout(timeout);
-			}
-			delete this.store[name];
-			return;
-		}
-		this.log.debug(`Deleting cache for name`, {
-			name,
-			keys
-		});
-		for (const key of keys) {
-			if (this.store[name] == null) break;
-			const timeout = this.store[name][key]?.timeout;
-			if (timeout) this.dateTimeProvider.clearTimeout(timeout);
-			delete this.store[name][key];
-		}
-		if (Object.keys(this.store[name] ?? {}).length === 0) delete this.store[name];
-	}
-	async has(name, key) {
-		return this.store[name]?.[key]?.data != null;
-	}
-	async keys(name, filter) {
-		const store = this.store[name] ?? {};
-		const keys = Object.keys(store);
-		if (filter) return keys.filter((key) => key.startsWith(filter));
-		return keys;
-	}
-	async clear() {
-		this.log.debug("Clearing all cache");
-		for (const name of Object.keys(this.store)) for (const key of Object.keys(this.store[name])) {
-			const timeout = this.store[name][key]?.timeout;
-			if (timeout) this.dateTimeProvider.clearTimeout(timeout);
-		}
-		this.store = {};
-	}
-};
-
-//#endregion
-//#region src/cache/descriptors/$cache.ts
-/**
-* Creates a cache descriptor for high-performance data caching with automatic management.
-*
-* Provides a caching layer that improves application performance by storing frequently accessed
-* data in memory or external stores like Redis, with support for both function result caching
-* and manual cache operations.
-*
-* **Key Features**
-* - Automatic function result caching based on input parameters
-* - Multiple storage backends (in-memory, Redis, custom providers)
-* - Intelligent serialization for JSON, strings, and binary data
-* - Configurable TTL with automatic expiration
-* - Pattern-based cache invalidation with wildcard support
-* - Environment controls to enable/disable caching
-*
-* **Storage Backends**
-* - Memory: Fast in-memory cache (default for development)
-* - Redis: Distributed cache for production environments
-* - Custom providers: Implement your own storage backend
-*
-* @example
-* ```ts
-* class DataService {
-*   // Function result caching
-*   getUserData = $cache({
-*     name: "user-data",
-*     ttl: [10, "minutes"],
-*     handler: async (userId: string) => {
-*       return await database.users.findById(userId);
-*     }
-*   });
-*
-*   // Manual cache operations
-*   sessionCache = $cache<UserSession>({
-*     name: "sessions",
-*     ttl: [1, "hour"]
-*   });
-*
-*   async storeSession(id: string, session: UserSession) {
-*     await this.sessionCache.set(id, session);
-*   }
-*
-*   async invalidateUserSessions(userId: string) {
-*     await this.sessionCache.invalidate(`user:${userId}:*`);
-*   }
-* }
-* ```
-*/
-const $cache = (options = {}) => {
-	const instance = (0, alepha.createDescriptor)(CacheDescriptor, options);
-	const fn = (...args) => instance.run(...args);
-	return Object.setPrototypeOf(fn, instance);
-};
-const envSchema = alepha.t.object({
-	CACHE_ENABLED: alepha.t.boolean({ default: true }),
-	CACHE_DEFAULT_TTL: alepha.t.number({
-		default: 300,
-		description: "The default time to live for cache entries. In seconds."
-	})
-});
-var CacheDescriptor = class extends alepha.Descriptor {
-	env = (0, alepha.$env)(envSchema);
-	dateTimeProvider = (0, alepha.$inject)(alepha_datetime.DateTimeProvider);
-	provider = this.$provider();
-	encoder = new TextEncoder();
-	decoder = new TextDecoder();
-	codes = {
-		BINARY: 1,
-		JSON: 2,
-		STRING: 3
-	};
-	get container() {
-		return this.options.name ?? `${this.config.service.name}:${this.config.propertyKey}`;
-	}
-	async run(...args) {
-		const handler = this.options.handler;
-		if (!handler) throw new Error("Cache handler is not defined.");
-		const key = this.key(...args);
-		const cached = await this.get(key);
-		if (cached) return cached;
-		const result = await handler(...args);
-		await this.set(key, result);
-		return result;
-	}
-	key(...args) {
-		return this.options.key ? this.options.key(...args) : JSON.stringify(args);
-	}
-	async invalidate(...keys) {
-		const keysToDelete = [];
-		for (const key of keys) if (key.endsWith("*")) {
-			const result = await this.provider.keys(this.container, key.slice(0, -1));
-			keysToDelete.push(...result);
-		} else keysToDelete.push(key);
-		await this.provider.del(this.container, ...keysToDelete);
-	}
-	async set(key, value, ttl) {
-		const px = this.dateTimeProvider.duration(ttl ?? this.options.ttl ?? [this.env.CACHE_DEFAULT_TTL, "seconds"]).as("milliseconds");
-		await this.provider.set(this.container, key, this.serialize(value), px > 0 ? px : void 0);
-	}
-	async get(key) {
-		if (!this.alepha.isStarted() || this.options.disabled || !this.env.CACHE_ENABLED) return;
-		const data = await this.provider.get(this.container, key);
-		if (data) return await this.deserialize(data);
-	}
-	serialize(value) {
-		if (value instanceof Uint8Array) return new Uint8Array([this.codes.BINARY, ...value]);
-		if (typeof value === "string") return new Uint8Array([this.codes.STRING, ...this.encoder.encode(value)]);
-		return new Uint8Array([this.codes.JSON, ...this.encoder.encode(JSON.stringify(value))]);
-	}
-	async deserialize(uint8Array) {
-		const type = uint8Array[0];
-		const payload = uint8Array.slice(1);
-		if (type === this.codes.BINARY) return payload;
-		if (type === this.codes.JSON) return JSON.parse(this.decoder.decode(payload));
-		if (type === this.codes.STRING) return this.decoder.decode(payload);
-		throw new CacheError(`Unknown serialization type: ${type}`);
-	}
-	$provider() {
-		if (!this.options.provider) return this.alepha.inject(CacheProvider);
-		if (this.options.provider === "memory") return this.alepha.inject(MemoryCacheProvider);
-		return this.alepha.inject(this.options.provider);
-	}
-};
-$cache[alepha.KIND] = CacheDescriptor;
-
-//#endregion
-//#region src/cache/index.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.
-*
-* @see {@link $cache}
-* @see {@link CacheProvider}
-* @module alepha.cache
-*/
-const AlephaCache = (0, alepha.$module)({
-	name: "alepha.cache",
-	descriptors: [$cache],
-	services: [CacheProvider, MemoryCacheProvider],
-	register: (alepha$1) => alepha$1.with({
-		optional: true,
-		provide: CacheProvider,
-		use: MemoryCacheProvider
-	})
-});
-
-//#endregion
-exports.$cache = $cache;
-exports.AlephaCache = AlephaCache;
-exports.CacheDescriptor = CacheDescriptor;
-exports.CacheProvider = CacheProvider;
-exports.MemoryCacheProvider = MemoryCacheProvider;
-//# sourceMappingURL=index.cjs.map