@breadstone/archipel-mcp 0.0.46 → 0.0.47

package/data/guides/composition-context.md

@@ -0,0 +1,462 @@
+---
+title: Composition Context
+description: Stage-aware, configuration-driven module composition for NestJS applications without direct process.env access.
+order: 4
+---
+
+# Composition Context
+
+The composition context pattern enables **stage-aware infrastructure module selection** at application startup. Rather than hard-coding provider imports or scattering `process.env` checks throughout your codebase, composition provides a clean abstraction that reads configuration once and determines which modules to import.
+
+This is particularly valuable for:
+
+- **Multi-stage deployments** — Use mock mail in development, real SMTP in production
+- **Feature flags** — Toggle entire modules based on configuration
+- **Provider switching** — Swap payment providers or blob storage backends per environment
+- **Clean architecture** — Keep `main.ts` free of conditional logic
+
+---
+
+## Installation
+
+The composition subpath is part of `platform-bootstrap`:
+
+```bash
+yarn add @breadstone/archipel-platform-bootstrap @breadstone/archipel-platform-configuration
+```
+
+---
+
+## Core Concepts
+
+### Composition Context
+
+The `ICompositionContext` provides typed access to configuration during module assembly:
+
+```typescript
+interface ICompositionContext {
+  readonly context: INestApplicationContext;
+  readonly config: ConfigService;
+
+  getConfigValue<T>(key: IConfigKey<T>): T;
+  tryGetConfigValue<T>(key: IConfigKey<T>, fallback: T): T;
+  getService<T>(token: Type<T>): T;
+  close(): Promise<void>;
+}
+```
+
+### Composition Resolver
+
+Abstract base class for encapsulating composition decisions:
+
+```typescript
+abstract class CompositionResolver {
+  abstract shouldImportProvider(providerKey: string): boolean;
+
+  protected getConfigValue<T>(key: IConfigKey<T>): T;
+  protected tryGetConfigValue<T>(key: IConfigKey<T>, fallback: T): T;
+  protected compareConfigValue<T>(key: IConfigKey<T>, expected: T): boolean;
+}
+```
+
+### Composition Import
+
+Type alias for valid NestJS module imports:
+
+```typescript
+type CompositionImport = Type<unknown> | DynamicModule | Promise<DynamicModule> | ForwardReference<unknown>;
+```
+
+---
+
+## Basic Usage
+
+### Direct Factory Approach
+
+For simple cases, use `createCompositionContext()` directly:
+
+```typescript
+import { NestFactory } from '@nestjs/core';
+import { createCompositionContext } from '@breadstone/archipel-platform-bootstrap/composition';
+import { AppModule } from './AppModule';
+
+async function main(): Promise<void> {
+  const context = await createCompositionContext();
+
+  try {
+    const driver = context.tryGetConfigValue({ key: 'MAIL_DRIVER' }, 'log');
+
+    if (driver === 'smtp') {
+      // Dynamic import only when needed
+      const { MailModule } = await import('@breadstone/archipel-platform-mailing');
+      const { SmtpDeliveryStrategy } = await import('@breadstone/archipel-platform-mailing/delivering/smtp');
+
+      console.log('Using SMTP mail delivery');
+    }
+  } finally {
+    await context.close();
+  }
+
+  // Continue with normal NestJS bootstrap
+  const app = await NestFactory.create(AppModule);
+  await app.listen(3000);
+}
+```
+
+### Builder Integration
+
+For full integration with `PlatformApplicationBuilder`:
+
+```typescript
+import { PlatformApplicationBuilder, useApi, CompositionImport } from '@breadstone/archipel-platform-bootstrap';
+import { ExpressAdapter, NestExpressApplication } from '@nestjs/platform-express';
+import { NestFactory } from '@nestjs/core';
+import { AppModule } from './AppModule';
+
+async function main(): Promise<void> {
+  const builder = await PlatformApplicationBuilder.createWithComposition<NestExpressApplication>(
+    async (context) => {
+      const imports: CompositionImport[] = [AppModule];
+
+      // Stage-aware mail provider selection
+      const driver = context.tryGetConfigValue({ key: 'MAIL_DRIVER' }, 'log');
+      const stage = context.tryGetConfigValue({ key: 'NODE_ENV' }, 'development');
+
+      if (driver === 'smtp' || stage === 'production') {
+        const { MailModule } = await import('@breadstone/archipel-platform-mailing');
+        const { SmtpDeliveryStrategy } = await import('@breadstone/archipel-platform-mailing/delivering/smtp');
+        imports.push(MailModule.register({ deliveryStrategy: SmtpDeliveryStrategy }));
+      } else {
+        const { MailModule } = await import('@breadstone/archipel-platform-mailing');
+        const { LogDeliveryStrategy } = await import('@breadstone/archipel-platform-mailing/delivering/log');
+        imports.push(MailModule.register({ deliveryStrategy: LogDeliveryStrategy }));
+      }
+
+      return imports;
+    },
+    {
+      appFactory: (module) => NestFactory.create<NestExpressApplication>(module, new ExpressAdapter()),
+    }
+  );
+
+  await builder
+    .use(useApi({ prefix: 'api' }))
+    .listenFromConfig({ fallbackPort: 3000 });
+}
+
+void main();
+```
+
+---
+
+## Custom Composition Resolver
+
+For complex applications, encapsulate composition logic in a dedicated resolver class:
+
+### 1. Define the Resolver
+
+```typescript
+// src/composition/AppCompositionResolver.ts
+import { Injectable } from '@nestjs/common';
+import { ConfigService, createConfigKey } from '@breadstone/archipel-platform-configuration';
+import { CompositionResolver } from '@breadstone/archipel-platform-bootstrap/composition';
+
+const MAIL_DRIVER = createConfigKey<string>('MAIL_DRIVER');
+const NODE_ENV = createConfigKey<string>('NODE_ENV');
+const FEATURE_NEW_PAYMENTS = createConfigKey<string>('FEATURE_NEW_PAYMENTS');
+
+@Injectable()
+export class AppCompositionResolver extends CompositionResolver {
+  public constructor(configService: ConfigService) {
+    super(configService);
+  }
+
+  public shouldImportProvider(providerKey: string): boolean {
+    switch (providerKey) {
+      case 'smtp-mail':
+        return this.shouldUseSmtpMail();
+      case 'log-mail':
+        return !this.shouldUseSmtpMail();
+      case 'stripe-payments':
+        return this.shouldUseStripePayments();
+      case 'paddle-payments':
+        return !this.shouldUseStripePayments();
+      default:
+        return false;
+    }
+  }
+
+  public shouldUseSmtpMail(): boolean {
+    const driver = this.tryGetConfigValue(MAIL_DRIVER, 'log');
+    return driver === 'smtp' || this.isProductionLike();
+  }
+
+  public shouldUseStripePayments(): boolean {
+    const feature = this.tryGetConfigValue(FEATURE_NEW_PAYMENTS, 'disabled');
+    return feature !== 'paddle';
+  }
+
+  public isProductionLike(): boolean {
+    const stage = this.tryGetConfigValue(NODE_ENV, 'development');
+    return stage === 'production' || stage === 'staging';
+  }
+}
+```
+
+### 2. Create a Composition Module
+
+```typescript
+// src/composition/AppCompositionModule.ts
+import { Module } from '@nestjs/common';
+import { ConfigModule, EnvironmentConfigStrategy } from '@breadstone/archipel-platform-configuration';
+import { AppCompositionResolver } from './AppCompositionResolver';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot({
+      strategyFactory: () => new EnvironmentConfigStrategy(),
+    }),
+  ],
+  providers: [AppCompositionResolver],
+  exports: [ConfigModule, AppCompositionResolver],
+})
+export class AppCompositionModule {}
+```
+
+### 3. Use in Bootstrap
+
+```typescript
+// src/main.ts
+import { PlatformApplicationBuilder, CompositionImport } from '@breadstone/archipel-platform-bootstrap';
+import { AppCompositionModule, AppCompositionResolver } from './composition';
+import { AppModule } from './AppModule';
+
+async function main(): Promise<void> {
+  const builder = await PlatformApplicationBuilder.createWithComposition(
+    async (context) => {
+      const resolver = context.getService(AppCompositionResolver);
+      const imports: CompositionImport[] = [AppModule];
+
+      // Mail provider
+      if (resolver.shouldImportProvider('smtp-mail')) {
+        const { MailModule } = await import('@breadstone/archipel-platform-mailing');
+        const { SmtpDeliveryStrategy } = await import('@breadstone/archipel-platform-mailing/delivering/smtp');
+        imports.push(MailModule.register({ deliveryStrategy: SmtpDeliveryStrategy }));
+      } else {
+        const { MailModule } = await import('@breadstone/archipel-platform-mailing');
+        const { LogDeliveryStrategy } = await import('@breadstone/archipel-platform-mailing/delivering/log');
+        imports.push(MailModule.register({ deliveryStrategy: LogDeliveryStrategy }));
+      }
+
+      // Payment provider
+      if (resolver.shouldImportProvider('stripe-payments')) {
+        const { PaymentModule } = await import('@breadstone/archipel-platform-payments');
+        const { StripeClient } = await import('@breadstone/archipel-platform-payments/stripe');
+        imports.push(PaymentModule.register({ paymentClient: StripeClient }));
+      } else if (resolver.shouldImportProvider('paddle-payments')) {
+        const { PaymentModule } = await import('@breadstone/archipel-platform-payments');
+        const { PaddleClient } = await import('@breadstone/archipel-platform-payments/paddle');
+        imports.push(PaymentModule.register({ paymentClient: PaddleClient }));
+      }
+
+      return imports;
+    },
+    {
+      compositionModule: AppCompositionModule,
+    }
+  );
+
+  await builder.listenFromConfig({ fallbackPort: 3000 });
+}
+```
+
+---
+
+## Provider Composer Pattern
+
+For reusable provider composition, define composer functions:
+
+```typescript
+// src/composition/composers/composeMailProvider.ts
+import type { ICompositionContext } from '@breadstone/archipel-platform-bootstrap/composition';
+import type { CompositionImport } from '@breadstone/archipel-platform-bootstrap';
+import { AppCompositionResolver } from '../AppCompositionResolver';
+
+export async function composeMailProvider(context: ICompositionContext): Promise<CompositionImport | null> {
+  const resolver = context.getService(AppCompositionResolver);
+
+  if (resolver.shouldImportProvider('smtp-mail')) {
+    const { MailModule } = await import('@breadstone/archipel-platform-mailing');
+    const { SmtpDeliveryStrategy } = await import('@breadstone/archipel-platform-mailing/delivering/smtp');
+    return MailModule.register({ deliveryStrategy: SmtpDeliveryStrategy });
+  }
+
+  if (resolver.shouldImportProvider('log-mail')) {
+    const { MailModule } = await import('@breadstone/archipel-platform-mailing');
+    const { LogDeliveryStrategy } = await import('@breadstone/archipel-platform-mailing/delivering/log');
+    return MailModule.register({ deliveryStrategy: LogDeliveryStrategy });
+  }
+
+  return null;
+}
+```
+
+Then compose cleanly in main:
+
+```typescript
+const builder = await PlatformApplicationBuilder.createWithComposition(
+  async (context) => {
+    const imports: CompositionImport[] = [AppModule];
+
+    const mailModule = await composeMailProvider(context);
+    if (mailModule) imports.push(mailModule);
+
+    const paymentModule = await composePaymentProvider(context);
+    if (paymentModule) imports.push(paymentModule);
+
+    return imports;
+  },
+  { compositionModule: AppCompositionModule }
+);
+```
+
+---
+
+## Testing Composition
+
+### Unit Testing a Resolver
+
+```typescript
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { ConfigService } from '@breadstone/archipel-platform-configuration';
+import { AppCompositionResolver } from './AppCompositionResolver';
+
+describe('AppCompositionResolver', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('uses SMTP in production regardless of driver setting', () => {
+    const configService = {
+      get: vi.fn((key: string) => {
+        if (key === 'MAIL_DRIVER') return 'log';
+        if (key === 'NODE_ENV') return 'production';
+        return undefined;
+      }),
+      tryGet: vi.fn((key: string, fallback: string) => {
+        if (key === 'MAIL_DRIVER') return 'log';
+        if (key === 'NODE_ENV') return 'production';
+        return fallback;
+      }),
+    } as unknown as ConfigService;
+
+    const resolver = new AppCompositionResolver(configService);
+
+    expect(resolver.shouldImportProvider('smtp-mail')).toBe(true);
+    expect(resolver.shouldImportProvider('log-mail')).toBe(false);
+  });
+});
+```
+
+### Integration Testing with Real Context
+
+```typescript
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { createCompositionContext } from '@breadstone/archipel-platform-bootstrap/composition';
+import { AppCompositionModule, AppCompositionResolver } from './composition';
+
+describe('Composition Integration', () => {
+  let originalEnv: Record<string, string | undefined>;
+
+  beforeEach(() => {
+    originalEnv = {
+      MAIL_DRIVER: process.env['MAIL_DRIVER'],
+      NODE_ENV: process.env['NODE_ENV'],
+    };
+  });
+
+  afterEach(() => {
+    for (const [key, value] of Object.entries(originalEnv)) {
+      if (value === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  });
+
+  it('resolves correct mail provider for production', async () => {
+    process.env['NODE_ENV'] = 'production';
+    process.env['MAIL_DRIVER'] = 'log';
+
+    const context = await createCompositionContext({
+      module: AppCompositionModule,
+    });
+
+    try {
+      const resolver = context.getService(AppCompositionResolver);
+      expect(resolver.shouldImportProvider('smtp-mail')).toBe(true);
+    } finally {
+      await context.close();
+    }
+  });
+});
+```
+
+---
+
+## API Reference
+
+### createCompositionContext
+
+```typescript
+function createCompositionContext(
+  options?: ICreateCompositionContextOptions
+): Promise<ICompositionContext>;
+```
+
+| Option | Type | Default | Description |
+| ------ | ---- | ------- | ----------- |
+| `module` | `Type<unknown>` | `CompositionModule` | Custom composition module |
+| `enableLogging` | `boolean` | `false` | Enable NestJS logger output |
+
+### PlatformApplicationBuilder.createWithComposition
+
+```typescript
+static async createWithComposition<TApp extends INestApplication>(
+  composer: (context: ICompositionContext) => Promise<CompositionImport[]> | CompositionImport[],
+  options?: ICreateWithCompositionOptions<TApp>
+): Promise<PlatformApplicationBuilder<TApp>>;
+```
+
+| Option | Type | Default | Description |
+| ------ | ---- | ------- | ----------- |
+| `compositionModule` | `Type<unknown>` | `CompositionModule` | Custom composition module |
+| `enableCompositionLogging` | `boolean` | `false` | Enable logging during composition |
+| `nestOptions` | `NestApplicationOptions` | `undefined` | Options for `NestFactory.create()` |
+| `platformOptions` | `IPlatformApplicationOptions` | `undefined` | Options for the builder |
+| `appFactory` | `(module: DynamicModule) => Promise<TApp>` | `undefined` | Custom app factory |
+
+---
+
+## Best Practices
+
+1. **Keep composition modules minimal** — Only configuration and resolver services. No database, queues, or heavy infrastructure.
+
+2. **Use dynamic imports** — Import provider modules only when needed to reduce bundle size and startup time.
+
+3. **Encapsulate decisions in resolvers** — Don't scatter `process.env` checks. Centralize in a `CompositionResolver`.
+
+4. **Test resolvers in isolation** — Unit test the decision logic separately from NestJS bootstrap.
+
+5. **Close the context** — Always call `context.close()` when using `createCompositionContext()` directly.
+
+6. **Prefer `tryGetConfigValue` over `getConfigValue`** — Provide sensible defaults for optional configuration.
+
+---
+
+## See Also
+
+- [Application Bootstrap](./application-bootstrap) — Standard bootstrap pipeline without composition
+- [Configuration Management](./configuration) — Typed configuration keys and strategies
+- [Implementing Ports](./implementing-ports) — Port/adapter pattern for swappable implementations

package/data/guides/index.md

@@ -14,6 +14,7 @@ Practical guides for working with Archipel packages in your NestJS application.
 | [Getting Started](./getting-started)                      | Install packages, register your first module, implement ports, and run the app.                               |
 | [Configuration Management](./configuration)               | Type-safe config keys, strategy-based resolution, central registry, and validation.                           |
 | [Application Bootstrap](./application-bootstrap)           | Compose NestJS startup with platform-bootstrap, Express middleware, security, sessions, and OpenAPI.          |
+| [Composition Context](./composition-context)              | Stage-aware, configuration-driven module composition without direct process.env access.                       |
 | [Implementing Ports](./implementing-ports)                | How the port/adapter pattern works, how to write adapters, and how to test them.                              |
 | [Controller Best Practices](./controller-best-practices)  | Structure, annotate, and implement controllers — regions, DI, ResponseReturn, guards, and the @Api decorator. |
 | [Request & Response DTOs](./request-response-dtos)        | DTO naming conventions, validation decorators, cross-field validation, and class-transformer integration.     |

package/data/packages/platform-blob-storage/api/Class.BlobStorageStrategyBase.md

@@ -16,6 +16,7 @@ Serves as both the type contract and the NestJS DI token type reference.
 - [`VercelBlobStorageStrategy`](Class.VercelBlobStorageStrategy)
 - [`AzureBlobStorageStrategy`](Class.AzureBlobStorageStrategy)
 - [`AwsS3BlobStorageStrategy`](Class.AwsS3BlobStorageStrategy)
+- [`EmptyBlobStorageStrategy`](Class.EmptyBlobStorageStrategy)
 - [`LocalBlobStorageStrategy`](Class.LocalBlobStorageStrategy)
 
 ## Constructors

package/data/packages/platform-blob-storage/api/Class.EmptyBlobStorageStrategy.md

@@ -0,0 +1,183 @@
+---
+title: 'Class: EmptyBlobStorageStrategy'
+generated: true
+editUrl: false
+---
+# Class: EmptyBlobStorageStrategy
+
+Defined in: strategies/empty/EmptyBlobStorageStrategy.ts:15
+
+Provides a blob storage strategy backed by the local filesystem.
+
+## Extends
+
+- [`BlobStorageStrategyBase`](Class.BlobStorageStrategyBase)
+
+## Constructors
+
+### Constructor
+
+```ts
+new EmptyBlobStorageStrategy(): EmptyBlobStorageStrategy;
+```
+
+Defined in: strategies/empty/EmptyBlobStorageStrategy.ts:29
+
+Constructs a new instance of the `EmptyBlobStorageStrategy` class.
+
+#### Returns
+
+`EmptyBlobStorageStrategy`
+
+#### Overrides
+
+[`BlobStorageStrategyBase`](Class.BlobStorageStrategyBase).[`constructor`](Class.BlobStorageStrategyBase#constructor)
+
+## Properties
+
+### defaultBucket?
+
+```ts
+optional defaultBucket?: string = undefined;
+```
+
+Defined in: strategies/empty/EmptyBlobStorageStrategy.ts:39
+
+Gets the default bucket (container/directory) configured for the provider.
+
+#### Overrides
+
+[`BlobStorageStrategyBase`](Class.BlobStorageStrategyBase).[`defaultBucket`](Class.BlobStorageStrategyBase#defaultbucket)
+
+***
+
+### providerId
+
+```ts
+readonly providerId: string = 'empty';
+```
+
+Defined in: strategies/empty/EmptyBlobStorageStrategy.ts:37
+
+Gets the unique identifier for this storage provider.
+
+#### Overrides
+
+[`BlobStorageStrategyBase`](Class.BlobStorageStrategyBase).[`providerId`](Class.BlobStorageStrategyBase#providerid)
+
+## Methods
+
+### createSignedUrl()?
+
+```ts
+optional createSignedUrl(request): Promise<string>;
+```
+
+Defined in: [strategies/abstracts/BlobStorageStrategyBase.ts:79](https://github.com/RueDeRennes/archipel/blob/main/libs/platform-blob-storage/src/strategies/abstracts/BlobStorageStrategyBase.ts#L79)
+
+Creates a signed URL for the specified blob object.
+Not all providers support this operation.
+
+#### Parameters
+
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `request` | [`IBlobSignedUrlRequest`](Interface.IBlobSignedUrlRequest) | The request describing the object to link. |
+
+#### Returns
+
+`Promise`\<`string`\>
+
+The generated signed URL.
+
+#### Inherited from
+
+[`BlobStorageStrategyBase`](Class.BlobStorageStrategyBase).[`createSignedUrl`](Class.BlobStorageStrategyBase#createsignedurl)
+
+***
+
+### deleteObject()
+
+```ts
+deleteObject(request): Promise<void>;
+```
+
+Defined in: strategies/empty/EmptyBlobStorageStrategy.ts:93
+
+Deletes a blob object from the storage backend.
+
+#### Parameters
+
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `request` | [`IBlobDeleteRequest`](Interface.IBlobDeleteRequest) | The delete request describing the object to remove. |
+
+#### Returns
+
+`Promise`\<`void`\>
+
+#### Overrides
+
+[`BlobStorageStrategyBase`](Class.BlobStorageStrategyBase).[`deleteObject`](Class.BlobStorageStrategyBase#deleteobject)
+
+***
+
+### downloadObject()
+
+```ts
+downloadObject<TData>(request): Promise<IBlobDownloadResult<TData>>;
+```
+
+Defined in: strategies/empty/EmptyBlobStorageStrategy.ts:75
+
+Downloads a blob object from the storage backend.
+
+#### Type Parameters
+
+| Type Parameter |
+| ------ |
+| `TData` |
+
+#### Parameters
+
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `request` | [`IBlobDownloadRequest`](Interface.IBlobDownloadRequest) | The download request describing the object to download. |
+
+#### Returns
+
+`Promise`\<[`IBlobDownloadResult`](Interface.IBlobDownloadResult)\<`TData`\>\>
+
+The download result including payload and metadata.
+
+#### Overrides
+
+[`BlobStorageStrategyBase`](Class.BlobStorageStrategyBase).[`downloadObject`](Class.BlobStorageStrategyBase#downloadobject)
+
+***
+
+### uploadObject()
+
+```ts
+uploadObject(request): Promise<IBlobUploadResult>;
+```
+
+Defined in: strategies/empty/EmptyBlobStorageStrategy.ts:45
+
+Uploads a blob object to the storage backend.
+
+#### Parameters
+
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `request` | [`IBlobUploadRequest`](Interface.IBlobUploadRequest) | The upload request describing the object to upload. |
+
+#### Returns
+
+`Promise`\<[`IBlobUploadResult`](Interface.IBlobUploadResult)\>
+
+The resulting upload metadata.
+
+#### Overrides
+
+[`BlobStorageStrategyBase`](Class.BlobStorageStrategyBase).[`uploadObject`](Class.BlobStorageStrategyBase#uploadobject)

package/data/packages/platform-blob-storage/api/Variable.AWS_S3_ACCESS_KEY_ID.md

@@ -9,6 +9,6 @@ editUrl: false
 const AWS_S3_ACCESS_KEY_ID: IConfigKey<string>;
 ```
 
-Defined in: [strategies/aws-s3/env.ts:16](https://github.com/RueDeRennes/archipel/blob/main/libs/platform-blob-storage/src/strategies/aws-s3/env.ts#L16)
+Defined in: [strategies/aws-s3/env.ts:26](https://github.com/RueDeRennes/archipel/blob/main/libs/platform-blob-storage/src/strategies/aws-s3/env.ts#L26)
 
 AWS S3 access key ID.

package/data/packages/platform-blob-storage/api/Variable.AWS_S3_BUCKET.md

@@ -9,6 +9,6 @@ editUrl: false
 const AWS_S3_BUCKET: IConfigKey<string>;
 ```
 
-Defined in: [strategies/aws-s3/env.ts:13](https://github.com/RueDeRennes/archipel/blob/main/libs/platform-blob-storage/src/strategies/aws-s3/env.ts#L13)
+Defined in: [strategies/aws-s3/env.ts:19](https://github.com/RueDeRennes/archipel/blob/main/libs/platform-blob-storage/src/strategies/aws-s3/env.ts#L19)
 
 AWS S3 bucket name.

package/data/packages/platform-blob-storage/api/Variable.AWS_S3_CONFIG_ENTRIES.md

@@ -9,6 +9,6 @@ editUrl: false
 const AWS_S3_CONFIG_ENTRIES: ReadonlyArray<Omit<IConfigRegistryEntry, "module">>;
 ```
 
-Defined in: [strategies/aws-s3/env.ts:25](https://github.com/RueDeRennes/archipel/blob/main/libs/platform-blob-storage/src/strategies/aws-s3/env.ts#L25)
+Defined in: [strategies/aws-s3/env.ts:47](https://github.com/RueDeRennes/archipel/blob/main/libs/platform-blob-storage/src/strategies/aws-s3/env.ts#L47)
 
 Configuration entries required by the AWS S3 blob storage strategy.

package/data/packages/platform-blob-storage/api/Variable.AWS_S3_ENDPOINT.md

@@ -9,6 +9,6 @@ editUrl: false
 const AWS_S3_ENDPOINT: IConfigKey<string>;
 ```
 
-Defined in: [strategies/aws-s3/env.ts:22](https://github.com/RueDeRennes/archipel/blob/main/libs/platform-blob-storage/src/strategies/aws-s3/env.ts#L22)
+Defined in: [strategies/aws-s3/env.ts:40](https://github.com/RueDeRennes/archipel/blob/main/libs/platform-blob-storage/src/strategies/aws-s3/env.ts#L40)
 
 AWS S3 custom endpoint (for S3-compatible providers).