original/NetworkAccessManagement/code/API_definitions/README.md

# Network Access Management API Definitions

This directory contains the OpenAPI specifications for the Network Access Management API, organized into modular components for better maintainability and reusability.

## Overview

The API definitions have been restructured from a monolithic approach to a modular, component-based architecture. This allows for better code reuse, easier maintenance, and cleaner separation of concerns.

## Folder Structure

```

API_definitions/

├── README.md                                    # This file (authoring & process docs)

├── redocly.yaml                                 # Lint/bundle configuration (Redocly CLI)

├── network-access-management.yaml               # Source API spec with $ref references (committed on main)

├── common/

│   └── CAMARA_common.yaml                       # Shared CAMARA-style error responses

└── modules/                                     # Modular domain-focused component files

    ├── NAM_Common.yaml                          # Shared primitives (UUID, DateTime, ResourceAudit, securitySchemes)

    ├── AccessDetail.yaml                        # Discriminated access detail variants (Wi-Fi, Thread)

    ├── Capabilities.yaml                        # Device capability schemas

    ├── Policy.yaml                              # Trust Domain policy schemas (maxDevices, bandwidth, egress)

    ├── NetworkAccessDevices/                     # Network Access Device resource schemas

    ├── RebootRequests/                           # Reboot Request lifecycle schemas

    ├── Services/                                # Service and ServiceSite schemas

    └── TrustDomains/                            # Trust Domain & related capability schemas

```

## Architecture Rationale

### Why Multiple Files?

**Before:** Single monolithic OpenAPI file (`network-access-management.yaml`)
- ✅ Simple to understand initially
- ❌ Became very large (2000+ lines)
- ❌ Hard to maintain and review
- ❌ Schema duplication across different APIs
- ❌ Merge conflicts in collaborative development
- ❌ No reusability between different API specifications

**After:** Modular component-based structure
- ✅ Each file has a single, clear responsibility
- ✅ Reusable schemas can be shared across APIs
- ✅ Easier to review and maintain individual components
- ✅ Parallel development by different team members
- ✅ Clear separation of concerns
- ✅ Smaller, focused files

### Component Breakdown

| File | Purpose | Reusability |
|------|---------|-------------|
| `Common.yaml` | Base types (UUID, DateTime, ErrorInfo) | High - used across all APIs |
| `Policy.yaml` | Trust Domain governance policies | Medium - Trust Domain specific |
| `AccessDetail.yaml` | Network access configurations | Medium - Network-related APIs |
| `TrustDomains.yaml` | Core Trust Domain schemas | Low - Trust Domain specific |

## Bundling and Validation

### Key Constraint: Bundled Files Are Not Committed on Main

Per the [CAMARA Consumption and Bundling Design](https://github.com/camaraproject/Commonalities/blob/main/documentation/Commonalities-Consumption-and-Bundling-Design.md), **bundled (standalone) API definitions are never committed on `main`**. The committed `network-access-management.yaml` retains its `$ref` references to `common/` and `modules/`. Bundled standalone OAS files are produced only on release branches/tags and for local validation.

This avoids merge conflicts in the large bundled output and keeps `main` as the single source of truth for modular schema authoring.

Bundled output files (`*-bundled.yaml`) are listed in `.gitignore`.

### Prerequisites

Install Redocly CLI:
```bash

npm install -g @redocly/cli

```

### Linting

Validate the spec and all referenced modules resolve correctly:
```bash

cd code/API_definitions

redocly lint network-access-management.yaml

```

### Local Bundling (for Validation or Tooling)

To produce a fully resolved, standalone OAS file locally:
```bash

cd code/API_definitions

redocly bundle network-access-management.yaml --output network-access-management-bundled.yaml

```

The bundled file is useful for:
- Importing into API tools (Swagger UI, Postman, etc.)
- Validating the fully resolved spec with external validators
- Generating SDKs or documentation locally

**Do not commit `*-bundled.yaml` files to `main`.** They are git-ignored.



### Bundling Configuration



The `redocly.yaml` file contains:

- **Linting rules** - Ensures consistency and quality
- **File resolution** - Allows `.yaml` and `.yml` extensions

Key bundling features:
- Resolves all `$ref` references to external files
- Validates schema compatibility
- Generates self-contained OpenAPI specifications
- Preserves examples and documentation

## File Purposes

### API Specification

- **`network-access-management.yaml`** - Source API specification with `$ref` references to `common/` and `modules/`. This is the file committed on `main`. Bundling resolves these refs into a standalone OAS file for release branches and local tooling.

### Component Files

- **`common/CAMARA_common.yaml`** - Shared CAMARA-style error responses and common schemas

- **`modules/NAM_Common.yaml`** - Shared fundamental types (UUID, DateTime, ResourceAudit, securitySchemes)
- **`modules/Policy.yaml`** - Trust Domain policy schemas (maxDevices, bandwidth limits, egress rules)
- **`modules/AccessDetail.yaml`** - Network access configuration schemas (Wi-Fi, Thread, security modes)
- **`modules/Capabilities.yaml`** - Device capability schemas
- **`modules/TrustDomains/TrustDomains.yaml`** - Core Trust Domain schemas and examples
- **`modules/NetworkAccessDevices/NetworkAccessDevices.yaml`** - Network Access Device resource schemas
- **`modules/RebootRequests/RebootRequests.yaml`** - Reboot Request lifecycle schemas
- **`modules/Services/Services.yaml`** - Service schemas
- **`modules/Services/ServiceSites.yaml`** - Service Site schemas

## Best Practices

### When to Create New Component Files
- **High reusability** - Schemas used by multiple APIs
- **Logical grouping** - Related schemas that form a cohesive unit
- **Size management** - When a file exceeds ~500 lines

### Schema Design Guidelines
- Use `$ref` for external schema references
- Keep examples close to their schemas
- Use YAML anchors for internal reuse within files
- Document inheritance and discriminator patterns clearly

### Example Cross-Reference Limitations

**Important:** While schemas can be easily shared across files using `$ref`, examples have significant limitations in the distributed component model:

#### The Problem
```yaml

# ❌ This does NOT work - cannot use $ref inside example values

TrustDomainExample:

  summary: Trust Domain with Wi-Fi access

  value:

    name: "My Network"

    accessDetails:

      - $ref: "modules/AccessDetail.yaml#/components/examples/WiFiExample/value"  # Invalid!

```

#### The Solutions

**Option 1: Local Example Duplication (Recommended)**
```yaml

# ✅ Define examples locally where they're used

TrustDomainExample:

  summary: Trust Domain with Wi-Fi access

  value:

    name: "My Network"

    accessDetails:

      - accessType: "Wi-Fi"

        ssid: "my-network"

        securityMode:

          password: "my-password"

          securityModeType: "WPA2-Personal"

```

**Option 2: YAML Anchors (Within Same File Only)**
```yaml

# ✅ Use anchors for reuse within the same file

_wifi_example: &wifi-access

  accessType: "Wi-Fi"

  ssid: "my-network"

  securityMode:

    password: "my-password"

    securityModeType: "WPA2-Personal"



components:

  examples:

    TrustDomainExample:

      value:

        accessDetails:

          - *wifi-access  # Reuse within same file

```

**Option 3: Component-Level Example References**
```yaml

# ✅ Reference complete examples at component level (not within values)

WiFiAccessExample:

  $ref: "modules/AccessDetail.yaml#/components/examples/WiFiAccessDetailWPA2Personal"



# But you still can't compose these inside other example values

```