Fusionner l'ensemble des modèles construits durant :

Phase 2-A à Phase 2-N

dans un unique schéma Prisma cohérent :

apps/api/prisma/schema.prisma

Ce schéma deviendra :

Source de vérité de la base PostgreSQL

et servira à générer :

Prisma Client

Repositories

Services NestJS

DTO

OpenAPI

SDK Frontend

enum UserStatus
 
enum ReservationStatus
 
enum PaymentStatus
 
enum ContractStatus
 
enum LeadStatus
 
enum OpportunityStatus
 
enum TaskStatus
 
enum TaskPriority
 
enum PropertyStatus
 
enum RiskLevel
 
enum NotificationType
 
enum CampaignStatus
 
enum ChannelType
 
enum SyncStatus
 
enum CurrencyCode
 
enum LanguageCode
 
enum DataClassificationLevel

enum UserStatus {
 
  ACTIVE
 
  INACTIVE
 
  BLOCKED
 
  PENDING
}

User

Role

Permission

UserRole

RolePermission

Session

RefreshToken

User

↓

UserRole

↓

Role

↓

RolePermission

↓

Permission

@@unique([userId, roleId])
 
@@unique([roleId, permissionId])

Lead

Opportunity

Pipeline

PipelineStage

Activity

Task

CustomerNote

Tag

Segment

Ajouter :

assignedUserId String?

sur :

Lead

Opportunity

Task

assignedUser User?
  @relation(fields:[assignedUserId], references:[id])

Owner

Property

PropertyMedia

PropertyFeature

PropertyAvailability

PropertyRate

PropertyDistribution

slug String @unique
 
reference String @unique
 
publicUrl String?

@@index([slug])
 
@@index([reference])

Reservation

ReservationGuest

ReservationPricing

ReservationEvent

ReservationStatusHistory

reservationNumber String @unique

@@index([reservationNumber])

Payment

Refund

Invoice

AccountingEntry

paymentReference String @unique
 
invoiceNumber String @unique

@@index([paymentReference])
 
@@index([invoiceNumber])

Conversation

Message

Notification

Email

Sms

Template

Campaign

CampaignRecipient

CampaignExecution

Ajouter :

tenantId String

sur tous les modèles.

AiConversation

AiMessage

KnowledgeDocument

KnowledgeChunk

Recommendation

AutomationScenario

AutomationExecution

Si pgvector est utilisé :

embedding Unsupported("vector")?

Sinon :

embedding Json?

AuditLog

EntityHistory

FeatureFlag

Workflow

WorkflowStep

WorkflowInstance

WorkflowExecution

Ajouter :

tenantId String

sur l'ensemble des modèles.

model Tenant {
 
  id          String   @id @default(uuid())
 
  code        String   @unique
 
  name        String
 
  active      Boolean  @default(true)
 
  createdAt   DateTime @default(now())
 
  updatedAt   DateTime @updatedAt
}

Ajouter sur tous les modèles métier :

tenantId String
 
tenant Tenant
  @relation(fields:[tenantId], references:[id])

@@index([tenantId])

deletedAt DateTime?

Suppression logique

Restauration possible

Audit complet

Conformité RGPD

createdAt DateTime @default(now())
 
updatedAt DateTime @updatedAt
 
createdBy String?
 
updatedBy String?

Tracer :

Création

Modification

Historique utilisateur

sur l'ensemble du système.

@@index([createdAt])
 
@@index([updatedAt])
 
@@index([deletedAt])

sur tous les modèles volumineux :

Reservation

Payment

Invoice

Lead

Activity

AuditLog

Notification

Message

CampaignExecution

AutomationExecution

npx prisma validate

npx prisma format

npx prisma generate

À la fin de la Phase 4-A :

1 schema.prisma consolidé

≈ 110 modèles

≈ 350 relations

≈ 150 enums

≈ 500 index

100 % cohérent

Prêt pour migration

apps/api/prisma/schema.prisma

Transformer le schéma Prisma consolidé :

apps/api/prisma/schema.prisma

en une véritable base PostgreSQL opérationnelle.

À l'issue de cette phase :

✓ Base PostgreSQL créée

✓ Tables générées

✓ Index générés

✓ Contraintes générées

✓ Prisma Client généré

✓ Prisma Studio disponible

docker ps

Vous devez voir :

postgres

en cours d'exécution.

psql -h localhost -U postgres

ou

docker exec -it postgres psql -U postgres

touch apps/api/.env

DATABASE_URL="postgresql://postgres:postgres@localhost:5432/rental_platform?schema=public"

cat apps/api/.env

cd apps/api
 
npx prisma validate

The schema at prisma/schema.prisma is valid

Corriger :

relations

enum

index

syntaxe Prisma

avant de continuer.

npx prisma format

Prisma schema loaded

Formatted prisma/schema.prisma

npx prisma migrate dev --name init

prisma/

└── migrations/

    └── xxxxxxxxx_init/

        └── migration.sql

CREATE TABLE "User"

CREATE TABLE "Role"

CREATE TABLE "Property"

CREATE TABLE "Reservation"

CREATE TABLE "Invoice"

CREATE TABLE "Payment"

etc.

docker exec -it postgres psql -U postgres

\c rental_platform

\dt

Tenant

User

Role

Permission

Owner

Property

Customer

Reservation

Contract

Invoice

Payment

...

≈ 110 tables.

npx prisma generate

node_modules/.prisma/client

ls node_modules/.prisma/client

apps/api/src/test-prisma.ts

import { PrismaClient } from '@prisma/client';
 
const prisma = new PrismaClient();
 
async function main() {
 
  const tenants = await prisma.tenant.findMany();
 
  console.log(tenants);
}
 
main();

npx ts-node src/test-prisma.ts

[]

ou une liste de tenants.

prisma/seed.ts

await prisma.tenant.create({
 
  data: {
 
    code: 'MAIN',
 
    name: 'Main Tenant'
  }
});

await prisma.role.create({
 
  data: {
 
    code: 'SUPER_ADMIN',
 
    name: 'Super Administrateur'
  }
});

await prisma.permission.createMany({
 
  data: [
 
    {
      code: 'users.read',
      name: 'Users Read'
    },
 
    {
      code: 'users.create',
      name: 'Users Create'
    }
  ]
});

npx prisma db seed

npx prisma studio

http://localhost:5555

Tenant

User

Role

Permission

Property

Reservation

Payment

Invoice

doivent être visibles.

pg_dump \
-U postgres \
-d rental_platform \
-s \
> schema.sql

schema.sql

Ce fichier servira :

Audit

Review

Backup

Documentation

SELECT COUNT(*)
 
FROM information_schema.tables
 
WHERE table_schema='public';

SELECT COUNT(*)
 
FROM pg_indexes
 
WHERE schemaname='public';

SELECT COUNT(*)
 
FROM information_schema.table_constraints;

La Phase 4-B est terminée lorsque :

✓ Migration init exécutée

✓ PostgreSQL fonctionnel

✓ 110+ tables créées

✓ Prisma Client généré

✓ Seed exécuté

✓ Prisma Studio fonctionnel

✓ Snapshot SQL généré

prisma/schema.prisma

prisma/migrations/*

prisma/seed.ts

schema.sql

Transformer le modèle Prisma consolidé en contrats applicatifs utilisables par :

NestJS

Swagger

OpenAPI

Zod

NextJS

React Query

SDK TypeScript

À l'issue de cette phase :

✓ DTO générés

✓ Types TypeScript générés

✓ Validation Zod générée

✓ Contrats API stabilisés

✓ Base de génération Swagger

libs/

└── contracts/

    ├── dto/

    ├── schemas/

    ├── enums/

    ├── types/

    └── index.ts

Séparer :

Base de données

↓

Prisma Models

----------------

API

↓

DTO

----------------

Frontend

↓

Types

nx g @nx/js:library contracts

libs/contracts

npm install class-validator
 
npm install class-transformer
 
npm install @nestjs/swagger

npm install zod

npm install prisma-zod-generator

libs/contracts

├── dto

│   ├── auth

│   ├── users

│   ├── properties

│   ├── reservations

│   ├── crm

│   ├── finance

│   └── security

│
├── schemas
│
├── enums
│
└── types

export class CreateUserDto {
 
  @IsEmail()
  email: string;
 
  @IsString()
  firstName: string;
 
  @IsString()
  lastName: string;
 
  @MinLength(8)
  password: string;
}

export class LoginDto {
 
  @IsEmail()
  email: string;
 
  @IsString()
  password: string;
}

export class RefreshTokenDto {
 
  @IsString()
  refreshToken: string;
}

export class UpdateUserDto {
 
  @IsOptional()
  firstName?: string;
 
  @IsOptional()
  lastName?: string;
 
  @IsOptional()
  phone?: string;
}

export class UserResponseDto {
 
  id: string;
 
  email: string;
 
  firstName: string;
 
  lastName: string;
 
  status: UserStatus;
}

export class CreatePropertyDto {
 
  title: string;
 
  description?: string;
 
  propertyType: string;
 
  maxGuests: number;
 
  bedrooms: number;
 
  bathrooms: number;
}

export class UpdatePropertyDto {
 
  title?: string;
 
  description?: string;
 
  published?: boolean;
}

export class PropertyResponseDto {
 
  id: string;
 
  reference: string;
 
  slug: string;
 
  title: string;
 
  published: boolean;
}

export class CreateReservationDto {
 
  propertyId: string;
 
  customerId: string;
 
  checkInDate: Date;
 
  checkOutDate: Date;
 
  adults: number;
 
  children?: number;
}

export class ReservationResponseDto {
 
  id: string;
 
  reservationNumber: string;
 
  status: ReservationStatus;
 
  totalAmount: number;
}

export class CreateLeadDto {
 
  firstName: string;
 
  lastName: string;
 
  email: string;
 
  source?: string;
}

export class CreateTaskDto {
 
  title: string;
 
  description?: string;
 
  assignedUserId?: string;
 
  dueDate?: Date;
}

export class CreateInvoiceDto {
 
  reservationId: string;
 
  issueDate: Date;
}

export class PaymentDto {
 
  reservationId: string;
 
  amount: number;
 
  currencyCode: string;
}

export class EnableMfaDto {
 
  method: string;
}

export class ConsentDto {
 
  consentType: string;
 
  granted: boolean;
}

export class PaginationRequest {
 
  page?: number;
 
  pageSize?: number;
 
  sort?: string;
 
  search?: string;
}

export class PaginationResponse<T> {
 
  data: T[];
 
  total: number;
 
  page: number;
 
  pageSize: number;
 
  totalPages: number;
}

export interface ApiResponse<T> {
 
  success: true;
 
  data: T;
}

export interface ApiError {
 
  success: false;
 
  code: string;
 
  message: string;
}

Dans :

schema.prisma

ajouter :

generator zod {
 
  provider = "prisma-zod-generator"
}

npx prisma generate

libs/contracts/schemas

contenant :

UserSchema

PropertySchema

ReservationSchema

LeadSchema

InvoiceSchema

PaymentSchema

export * from './user-status.enum';
 
export * from './reservation-status.enum';
 
export * from './payment-status.enum';

export * from './auth';
 
export * from './users';
 
export * from './properties';
 
export * from './reservations';

export * from './dto';
 
export * from './schemas';
 
export * from './enums';
 
export * from './types';

nx build contracts

npx tsc --noEmit

nx lint contracts

libs/contracts/dto

libs/contracts/types

libs/contracts/enums

libs/contracts/schemas

libs/contracts/index.ts

La Phase 4-C est terminée lorsque :

✓ DTO créés

✓ Types TypeScript créés

✓ Zod généré

✓ Contrats partagés Backend/Frontend

✓ Validation unifiée

✓ Build vert

Construire l'architecture complète du backend NestJS à partir :

Prisma Schema consolidé

OpenAPI Enterprise 4.0

Contrats DTO

DDD

CQRS

Hexagonal Architecture

À l'issue de cette phase :

✓ Backend structuré

✓ Modules générés

✓ CQRS en place

✓ Event Bus en place

✓ Repository Pattern

✓ Domain Services

✓ Guards

✓ Interceptors

✓ Filters

✓ Multi-Tenant

apps/api/src

├── core

├── infrastructure

├── shared

├── modules

└── bootstrap

Contenir les composants techniques communs.

src/core

├── database

├── cqrs

├── events

├── guards

├── interceptors

├── filters

├── decorators

├── exceptions

├── logging

└── tenancy

src/core/database/prisma.service.ts

src/core/database/prisma.module.ts

npm install @nestjs/cqrs

src/core/cqrs/cqrs.module.ts

Commands

Queries

Handlers

Events

Sagas

UserCreated

ReservationCreated

ContractSigned

PaymentReceived

InvoiceGenerated

LeadConverted

MfaEnabled

src/core/events

Mutualiser les objets transverses.

src/shared

├── dto

├── enums

├── constants

├── types

├── interfaces

└── utils

Contenir les adaptateurs techniques.

Construire l'architecture complète du backend NestJS à partir :

Prisma Schema consolidé

OpenAPI Enterprise 4.0

Contrats DTO

DDD

CQRS

Hexagonal Architecture

À l'issue de cette phase :

✓ Backend structuré

✓ Modules générés

✓ CQRS en place

✓ Event Bus en place

✓ Repository Pattern

✓ Domain Services

✓ Guards

✓ Interceptors

✓ Filters

✓ Multi-Tenant

apps/api/src

├── core

├── infrastructure

├── shared

├── modules

└── bootstrap

Contenir les composants techniques communs.

src/core

├── database

├── cqrs

├── events

├── guards

├── interceptors

├── filters

├── decorators

├── exceptions

├── logging

└── tenancy

src/core/database/prisma.service.ts

src/core/database/prisma.module.ts

npm install @nestjs/cqrs

src/core/cqrs/cqrs.module.ts

Commands

Queries

Handlers

Events

Sagas

UserCreated

ReservationCreated

ContractSigned

PaymentReceived

InvoiceGenerated

LeadConverted

MfaEnabled

src/core/events

Mutualiser les objets transverses.

src/shared

├── dto

├── enums

├── constants

├── types

├── interfaces

└── utils

src/infrastructure

├── prisma

├── cache

├── queue

├── mail

├── sms

├── storage

├── payments

├── signatures

├── ota

├── ai

└── search

src/infrastructure/cache

npm install @nestjs/cache-manager
 
npm install cache-manager
 
npm install cache-manager-redis-store
 
npm install redis

CacheService

CacheKeys

CacheInvalidationService

npm install @nestjs/bullmq
 
npm install bullmq

queue.module.ts

jobs/

processors/

workers/

SendEmailJob

SendSmsJob

GenerateInvoiceJob

SyncOtaJob

GenerateContractJob

AiIndexationJob

SendGrid

Mailgun

SMTP

Amazon SES

export interface EmailProvider {
 
  send(
    payload: SendEmailPayload
  ): Promise<void>;
}

Twilio

MessageBird

OVH SMS

export interface SmsProvider {
 
  send(
    payload: SendSmsPayload
  ): Promise<void>;
}

S3

MinIO

Azure Blob

StorageService

FileUploadService

ImageOptimizationService

Stripe

PayPal

StripeAdapter

PaypalAdapter

DocuSign

Yousign

Universign

DocusignAdapter

YousignAdapter

BookingAdapter

AirbnbAdapter

VrboAdapter

ExpediaAdapter

OpenAI

Azure OpenAI

Anthropic

AiAssistantService

EmbeddingService

RecommendationService

KnowledgeSearchService

Chaque domaine métier adopte exactement la même structure.

src/modules/properties

├── application

├── domain

├── infrastructure

├── presentation

└── properties.module.ts

application

├── commands

├── queries

├── handlers

├── dto

└── mappers

commands/

CreatePropertyCommand

UpdatePropertyCommand

PublishPropertyCommand

GetPropertyQuery

SearchPropertiesQuery

GetAvailabilityQuery

domain

├── entities

├── repositories

├── services

├── value-objects

└── events

Property

Reservation

Owner

Invoice

Lead

export interface PropertyRepository {
 
  findById(id: string);
 
  save(property: Property);
 
  delete(id: string);
}

PricingService

ReservationService

ContractService

RevenueManagementService

PrismaPropertyRepository

PrismaReservationRepository

PrismaLeadRepository

infrastructure/prisma

└── prisma-property.repository.ts

presentation

├── controllers

├── presenters

└── swagger

properties.controller.ts

availability.controller.ts

rates.controller.ts

AuthModule

UsersModule

OwnersModule

PropertiesModule

ReservationsModule

ContractsModule

PaymentsModule

InvoicesModule

CRMModule

MessagingModule

MarketingModule

AutomationModule

AiModule

GovernanceModule

OtaModule

RevenueModule

SecurityModule

InternationalizationModule

src/core/tenancy

TenantContextService

X-Tenant-Id

TenantGuard

TenantMiddleware

Injecter automatiquement :

tenantId

dans tous les accès Prisma.

JwtAuthGuard

RolesGuard

PermissionsGuard

TenantGuard

MfaGuard

@CurrentUser()
 
@Roles()
 
@Permissions()
 
@Tenant()

LoggingInterceptor

AuditInterceptor

CacheInterceptor

TenantInterceptor

ResponseTransformInterceptor

GlobalExceptionFilter

PrismaExceptionFilter

ValidationExceptionFilter

DomainExceptionFilter

{
  "success": false,
  "code": "PROPERTY_NOT_FOUND",
  "message": "Property not found"
}

src/bootstrap

├── swagger.ts

├── validation.ts

├── security.ts

└── app.ts

async function bootstrap() {
 
  const app =
    await NestFactory.create(AppModule);
 
  setupSwagger(app);
 
  setupValidation(app);
 
  setupSecurity(app);
 
  await app.listen(3000);
}

AppModule

├── CoreModule

├── InfrastructureModule

├── AuthModule

├── UsersModule

├── OwnersModule

├── PropertiesModule

├── ReservationsModule

├── ContractsModule

├── PaymentsModule

├── CRMModule

├── MessagingModule

├── RevenueModule

├── SecurityModule

nx build api

nx lint api

nx test api

src/core

src/shared

src/infrastructure

src/modules

src/bootstrap

app.module.ts

main.ts

La Phase 4-D est terminée lorsque :

✓ Architecture Hexagonale en place

✓ CQRS installé

✓ Event Bus installé

✓ Modules générés

✓ Multi-Tenant opérationnel

✓ Guards opérationnels

✓ Interceptors opérationnels

✓ Filters opérationnels

✓ Build vert

Construire l'architecture Frontend complète de la plateforme.

Cette phase transforme :

OpenAPI Enterprise

DTO TypeScript

SDK TypeScript

Contrats API

en une application :

NextJS 15

React 19

TypeScript

TanStack Query

TailwindCSS

shadcn/ui

Multi-Tenant

RBAC

Internationalisée

À l'issue de cette phase :

✓ Frontend compilable

✓ Authentification complète

✓ Layouts Enterprise

✓ Design System

✓ Pages métier

✓ Gestion permissions

✓ Multi-tenant

✓ Multi-langues

cd apps
 
npx create-next-app@latest web

TypeScript        YES

ESLint            YES

TailwindCSS       YES

App Router        YES

src/ directory    YES

Turbopack         YES

Import Alias      YES

apps/web

npm install @tanstack/react-query
 
npm install @tanstack/react-query-devtools

npm install react-hook-form
 
npm install zod
 
npm install @hookform/resolvers

npm install jwt-decode

npx shadcn@latest init

npx shadcn add button
 
npx shadcn add input
 
npx shadcn add dialog
 
npx shadcn add table
 
npx shadcn add dropdown-menu
 
npx shadcn add form
 
npx shadcn add card
 
npx shadcn add tabs
 
npx shadcn add toast

apps/web/src

├── app

├── modules

├── components

├── layouts

├── hooks

├── services

├── providers

├── stores

├── lib

├── types

└── config

providers

├── query-provider.tsx

├── auth-provider.tsx

├── tenant-provider.tsx

├── theme-provider.tsx

└── i18n-provider.tsx

<QueryClientProvider>
 
  {children}
 
</QueryClientProvider>

services/api

├── auth

├── users

├── properties

├── reservations

├── crm

├── finance

├── ota

├── ai

└── security

export const getProperty = (
 
  id: string
 
) => sdk.properties.getProperty(id);

modules/auth

├── hooks

├── services

├── components

└── pages

/login

/register

/forgot-password

/reset-password

/mfa

useCurrentUser()
 
useLogin()
 
useLogout()
 
usePermissions()

layouts/public-layout.tsx

layouts/auth-layout.tsx

layouts/dashboard-layout.tsx

layouts/owner-layout.tsx

layouts/admin-layout.tsx

Dashboard

Reservations

Properties

Owners

CRM

Finance

Marketing

Analytics

Security

Administration

Piloté par :

Permissions

Tenant

Feature Flags

/properties

/properties/create

/properties/[id]

/properties/[id]/edit

PropertyForm

PropertyTable

PropertyCard

PropertyGallery

AvailabilityCalendar

/reservations

/reservations/create

/reservations/[id]

ReservationForm

ReservationDetails

GuestList

PricingSummary

/crm/leads

/crm/opportunities

/crm/tasks

/crm/customers

LeadKanban

OpportunityPipeline

TaskBoard

CustomerTimeline

/finance/payments

/finance/invoices

/finance/refunds

InvoiceTable

PaymentHistory

RefundManager

/ota/channels

/ota/distribution

/ota/synchronization

ChannelStatus

SyncDashboard

DistributionTable

/ai

/ai/chat

/ai/recommendations

/ai/knowledge-base

AiChat

RecommendationPanel

KnowledgeSearch

AutomationDashboard

/security

/security/mfa

/security/sessions

/security/privacy

/security/compliance

MfaWizard

SessionManager

ConsentManager

RiskMatrix

/dashboard

Revenue KPI

Occupancy KPI

Reservations KPI

Payments KPI

Lead KPI

Security KPI

npm install next-intl

fr

en

es

it

de

nl

messages

├── fr.json

├── en.json

├── es.json

└── de.json

X-Tenant-Id

TenantProvider

TenantContext

Changer dynamiquement :

Branding

Logo

Couleurs

Permissions

Domaine

selon le tenant.

useRole()
 
usePermission()
 
useFeatureFlag()