apps/backend/src/application/auth/auth.service.ts

@@ -311,12 +311,12 @@ export class AuthService {
    * Generate access and refresh tokens
    */
   private async generateTokens(user: User): Promise<{ accessToken: string; refreshToken: string }> {
-    // ADMIN users always get ENTERPRISE plan with no expiration
+    // ADMIN users always get PLATINIUM plan with no expiration
-    let plan = 'FREE';
+    let plan = 'BRONZE';
     let planFeatures: string[] = [];
 
     if (user.role === UserRole.ADMIN) {
-      plan = 'ENTERPRISE';
+      plan = 'PLATINIUM';
       planFeatures = [
         'dashboard',
         'wiki',

apps/backend/src/application/dto/subscription.dto.ts

@@ -11,10 +11,10 @@ import { IsString, IsEnum, IsUrl, IsOptional } from 'class-validator';
  * Subscription plan types
  */
 export enum SubscriptionPlanDto {
-  FREE = 'FREE',
+  BRONZE = 'BRONZE',
-  STARTER = 'STARTER',
+  SILVER = 'SILVER',
-  PRO = 'PRO',
+  GOLD = 'GOLD',
-  ENTERPRISE = 'ENTERPRISE',
+  PLATINIUM = 'PLATINIUM',
 }
 
 /**
@@ -44,7 +44,7 @@ export enum BillingIntervalDto {
  */
 export class CreateCheckoutSessionDto {
   @ApiProperty({
-    example: SubscriptionPlanDto.STARTER,
+    example: SubscriptionPlanDto.SILVER,
     description: 'The subscription plan to purchase',
     enum: SubscriptionPlanDto,
   })
@@ -188,7 +188,7 @@ export class LicenseResponseDto {
  */
 export class PlanDetailsDto {
   @ApiProperty({
-    example: SubscriptionPlanDto.STARTER,
+    example: SubscriptionPlanDto.SILVER,
     description: 'Plan identifier',
     enum: SubscriptionPlanDto,
   })
@@ -274,7 +274,7 @@ export class SubscriptionResponseDto {
   organizationId: string;
 
   @ApiProperty({
-    example: SubscriptionPlanDto.STARTER,
+    example: SubscriptionPlanDto.SILVER,
     description: 'Current subscription plan',
     enum: SubscriptionPlanDto,
   })

apps/backend/src/application/services/subscription.service.ts

@@ -182,8 +182,8 @@ export class SubscriptionService {
     }
 
     // Cannot checkout for FREE plan
-    if (dto.plan === SubscriptionPlanDto.FREE) {
+    if (dto.plan === SubscriptionPlanDto.BRONZE) {
-      throw new BadRequestException('Cannot create checkout session for Free plan');
+      throw new BadRequestException('Cannot create checkout session for Bronze plan');
     }
 
     const subscription = await this.getOrCreateSubscription(organizationId);

apps/backend/src/domain/value-objects/plan-feature.vo.ts

@@ -24,13 +24,13 @@ export const ALL_PLAN_FEATURES: readonly PlanFeature[] = [
   'dedicated_kam',
 ];
 
-export type SubscriptionPlanTypeForFeatures = 'FREE' | 'STARTER' | 'PRO' | 'ENTERPRISE';
+export type SubscriptionPlanTypeForFeatures = 'BRONZE' | 'SILVER' | 'GOLD' | 'PLATINIUM';
 
 export const PLAN_FEATURES: Record<SubscriptionPlanTypeForFeatures, readonly PlanFeature[]> = {
-  FREE: [],
+  BRONZE: [],
-  STARTER: ['dashboard', 'wiki', 'user_management', 'csv_export'],
+  SILVER: ['dashboard', 'wiki', 'user_management', 'csv_export'],
-  PRO: ['dashboard', 'wiki', 'user_management', 'csv_export', 'api_access'],
+  GOLD: ['dashboard', 'wiki', 'user_management', 'csv_export', 'api_access'],
-  ENTERPRISE: [
+  PLATINIUM: [
     'dashboard',
     'wiki',
     'user_management',

apps/backend/src/domain/value-objects/subscription-plan.vo.ts

@@ -5,25 +5,24 @@
  * Each plan has a maximum number of licenses, shipment limits, commission rates,
  * feature flags, and support levels.
  *
- * Plans: FREE (0EUR/mo), STARTER (49EUR/mo), PRO (249EUR/mo), ENTERPRISE (custom)
+ * Plans: BRONZE (free), SILVER (249EUR/mo), GOLD (899EUR/mo), PLATINIUM (custom)
  */
 
 import { PlanFeature, PLAN_FEATURES } from './plan-feature.vo';
 
-export type SubscriptionPlanType = 'FREE' | 'STARTER' | 'PRO' | 'ENTERPRISE';
+export type SubscriptionPlanType = 'BRONZE' | 'SILVER' | 'GOLD' | 'PLATINIUM';
 
 export type SupportLevel = 'none' | 'email' | 'direct' | 'dedicated_kam';
 export type StatusBadge = 'none' | 'silver' | 'gold' | 'platinium';
 
 /**
- * Legacy plan name mapping for backward compatibility with DB values.
+ * Legacy plan name mapping for backward compatibility during migration.
- * DB stores BRONZE/SILVER/GOLD/PLATINIUM (from migration); map them to canonical names.
  */
 const LEGACY_PLAN_MAPPING: Record<string, SubscriptionPlanType> = {
-  BRONZE: 'FREE',
+  FREE: 'BRONZE',
-  SILVER: 'STARTER',
+  STARTER: 'SILVER',
-  GOLD: 'PRO',
+  PRO: 'GOLD',
-  PLATINIUM: 'ENTERPRISE',
+  ENTERPRISE: 'PLATINIUM',
 };
 
 interface PlanDetails {
@@ -40,58 +39,58 @@ interface PlanDetails {
 }
 
 const PLAN_DETAILS: Record<SubscriptionPlanType, PlanDetails> = {
-  FREE: {
+  BRONZE: {
-    name: 'Free',
+    name: 'Bronze',
-    maxLicenses: 2,
+    maxLicenses: 1,
     monthlyPriceEur: 0,
     yearlyPriceEur: 0,
     maxShipmentsPerYear: 12,
     commissionRatePercent: 5,
     statusBadge: 'none',
     supportLevel: 'none',
-    planFeatures: PLAN_FEATURES.FREE,
+    planFeatures: PLAN_FEATURES.BRONZE,
-    features: ['Up to 2 users', '12 shipments per year', 'Basic rate search'],
+    features: ['1 utilisateur', '12 expéditions par an', 'Recherche de tarifs basique'],
   },
-  STARTER: {
+  SILVER: {
-    name: 'Starter',
+    name: 'Silver',
     maxLicenses: 5,
-    monthlyPriceEur: 49,
+    monthlyPriceEur: 249,
-    yearlyPriceEur: 470,
+    yearlyPriceEur: 2739, // 249 * 11 months
     maxShipmentsPerYear: -1,
     commissionRatePercent: 3,
     statusBadge: 'silver',
     supportLevel: 'email',
-    planFeatures: PLAN_FEATURES.STARTER,
+    planFeatures: PLAN_FEATURES.SILVER,
     features: [
-      'Up to 5 users',
+      "Jusqu'à 5 utilisateurs",
-      'Unlimited shipments',
+      'Expéditions illimitées',
-      'Dashboard',
+      'Tableau de bord',
-      'Maritime Wiki',
+      'Wiki Maritime',
-      'User management',
+      'Gestion des utilisateurs',
-      'CSV import',
+      'Import CSV',
-      'Email support',
+      'Support par email',
     ],
   },
-  PRO: {
+  GOLD: {
-    name: 'Pro',
+    name: 'Gold',
     maxLicenses: 20,
-    monthlyPriceEur: 249,
+    monthlyPriceEur: 899,
-    yearlyPriceEur: 2739,
+    yearlyPriceEur: 9889, // 899 * 11 months
     maxShipmentsPerYear: -1,
     commissionRatePercent: 2,
     statusBadge: 'gold',
     supportLevel: 'direct',
-    planFeatures: PLAN_FEATURES.PRO,
+    planFeatures: PLAN_FEATURES.GOLD,
     features: [
-      'Up to 20 users',
+      "Jusqu'à 20 utilisateurs",
-      'Unlimited shipments',
+      'Expéditions illimitées',
-      'All Starter features',
+      'Toutes les fonctionnalités Silver',
-      'API access',
+      'Intégration API',
-      'Direct commercial support',
+      'Assistance commerciale directe',
     ],
   },
-  ENTERPRISE: {
+  PLATINIUM: {
-    name: 'Enterprise',
+    name: 'Platinium',
     maxLicenses: -1, // unlimited
     monthlyPriceEur: 0, // custom pricing
     yearlyPriceEur: 0, // custom pricing
@@ -99,13 +98,13 @@ const PLAN_DETAILS: Record<SubscriptionPlanType, PlanDetails> = {
     commissionRatePercent: 1,
     statusBadge: 'platinium',
     supportLevel: 'dedicated_kam',
-    planFeatures: PLAN_FEATURES.ENTERPRISE,
+    planFeatures: PLAN_FEATURES.PLATINIUM,
     features: [
-      'Unlimited users',
+      'Utilisateurs illimités',
-      'All Pro features',
+      'Toutes les fonctionnalités Gold',
-      'Dedicated Key Account Manager',
+      'Key Account Manager dédié',
-      'Custom interface',
+      'Interface personnalisable',
-      'Framework rate contracts',
+      'Contrats tarifaires cadre',
     ],
   },
 };
@@ -122,18 +121,18 @@ export class SubscriptionPlan {
 
   /**
    * Create from string with legacy name support.
-   * Accepts both old DB names (BRONZE/SILVER/GOLD/PLATINIUM) and canonical names (FREE/STARTER/PRO/ENTERPRISE).
+   * Accepts both old (FREE/STARTER/PRO/ENTERPRISE) and new (BRONZE/SILVER/GOLD/PLATINIUM) names.
    */
   static fromString(value: string): SubscriptionPlan {
     const upperValue = value.toUpperCase();
 
-    // Check legacy mapping first (DB values BRONZE/SILVER/GOLD/PLATINIUM)
+    // Check legacy mapping first
     const mapped = LEGACY_PLAN_MAPPING[upperValue];
     if (mapped) {
       return new SubscriptionPlan(mapped);
     }
 
-    // Try direct match (canonical names)
+    // Try direct match
     if (PLAN_DETAILS[upperValue as SubscriptionPlanType]) {
       return new SubscriptionPlan(upperValue as SubscriptionPlanType);
     }
@@ -142,41 +141,41 @@ export class SubscriptionPlan {
   }
 
   // Named factories
-  static free(): SubscriptionPlan {
-    return new SubscriptionPlan('FREE');
-  }
-
-  static starter(): SubscriptionPlan {
-    return new SubscriptionPlan('STARTER');
-  }
-
-  static pro(): SubscriptionPlan {
-    return new SubscriptionPlan('PRO');
-  }
-
-  static enterprise(): SubscriptionPlan {
-    return new SubscriptionPlan('ENTERPRISE');
-  }
-
-  // Legacy aliases (kept for backward compatibility)
   static bronze(): SubscriptionPlan {
-    return SubscriptionPlan.free();
+    return new SubscriptionPlan('BRONZE');
   }
 
   static silver(): SubscriptionPlan {
-    return SubscriptionPlan.starter();
+    return new SubscriptionPlan('SILVER');
   }
 
   static gold(): SubscriptionPlan {
-    return SubscriptionPlan.pro();
+    return new SubscriptionPlan('GOLD');
   }
 
   static platinium(): SubscriptionPlan {
-    return SubscriptionPlan.enterprise();
+    return new SubscriptionPlan('PLATINIUM');
+  }
+
+  // Legacy aliases
+  static free(): SubscriptionPlan {
+    return SubscriptionPlan.bronze();
+  }
+
+  static starter(): SubscriptionPlan {
+    return SubscriptionPlan.silver();
+  }
+
+  static pro(): SubscriptionPlan {
+    return SubscriptionPlan.gold();
+  }
+
+  static enterprise(): SubscriptionPlan {
+    return SubscriptionPlan.platinium();
   }
 
   static getAllPlans(): SubscriptionPlan[] {
-    return (['FREE', 'STARTER', 'PRO', 'ENTERPRISE'] as SubscriptionPlanType[]).map(
+    return (['BRONZE', 'SILVER', 'GOLD', 'PLATINIUM'] as SubscriptionPlanType[]).map(
       p => new SubscriptionPlan(p)
     );
   }
@@ -251,21 +250,21 @@ export class SubscriptionPlan {
    * Returns true if this is a paid plan
    */
   isPaid(): boolean {
-    return this.plan !== 'FREE';
+    return this.plan !== 'BRONZE';
   }
 
   /**
-   * Returns true if this is the free plan
+   * Returns true if this is the free (Bronze) plan
    */
   isFree(): boolean {
-    return this.plan === 'FREE';
+    return this.plan === 'BRONZE';
   }
 
   /**
-   * Returns true if this plan has custom pricing (Enterprise)
+   * Returns true if this plan has custom pricing (Platinium)
    */
   isCustomPricing(): boolean {
-    return this.plan === 'ENTERPRISE';
+    return this.plan === 'PLATINIUM';
   }
 
   /**
@@ -280,7 +279,7 @@ export class SubscriptionPlan {
    * Check if upgrade to target plan is allowed
    */
   canUpgradeTo(targetPlan: SubscriptionPlan): boolean {
-    const planOrder: SubscriptionPlanType[] = ['FREE', 'STARTER', 'PRO', 'ENTERPRISE'];
+    const planOrder: SubscriptionPlanType[] = ['BRONZE', 'SILVER', 'GOLD', 'PLATINIUM'];
     const currentIndex = planOrder.indexOf(this.plan);
     const targetIndex = planOrder.indexOf(targetPlan.value);
     return targetIndex > currentIndex;
@@ -290,7 +289,7 @@ export class SubscriptionPlan {
    * Check if downgrade to target plan is allowed given current user count
    */
   canDowngradeTo(targetPlan: SubscriptionPlan, currentUserCount: number): boolean {
-    const planOrder: SubscriptionPlanType[] = ['FREE', 'STARTER', 'PRO', 'ENTERPRISE'];
+    const planOrder: SubscriptionPlanType[] = ['BRONZE', 'SILVER', 'GOLD', 'PLATINIUM'];
     const currentIndex = planOrder.indexOf(this.plan);
     const targetIndex = planOrder.indexOf(targetPlan.value);
 

apps/backend/src/infrastructure/persistence/typeorm/mappers/subscription-orm.mapper.ts

@@ -5,20 +5,7 @@
  */
 
 import { Subscription } from '@domain/entities/subscription.entity';
-import { SubscriptionOrmEntity, SubscriptionPlanOrmType } from '../entities/subscription.orm-entity';
+import { SubscriptionOrmEntity } from '../entities/subscription.orm-entity';
-
-/** Maps canonical domain plan names back to the values stored in the DB. */
-const DOMAIN_TO_ORM_PLAN: Record<string, SubscriptionPlanOrmType> = {
-  FREE: 'BRONZE',
-  STARTER: 'SILVER',
-  PRO: 'GOLD',
-  ENTERPRISE: 'PLATINIUM',
-  // Pass-through for any value already in ORM format
-  BRONZE: 'BRONZE',
-  SILVER: 'SILVER',
-  GOLD: 'GOLD',
-  PLATINIUM: 'PLATINIUM',
-};
 
 export class SubscriptionOrmMapper {
   /**
@@ -30,7 +17,7 @@ export class SubscriptionOrmMapper {
 
     orm.id = props.id;
     orm.organizationId = props.organizationId;
-    orm.plan = DOMAIN_TO_ORM_PLAN[props.plan] ?? 'BRONZE';
+    orm.plan = props.plan;
     orm.status = props.status;
     orm.stripeCustomerId = props.stripeCustomerId;
     orm.stripeSubscriptionId = props.stripeSubscriptionId;

apps/backend/src/infrastructure/stripe/stripe.adapter.ts

@@ -51,22 +51,22 @@ export class StripeAdapter implements StripePort {
     const platiniumMonthly = this.configService.get<string>('STRIPE_PLATINIUM_MONTHLY_PRICE_ID');
     const platiniumYearly = this.configService.get<string>('STRIPE_PLATINIUM_YEARLY_PRICE_ID');
 
-    if (silverMonthly) this.priceIdMap.set(silverMonthly, 'STARTER');
+    if (silverMonthly) this.priceIdMap.set(silverMonthly, 'SILVER');
-    if (silverYearly) this.priceIdMap.set(silverYearly, 'STARTER');
+    if (silverYearly) this.priceIdMap.set(silverYearly, 'SILVER');
-    if (goldMonthly) this.priceIdMap.set(goldMonthly, 'PRO');
+    if (goldMonthly) this.priceIdMap.set(goldMonthly, 'GOLD');
-    if (goldYearly) this.priceIdMap.set(goldYearly, 'PRO');
+    if (goldYearly) this.priceIdMap.set(goldYearly, 'GOLD');
-    if (platiniumMonthly) this.priceIdMap.set(platiniumMonthly, 'ENTERPRISE');
+    if (platiniumMonthly) this.priceIdMap.set(platiniumMonthly, 'PLATINIUM');
-    if (platiniumYearly) this.priceIdMap.set(platiniumYearly, 'ENTERPRISE');
+    if (platiniumYearly) this.priceIdMap.set(platiniumYearly, 'PLATINIUM');
 
-    this.planPriceMap.set('STARTER', {
+    this.planPriceMap.set('SILVER', {
       monthly: silverMonthly || '',
       yearly: silverYearly || '',
     });
-    this.planPriceMap.set('PRO', {
+    this.planPriceMap.set('GOLD', {
       monthly: goldMonthly || '',
       yearly: goldYearly || '',
     });
-    this.planPriceMap.set('ENTERPRISE', {
+    this.planPriceMap.set('PLATINIUM', {
       monthly: platiniumMonthly || '',
       yearly: platiniumYearly || '',
     });

apps/frontend/e2e/booking-workflow.spec.ts

@@ -77,7 +77,7 @@ test.describe('Complete Booking Workflow', () => {
     // Step 4: Select a Rate and Create Booking
     await test.step('Select Rate and Create Booking', async () => {
       // Select first available rate
-      await page.locator('.rate-card').first().locator('button:has-text("Book")').click();
+      await page.locator('.rate-card').first().click('button:has-text("Book")');
 
       // Should navigate to booking form
       await expect(page).toHaveURL(/.*bookings\/create/);