@clidey/dory 0.1.0 → 0.2.0

package/docs/usage/api-usage/api-suppliers.mdx

@@ -1,171 +0,0 @@
----
-title: 'Suppliers API'
-description: 'Management of suppliers and vendor import/export functionalities.'
----
-
-## Suppliers API - Internal Developer Documentation
-
-### 1. Purpose and Scope
-
-The Suppliers API is a core backend service within the Genie application responsible for managing supplier entities and their relationships to products and product variants. It enables operations such as creating, retrieving, updating, deleting suppliers, importing suppliers from CSV files, managing associations between suppliers and products, and handling supplier payment terms.
-
-This service directly supports the procurement workflow by maintaining up-to-date supplier data, ensuring synchronisation with products, and facilitating bulk operations via CSV imports. It operates within the team scope, ensuring data isolation per team.
-
-**System boundaries:**
-- Acts as an internal REST API controller exposing suppliers-related endpoints.
-- Interfaces with the database through TypeORM repositories for Supplier, Product, and related entities.
-- Integrates with the asset management service for handling attachments.
-
-**Architectural context:**
-- Part of the Supplier Module within the backend API service.
-- Leverages shared DTOs and schemas from the `@genie/shared` package for data validation.
-
-### 2. Technical Overview
-
-The core of the Suppliers API is implemented via two classes:
-- `SuppliersController`: Exposes REST endpoints following NestJS controller patterns.
-- `SuppliersService`: Contains business logic and database interactions.
-
-#### Architecture and Integration
-
-```mermaid
-flowchart TD
-  subgraph "Backend API Service"
-    SuppliersController["SuppliersController (REST Endpoints)"]:::controller
-    SuppliersService["SuppliersService (Business Logic)"]:::service
-    SupplierRepository["Supplier Repository (TypeORM)"]:::db
-    ProductRepository["Product Repository (TypeORM)"]:::db
-    ProductSupplierRepository["ProductSupplier Repository (TypeORM)"]:::db
-    AssetsService["AssetsService (Asset Cleanup & Management)"]:::service
-  end
-
-  SuppliersController -->|"calls"| SuppliersService
-  SuppliersService -->|"uses"| SupplierRepository
-  SuppliersService -->|"uses"| ProductRepository
-  SuppliersService -->|"uses"| ProductSupplierRepository
-  SuppliersService -->|"calls"| AssetsService
-
-  classDef controller fill:#74c0fc,stroke:#1c7ed6,color:#fff,stroke-width:1px;
-  classDef service fill:#63e6be,stroke:#20c997,color:#044f1e,stroke-width:1px;
-  classDef db fill:#ffa94d,stroke:#d9480f,color:#661a00,stroke-width:1px;
-```
-
-#### Key technologies and frameworks
-- NestJS for API structure and dependency injection
-- TypeORM for database access with repository pattern
-- Zod for runtime schema validation
-- node-fetch and csv-parser for remote CSV import and parsing
-- Lodash for utility functions
-
-### 3. Core Concepts and Responsibilities
-
-- **Team Boundary:** All supplier data belongs and is scoped to a `teamId` ensuring multi-tenancy.
-- **Supplier Entity:** Stores supplier data including contact info, address, lead time, minimum order quantity (MOQ), and payment terms.
-- **Product-Supplier Relationships:** Supports binding products and their variants to suppliers, including primary and secondary suppliers.
-- **Payment Terms:** Three types supported: Upfront, Net Days, and Installments. Payment terms are stored in separate entities linked to suppliers.
-- **CSV Import and Mapping:** The service supports importing suppliers and mapping supplier-product-variant relations via CSV files fetched over HTTP.
-
-### 4. Code Structure
-
-Relevant files:
-- [SuppliersService](apps/api/src/supplier/services/suppliers.service.ts): Main service class implementing business logic.
-- [SuppliersController](apps/api/src/supplier/controllers/suppliers.controllers.ts): REST API endpoints.
-
-#### Key Files and Responsibilities
-| File | Responsibility |
-|---|---|
-| apps/api/src/supplier/services/suppliers.service.ts | Core supplier logic: CRUD, imports, product associations.
-| apps/api/src/supplier/controllers/suppliers.controllers.ts | HTTP endpoint handlers with validation and response formatting.
-
-#### Example: Creating a Supplier
-```ts
-async createSupplier(teamId: string, data: CreateOrUpdateSupplierRequestDto) {
-  const supplier = this.supplierRepository.create({
-    ...data,
-    teamId,
-  });
-  return await this.supplierRepository.save(supplier);
-}
-```
-
-#### Example: Importing Suppliers from CSV
-```ts
-private async parseSuppliersImportCSV(url: string) {
-  const response = await fetch(url);
-  if (!response.ok) throw new Error(`Failed to fetch file: ${response.statusText}`);
-
-  return new Promise((resolve, reject) => {
-    const results: SupplierDto[] = [];
-    response.body.pipe(csvParser({ separator: ",", quote: '"' }))
-      .on("data", (row) => {
-        // map CSV rows to supplier data with contacts parsing
-      })
-      .on("end", () => resolve(results))
-      .on("error", reject);
-  });
-}
-```
-
-### 5. API and Interfaces
-
-Supported endpoints (via `SuppliersController`):
-
-| HTTP Method & Path              | Purpose                                | Input Schema                                   | Response Schema              |
-|-------------------------------|---------------------------------------|-----------------------------------------------|-----------------------------|
-| POST `/suppliers`             | List suppliers with filters/pagination | `GetSuppliersRequestDto`                       | `GetSuppliersResponseDto`    |
-| GET `/suppliers/import-suppliers-template` | Download CSV template for import       | None                                          | CSV text                    |
-| GET `/suppliers/:id`          | Get supplier detail by ID              | Path param: supplier ID                          | `SupplierDto`               |
-| POST `/suppliers/create`      | Create a new supplier                  | `CreateOrUpdateSupplierRequestDto`             | `SupplierDto`               |
-| PUT `/suppliers/:id`          | Update supplier details                | `CreateOrUpdateSupplierRequestDto`             | None (204 No Content)        |
-| DELETE `/suppliers/:id`       | Delete supplier                       | Path param: supplier ID                          | None (204 No Content)        |
-| PUT `/suppliers/:id/attachmentUrls` | Update attachment URLs for supplier    | `UpdateSupplierAttachmentUrlsRequestDto`       | None (204 No Content)        |
-| POST `/suppliers/get-importable-vendors` | Get vendors (not yet linked as suppliers) | None                                          | array of vendor names       |
-| POST `/suppliers/import-vendors` | Import vendors as suppliers            | `ImportVendorsRequestDto`                      | None                       |
-| POST `/suppliers/:id/add-products` | Add products to supplier             | `AddProductsRequestDto`                        | None (204 No Content)        |
-| POST `/suppliers/:id/remove-products` | Remove products from supplier         | `RemoveProductsRequestDto`                     | None (204 No Content)        |
-| POST `/suppliers/import-suppliers` | Bulk import suppliers CSV            | `ImportSuppliersRequestDto`                     | None                       |
-| POST `/suppliers/import-suppliers-products-mapping` | Bulk import supplier-product mappings | `ImportSuppliersProductsMappingRequestDto`     | None                       |
-
-#### Validation
-All inputs are validated with Zod schemas imported from `@genie/shared`. Invalid data results in thrown exceptions with error details.
-
-#### Failure Modes
-- Not found errors throw `GenieException` with codes like `SupplierNotFound`, caught in controllers and return 404.
-- CSV parsing failures throw `GenieException` with validation error details.
-
-### 6. Environment & Configuration
-
-No explicit environment variables or external config referenced within the Suppliers API service itself beyond the general backend API setup.
-
-Uses shared libraries such as `node-fetch` and `csv-parser` for CSV imports.
-
-### 7. Testing, Monitoring, and Deployment
-
-Testing strategy details are not included in the provided context.
-
-The service uses structured exceptions (`GenieException`) for consistent error handling.
-
-Logging and error details are captured via exceptions but precise monitoring and alerting configurations are not specified.
-
-### 8. Troubleshooting & Known Issues
-
-- Searching suppliers by country name is currently not supported since the entity stores only country codes.
-
-- Import CSV files must match strict schema validation or import operations fail.
-
-- When updating payment terms, only one payment term type is supported per supplier at a time and existing payment term records are deleted within a database transaction.
-
-### 9. Style and Tone Guidelines
-
-- Code uses async/await for asynchronous operations.
-- Transactions are used for complex updates to maintain data consistency.
-- Clear separation of concerns between controller (HTTP) and service (logic).
-
----
-
-### References
-- [SuppliersService](apps/api/src/supplier/services/suppliers.service.ts)
-- [SuppliersController](apps/api/src/supplier/controllers/suppliers.controllers.ts)
-- [Shared DTOs and Schemas](@genie/shared)
-
----

package/docs/usage/api-usage/api-user-management.mdx

@@ -1,171 +0,0 @@
----
-title: 'User & Teams API'
-description: 'User context, team management, invitations, and user-related configuration.'
----
-
-## User & Teams API - Developer Documentation
-
-### 1. Purpose and Scope
-
-The **User & Teams API** module manages all aspects of user and team management within the Genie application. It handles team settings, user invitations, membership, notifications, and related configurations. The API ensures that users belong to teams, administrators manage memberships and invitations, and teams' settings and insights configurations are maintained.
-
-This component serves as a foundational building block for user management workflows, offering RESTful endpoints primarily through the `TeamsController` and backend logic encapsulated in the `TeamsService`. It supports administrative operations, user onboarding, and team lifecycle management.
-
-**System Boundaries:** This API interacts closely with other subsystems such as SettingsService (for team configurations), EmailService (sending invitations), JWT authentication (auth tokens on invitation acceptance), and Shopify integration (via team Shopify stores). It is a backend component used by frontend UI workflows and other backend processes.
-
-### 2. Technical Overview
-
-The User & Teams API is implemented using the NestJS framework, leveraging decorators for routing and validation. The main controller is `TeamsController`, defined in `apps/api/src/user-management/controllers/teams.controller.ts`. Business logic is centralized in the `TeamsService` located at `apps/api/src/user-management/services/teams.service.ts`.
-
-Key technology and framework usage:
-- **NestJS**: For modular MVC structure and dependency injection.
-- **TypeORM**: For database interactions related to users, teams, and invitations.
-- **Zod**: For robust schema validation of request payloads and response transformations.
-- **JWT**: For token generation when a user accepts an invitation.
-
-The module enforces strict team membership checks before processing requests and uses structured exception handling (e.g., `GenieException`) for business logic errors.
-
-### Mermaid Diagram
-
-```mermaid
-flowchart TD
-  subgraph API Layer
-    direction TB
-    TeamsController["TeamsController\n(apps/api/src/user-management/controllers/teams.controller.ts)"]:::service
-  end
-
-  subgraph Service Layer
-    direction TB
-    TeamsService["TeamsService\n(apps/api/src/user-management/services/teams.service.ts)"]:::service
-    SettingsService["SettingsService"]
-    EmailService["EmailService"]
-    JwtService["JwtService"]
-  end
-
-  subgraph Data Layer
-    direction TB
-    UserEntity["UserEntity (DB)"]:::database
-    TeamEntity["TeamEntity (DB)"]:::database
-    MemberInvitationEntity["MemberInvitationEntity (DB)"]:::database
-  end
-
-  TeamsController -->|calls| TeamsService
-  TeamsController -->|calls| SettingsService
-  TeamsService -->|reads/writes| UserEntity
-  TeamsService -->|reads/writes| TeamEntity
-  TeamsService -->|reads/writes| MemberInvitationEntity
-  TeamsService -->|sends email| EmailService
-  TeamsService -->|generates token| JwtService
-
-  classDef service fill:#def,stroke:#333,stroke-width:1px,color:#000
-  classDef database fill:#ffd,stroke:#b28,stroke-width:1px,color:#000
-
-  click TeamsController "apps/api/src/user-management/controllers/teams.controller.ts"
-  click TeamsService "apps/api/src/user-management/services/teams.service.ts"
-```
-
-### 3. Core Concepts and Responsibilities
-
-- **Team Membership Enforcement:** Every endpoint validates that the acting user belongs to a team; otherwise, a `GenieException` is thrown.
-- **Invitation Lifecycle:** Invitations can be sent, verified (validated against existing users and teams), accepted (with token issuance), or removed.
-- **Role-Based Access:** Certain actions, such as deactivating users, require the acting user to be a Team Admin. This is explicitly checked via `UserRole.Admin`.
-- **Settings Management:** The module allows updating and retrieving team-related settings (general, insights, shop).
-- **Invitation Expiry and Validation:** Invitations are expired if older than a predefined age constant (`MAX_MEMBER_INVITE_AGE_DAYS`).
-- **Soft Deactivation of Users:** Deactivating a user anonymizes their email and clears sensitive fields, allowing reuse of the original email.
-
-**Ownership**: Maintained by the User Management Team.
-
-### 4. Code Structure
-
-- **Controllers**
-  - `TeamsController` handles HTTP routes under `/teams`, validating inputs using `ZodValidationPipe` and delegating logic to services.
-
-- **Services**
-  - `TeamsService` performs user/team data operations, invitation management, and integration with Email and JWT.
-
-- **Entities**
-  - Database entities (`UserEntity`, `TeamEntity`, `MemberInvitationEntity`) connect ORM to Postgres.
-
-- **DTOs and Validation Schemas**
-  - Located under shared DTOs, e.g., `TeamSettingsDto`, `SendInvitationsRequestDto`.
-
-**Example Key Method:** Sending Team Invitations
-
-```ts
-async sendInvitations({ teamId, userId, invitations }) {
-  // Validate all invitations
-  const errors = [];
-  for (const inv of invitations) {
-    const err = await this.validateInvitation(teamId, inv);
-    if (err) errors.push({ email: inv.email, error: err });
-  }
-  if (errors.length) return { successful: false, invitationErrors: errors };
-
-  // Expire existing invitations if any
-  for (const inv of invitations) {
-    const existing = await this.memberInvitationRepository.findOne({
-      where: { teamId, email: inv.email, status: MemberInvitationStatus.Pending },
-    });
-    if (existing) {
-      await this.memberInvitationRepository.update(existing.id, { status: MemberInvitationStatus.Expired });
-    }
-
-    // Create and save new invitation
-    await this.memberInvitationRepository.save({
-      teamId, inviterUserId: userId, email: inv.email, role: inv.role, status: MemberInvitationStatus.Pending
-    });
-
-    // Send invitation email
-    await this.emailService.sendInvitationEmail(inv.email, existing.id || newInvitation.id, user.firstName);
-  }
-
-  return { successful: true };
-}
-```
-
-### 5. API and Interfaces
-
-The API exposes the following key endpoints in `TeamsController`:
-
-| HTTP Method | Endpoint                | Description                                      | Request Validation Schema                       | Requires team membership |
-|-------------|-------------------------|------------------------------------------------|------------------------------------------------|--------------------------|
-| PUT         | /teams/settings         | Update team-wide settings                       | `teamSettingsDtoSchema`                         | Yes                      |
-| PUT         | /teams/settings/general | Update general team settings                    | `teamGeneralSettingsDtoSchema`                  | Yes                      |
-| GET         | /teams/settings/general | Retrieve general team settings                  | N/A                                            | Yes                      |
-| PUT         | /teams/settings/insights| Update team insights settings                   | `insightsSettingsSchema`                        | Yes                      |
-| GET         | /teams/settings/insights| Retrieve team insights settings                 | N/A                                            | Yes                      |
-| GET         | /teams/settings/shop    | Get team's Shopify shop settings                | N/A                                            | Yes                      |
-| GET         | /teams/members          | Get list of team members and invitations       | N/A                                            | Yes                      |
-| POST        | /teams/send-invitations | Send invitations to new members                 | `sendInvitationsRequestDtoSchema`               | Yes                      |
-| PATCH       | /teams/user/:id/deactivate | Deactivate a user by ID                       | N/A                                            | Yes, Admin only           |
-| DELETE      | /teams/invitations/:email| Remove pending invitation by email             | N/A                                            | Yes                      |
-| POST        | /teams/accept-invitation | Accept an invitation using a code (public)    | `AcceptInvitationRequestDto`                    | No                       |
-
-**Failure modes**:
-- Actions throw `GenieException` if the user is not assigned to a team.
-- Only Admins can deactivate users.
-- Invitation acceptance fails with `ForbiddenException` on invalid, expired codes, or email conflicts.
-
-Authentication and Authorization are managed implicitly by checking `user.teamId` and `user.role`.
-
-### 6. Environment & Configuration
-
-No explicit environment variables are required specifically by this module mentioned in context. However, it depends on:
-- EmailService for invitation emails.
-- JWT secret for signing tokens.
-
-Local development requires connection to the appropriate database used by TypeORM.
-
-### 7. Testing, Monitoring, and Deployment
-
-Testing specifics are not provided. The module uses NestJS conventions allowing unit and integration tests for controllers and services.
-
-Monitoring and error logging happen via `GenieException` with structured logging.
-
-### 8. Troubleshooting & Known Issues
-
-No explicit troubleshooting or common issues are documented.
-
-### Summary
-
-The User & Teams API manages team member lifecycle, settings, and invitations with a focus on security, validation, and up-to-date team data management. The modular pattern and strong typing with DTOs and Zod schemas make it robust and maintainable. Understanding the team membership checks and invitation handling flow is key to working with this codebase.

package/docs/usage/ui-workflows/bundles.mdx

@@ -1,157 +0,0 @@
----
-title: 'Bundles Management'
-description: 'Managing product bundles, adding or editing bundled products, and bulk operations.'
----
-
-## Bundles Management - Internal Developer Documentation
-
-### 1. Purpose and Scope
-
-The Bundles Management subsystem is responsible for handling product bundles within the Genie platform. Bundles represent products composed of multiple standalone components, allowing the system to track aggregate sales data while managing individual components separately. This module manages CRUD operations on bundles and their components, synchronizes bundles with purchase orders, and supports upstream and downstream data consistency.
-
-This subsystem operates within the Product Information Management (PIM) context and interfaces closely with key services such as purchase order processing and team management. It solves the problem of associating bundles' sales attribution to component products, ensuring data cleanliness, and maintaining bundle mappings in sync with inventory and sales data.
-
-### 2. Technical Overview
-
-Bundles are implemented primarily via specialized `ProductVariantEntity` entries where the variant `type` is set to `InventoryItemType.Bundle`. Components of bundles are managed via `ProductVariantComponentEntity` entities that link parent (bundle) variants to child (standalone) product variants with specified quantities.
-
-The system employs a layered architecture with clear separation:
-- **API/Controller Layer**: e.g., `BundlesController` handles HTTP requests related to bundle operations and team inventory migrations.
-- **Service Layer**: e.g., `ProductsMappingService` and `PoBundlesService` encapsulate business logic for bundle creation, deletion, updates, and purchase order synchronization.
-
-Key technologies include:
-- NestJS framework with dependency injection and decorators.
-- TypeORM as the ORM for database abstraction.
-- PostgreSQL for relational storage with SQL queries optimized for bundle and component retrieval.
-
-Design patterns:
-- **Repository pattern** via TypeORM repositories.
-- Upsert operations to handle idempotent creation or updates of components.
-- Transactional integrity ensuring consistency when modifying bundles and components.
-
-### Mermaid Diagram of Core Components and Relationships
-
-```mermaid
-flowchart TD
-  subgraph Backend Services
-    BundlesController["BundlesController (API Layer)"]:::controller
-    ProductsMappingService["ProductsMappingService (Bundle Logic)"]:::service
-    PoBundlesService["PoBundlesService (PO Bundle Sync)"]:::service
-    TeamsService["TeamsService (Team Management)"]:::service
-  end
-
-  subgraph Database
-    ProductEntity[("ProductEntity (Products Table)")]
-    ProductVariantEntity[("ProductVariantEntity (Variants Table)")]
-    ProductVariantComponentEntity[("ProductVariantComponentEntity (Bundle Components)")]
-    PurchaseOrderItemEntity[("PurchaseOrderItemEntity (PO Items)")]
-    PurchaseOrderBundleItemEntity[("PurchaseOrderBundleItemEntity (PO Bundle Items)")]
-  end
-
-  BundlesController -->|"calls"| TeamsService
-  BundlesController -->|"calls"| PoBundlesService
-  PoBundlesService -->|"uses Repos"| PurchaseOrderItemEntity
-  PoBundlesService -->|"uses Repos"| PurchaseOrderBundleItemEntity
-  ProductsMappingService -->|"updates"| ProductVariantEntity
-  ProductsMappingService -->|"manages"| ProductVariantComponentEntity
-  ProductsMappingService -->|"delegates"| PoBundlesService
-  ProductVariantComponentEntity -->|"links"| ProductVariantEntity
-  PurchaseOrderBundleItemEntity -->|"linked with"| ProductEntity
-
-  classDef controller fill:#55aaff,stroke:#004466,color:#fff
-  classDef service fill:#ffaa55,stroke:#664400,color:#000
-```
-
-### 3. Core Concepts and Responsibilities
-
-- **Bundle vs StandAlone Variants**: Variants of type `InventoryItemType.Bundle` represent bundles; others are standalone.
-- **Bundle Components**: Components link bundle variants (parents) to standalone variants (children) with quantities.
-- **Purchase Order Bundle Synchronization**: Bundles are reflected in purchase orders via `PurchaseOrderBundleItemEntity`.
-- **Bundle Status**: Bundles can have statuses such as `SetupComplete`, `SetupIncomplete`, `ErrorInUpdate`, and `SetupNotStarted` based on completeness and validity of component mappings.
-
-Ownership of this subsystem lies with the PIM team, with logs and error captures routed through the `Logger` instances in services and exceptions like `GenieException`.
-
-Non-functional requirements include:
-- **Performance**: Efficient SQL queries with joins, indexing to handle large product sets.
-- **Reliability**: Use of transactions and upserts to maintain consistent state.
-- **Scalability**: Supports bulk updates and paginated queries for large product catalogs.
-
-### 4. Code Structure
-
-- **Controllers**
-  - `apps/api/src/admin/controllers/bundles.controller.ts`
-    - Entry point for admin-level bundle operations, such as migrating team inventory to bundle items.
-
-- **Services**
-  - `apps/api/src/pim/services/products-mapping.service.ts`
-    - Core business logic for creating/deleting bundles and managing bundle components.
-    - Handles bundle retrieval with detailed component data and supports bulk CSV exports.
-  - `apps/api/src/purchase-order/services/po-bundles.service.ts`
-    - Manages synchronization of bundles within purchase orders.
-    - Converts item bundles to purchase order bundle items and removes orphaned bundle data.
-
-- **API Exports**
-  - `apps/web/src/api/resources/products-mapping/index.ts`
-    - Aggregates bundle-related API calls including add, remove, get bundle and bundle components operations.
-
-#### Key Files and Their Roles
-- [apps/api/src/pim/services/products-mapping.service.ts](apps/api/src/pim/services/products-mapping.service.ts): Implements main domain logic for bundles.
-- [apps/api/src/purchase-order/services/po-bundles.service.ts](apps/api/src/purchase-order/services/po-bundles.service.ts): Sync bundles with purchase order data.
-- [apps/api/src/admin/controllers/bundles.controller.ts](apps/api/src/admin/controllers/bundles.controller.ts): Admin API controller for bundle-related commands.
-
-#### Code Snippet: Creating Bundles
-```ts
-async createBundles(teamId: string, ids: string[]): Promise<void> {
-  await this.productVariantRepository.update(
-    { productId: In(ids), teamId },
-    { type: InventoryItemType.Bundle }
-  );
-
-  await this.poBundlesService.convertItemBundlesToPOBundleItems(teamId);
-}
-```
-This updates product variants to type `Bundle` for given product IDs and then synchronizes purchase order bundle items accordingly.
-
-### 5. API and Interfaces
-
-#### BundlesController
-- POST `/admin/bundles/migrate-all-teams-inventory-to-bundle-items`
-  - Migrates all active teams' inventory items identifying as bundles to purchase order bundle items.
-
-#### ProductsMappingService Public Methods
-- `createBundles(teamId: string, ids: string[])` - Marks specified products as bundles.
-- `deleteBundles(teamId: string, ids: string[])` - Removes bundles and reverts variants back to standalone.
-- `updateComponentsQuantities(teamId: string, componentQuantities)` - Batch update quantities of components within bundles.
-- `createBundleVariantsComponents(teamId: string, bundleVariantsComponents)` - Creates component mappings for bundle variants.
-- `deleteComponents(teamId: string, componentIds: string[])` - Deletes bundle components by IDs.
-- `getBundle(teamId: string, bundleId: string)` - Retrieves bundle details including variants and components.
-- `getBundlesByProducts(teamId: string, queryParams)` - Retrieves paginated bundles list with statuses and component products.
-- `getBundlesCsvMap(teamId: string)` - Exports component mapping data as CSV.
-
-#### Failure Modes
-- `getBundle` throws `GenieException` with code `BundleNotFound` if bundle ID does not exist or if the product is not a bundle.
-- Attempts to create components where parent is not a bundle or children are bundles raise `GenieException` with relevant error codes.
-
-### 6. Environment & Configuration
-
-No explicit environment variables or external config parameters were found specifically related to bundles management in the provided context.
-
-### 7. Testing, Monitoring, and Deployment
-
-No direct information about tests, logs, deployment, or monitoring specific to bundles was given in the current context. Logging uses NestJS `Logger` class for error and operation tracing within services.
-
-### 8. Troubleshooting & Known Issues
-
-- The `PoBundlesService` logs to Console if a purchase order item has an undefined product variant during conversion.
-- `ProductsMappingService` tracks invalid bundle relations and handles bundle component update failures with exception captures.
-- Bundles with no child components get reverted to standalone variants on relation removals.
-
-### References
-- `apps/api/src/pim/services/products-mapping.service.ts`
-- `apps/api/src/purchase-order/services/po-bundles.service.ts`
-- `apps/api/src/admin/controllers/bundles.controller.ts`
-- `apps/web/src/api/resources/products-mapping/index.ts`
-
----
-
-This documentation serves as the foundation for maintaining and extending bundles management within Genie's PIM system, facilitating understanding of core logic, integration points, and design decisions involved.