@venizia/ignis-docs 0.0.5 → 0.0.6-0

package/wiki/references/components/socket-io/usage.md

@@ -0,0 +1,322 @@
+# Socket.IO -- Usage & Examples
+
+> Server-side usage patterns, client helper setup, and advanced examples.
+
+## Server-Side Usage
+
+### Inject and Use in Services/Controllers
+
+Inject `SocketIOServerHelper` to interact with Socket.IO:
+
+```typescript
+import {
+  BaseService,
+  inject,
+  SocketIOBindingKeys,
+  SocketIOServerHelper,
+  CoreBindings,
+  BaseApplication,
+} from '@venizia/ignis';
+
+export class NotificationService extends BaseService {
+  // Lazy getter pattern -- helper is bound AFTER server starts
+  private _io: SocketIOServerHelper | null = null;
+
+  constructor(
+    @inject({ key: CoreBindings.APPLICATION_INSTANCE })
+    private application: BaseApplication,
+  ) {
+    super({ scope: NotificationService.name });
+  }
+
+  private get io(): SocketIOServerHelper {
+    if (!this._io) {
+      this._io = this.application.get<SocketIOServerHelper>({
+        key: SocketIOBindingKeys.SOCKET_IO_INSTANCE,
+        isOptional: true,
+      }) ?? null;
+    }
+
+    if (!this._io) {
+      throw new Error('SocketIO not initialized');
+    }
+
+    return this._io;
+  }
+
+  // Send to a specific client
+  notifyUser(opts: { userId: string; message: string }) {
+    this.io.send({
+      destination: opts.userId,
+      payload: {
+        topic: 'notification',
+        data: { message: opts.message, time: new Date().toISOString() },
+      },
+    });
+  }
+
+  // Send to a room
+  notifyRoom(opts: { room: string; message: string }) {
+    this.io.send({
+      destination: opts.room,
+      payload: {
+        topic: 'room:update',
+        data: { message: opts.message },
+      },
+    });
+  }
+
+  // Broadcast to all clients
+  broadcastAnnouncement(opts: { message: string }) {
+    this.io.send({
+      payload: {
+        topic: 'system:announcement',
+        data: { message: opts.message },
+      },
+    });
+  }
+}
+```
+
+> [!IMPORTANT]
+> **Lazy getter pattern**: Since `SocketIOServerHelper` is bound via a post-start hook, it's not available during DI construction. Use a lazy getter that resolves from the application container on first access.
+
+## Client Helper
+
+`SocketIOClientHelper` provides a managed Socket.IO client for connecting to Socket.IO servers -- useful for service-to-service communication, testing, or building relay services. It extends `BaseHelper` for scoped logging and wraps the `socket.io-client` library with authentication flow, lifecycle callbacks, and error-safe event subscription.
+
+### Client Setup
+
+```typescript
+import {
+  SocketIOClientHelper,
+} from '@venizia/ignis-helpers/socket-io';
+
+const client = new SocketIOClientHelper({
+  identifier: 'notification-relay',
+  host: 'http://localhost:3000',
+  options: {
+    path: '/io',
+    extraHeaders: {
+      authorization: 'Bearer <token>',
+    },
+  },
+
+  // Lifecycle callbacks (all optional)
+  onConnected: () => {
+    console.log('Connected to server');
+    client.authenticate();
+  },
+  onDisconnected: (reason) => {
+    console.log('Disconnected:', reason);
+  },
+  onError: (error) => {
+    console.error('Connection error:', error);
+  },
+  onAuthenticated: () => {
+    console.log('Authentication successful');
+  },
+  onUnauthenticated: (message) => {
+    console.warn('Authentication failed:', message);
+  },
+});
+```
+
+#### Constructor Behavior
+
+The constructor immediately calls `configure()`, which creates the `socket.io-client` `Socket` instance via `io(host, options)` and registers all internal event handlers (`connect`, `disconnect`, `connect_error`, `authenticated`, `unauthenticated`, `ping`). The socket is **not** connected until you call `client.connect()` (if using `autoConnect: false` in the options) or it connects automatically if `autoConnect` is not explicitly disabled.
+
+#### `connect` vs `connection` Event
+
+The client-side `socket.io-client` library fires the `connect` event (no "ion" suffix) when the connection is established. The server-side `socket.io` library fires `connection` (with the suffix). This is a Socket.IO convention, not an Ignis-specific behavior. The client helper registers on `'connect'` while the server helper registers on `SocketIOConstants.EVENT_CONNECT` which equals `'connection'`.
+
+### Authentication Flow
+
+After connecting, the client must emit `authenticate` to start the auth handshake. The server validates credentials from the socket handshake (headers, query params, `auth` object) and responds with either `authenticated` or `unauthenticated`.
+
+```typescript
+// Manual authentication after connection
+client.authenticate();
+```
+
+The `authenticate()` method has two guard conditions:
+1. The socket must be connected (`client.connected === true`)
+2. The current state must be `unauthorized` -- calling `authenticate()` while `authenticating` or already `authenticated` is a no-op with a warning log
+
+#### Authentication Failure Details
+
+The server sends two distinct error messages depending on how the `authenticateFn` fails:
+
+| Failure Mode | Message | Cause |
+|-------------|---------|-------|
+| `authenticateFn` returned `false` | `"Invalid token to authenticate! Please login again!"` | Credentials were checked but deemed invalid |
+| `authenticateFn` threw an error | `"Failed to authenticate connection! Please login again!"` | An unexpected error occurred during validation |
+
+Both failure paths set the client state back to `unauthorized`, emit the `unauthenticated` event to the client with the message, and then disconnect the socket after the message is delivered (via `setImmediate` callback).
+
+### Event Subscription
+
+Subscribe to custom events with automatic error safety. Handlers are wrapped in a dual try-catch that catches both synchronous throws and asynchronous rejections:
+
+```typescript
+// Subscribe to a single event
+client.subscribe({
+  event: 'chat:message',
+  handler: (data: { from: string; text: string }) => {
+    console.log(`${data.from}: ${data.text}`);
+  },
+});
+
+// Subscribe with duplicate detection disabled
+client.subscribe({
+  event: 'chat:message',
+  handler: (data) => { /* second handler */ },
+  ignoreDuplicate: false, // default: true -- set to false to allow multiple handlers
+});
+
+// Subscribe to multiple events at once
+client.subscribeMany({
+  events: {
+    'user:joined': (data) => console.log('User joined:', data),
+    'user:left': (data) => console.log('User left:', data),
+    'room:updated': (data) => console.log('Room updated:', data),
+  },
+});
+```
+
+#### Deduplication Behavior
+
+By default (`ignoreDuplicate: true`), `subscribe()` checks `socket.hasListeners(event)` before registering. If listeners already exist for the event, the call is a no-op and logs an info message. Set `ignoreDuplicate: false` to allow multiple handlers for the same event.
+
+### Unsubscribing
+
+```typescript
+// Remove all handlers for an event
+client.unsubscribe({ event: 'chat:message' });
+
+// Remove a specific handler
+client.unsubscribe({ event: 'chat:message', handler: myHandler });
+
+// Remove handlers for multiple events
+client.unsubscribeMany({ events: ['chat:message', 'user:joined', 'room:updated'] });
+```
+
+### Emitting Events
+
+```typescript
+client.emit({
+  topic: 'chat:send',
+  data: { text: 'Hello world' },
+  doLog: true,   // optional: log the emission
+  cb: () => {    // optional: callback via setImmediate after emit
+    console.log('Message sent');
+  },
+});
+```
+
+The `emit()` method throws if the socket is not connected or if no `topic` is provided. Unlike `send()` on the server helper, this method does **not** silently swallow errors.
+
+### Room Management
+
+```typescript
+// Request to join rooms (server validates via validateRoomFn)
+client.joinRooms({ rooms: ['chat-room-1', 'notifications'] });
+
+// Request to leave rooms
+client.leaveRooms({ rooms: ['chat-room-1'] });
+```
+
+Both methods emit Socket.IO events (`join` / `leave`) to the server. The actual join/leave happens server-side. If the socket is not connected, the call is a no-op with a warning log.
+
+### Connection Management
+
+```typescript
+// Manually connect (useful when autoConnect: false in options)
+client.connect();
+
+// Disconnect from server
+client.disconnect();
+
+// Check current state
+const state = client.getState(); // 'unauthorized' | 'authenticating' | 'authenticated'
+
+// Get raw socket.io-client Socket instance
+const rawSocket = client.getSocketClient();
+```
+
+### Shutdown
+
+```typescript
+// Clean shutdown: removes all listeners, disconnects, resets state
+client.shutdown();
+```
+
+The `shutdown()` method:
+1. Calls `removeAllListeners()` on the underlying socket to prevent memory leaks
+2. Disconnects if still connected
+3. Resets state to `unauthorized`
+
+## Advanced Usage
+
+### Complete Example
+
+A full working example is available at `examples/socket-io-test/`. It demonstrates:
+
+| Feature | Implementation |
+|---------|---------------|
+| Application setup | `src/application.ts` -- bindings, component registration, graceful shutdown |
+| REST endpoints | `src/controllers/socket-test.controller.ts` -- 9 endpoints for Socket.IO management |
+| Event handling | `src/services/socket-event.service.ts` -- chat, echo, room management |
+| Automated test client | `client.ts` -- 15+ test cases covering all features |
+
+#### REST API Endpoints
+
+The example provides a REST API for managing Socket.IO:
+
+| Method | Path | Description |
+|--------|------|-------------|
+| `GET` | `/socket/info` | Server status + connected client count |
+| `GET` | `/socket/clients` | List all connected client IDs |
+| `GET` | `/socket/health` | Health check (is SocketIO ready?) |
+| `POST` | `/socket/broadcast` | Broadcast <code v-pre>{{ topic, data }}</code> to all clients |
+| `POST` | `/socket/room/{roomId}/send` | Send <code v-pre>{{ topic, data }}</code> to a room |
+| `POST` | `/socket/client/{clientId}/send` | Send <code v-pre>{{ topic, data }}</code> to a specific client |
+| `POST` | `/socket/client/{clientId}/join` | Join client to <code v-pre>{{ rooms: string[] }}</code> |
+| `POST` | `/socket/client/{clientId}/leave` | Remove client from <code v-pre>{{ rooms: string[] }}</code> |
+| `GET` | `/socket/client/{clientId}/rooms` | List rooms a client belongs to |
+
+#### Running the Example
+
+```bash
+# Start the server
+cd examples/socket-io-test
+bun run server:dev
+
+# In another terminal -- run automated tests
+bun client.ts
+```
+
+The automated client tests the following features:
+
+- Authentication (valid and invalid tokens)
+- Ping/pong keepalive
+- Room join/leave with validation
+- Client-to-client messaging
+- Room broadcasting
+- Global broadcasting
+- REST API for Socket.IO management
+- Graceful disconnection
+
+Review the example code to understand production-ready patterns for:
+
+- Binding multiple handlers in a single `setupSocketIO()` method
+- Lazy getter pattern for accessing `SocketIOServerHelper` in services
+- Custom event registration via `CLIENT_CONNECTED_HANDLER`
+- Room validation logic preventing unauthorized room access
+- Graceful shutdown sequence in `application.stop()`
+
+## See Also
+
+- [Setup & Configuration](./) -- Quick reference, installation, bindings, constants
+- [API Reference](./api) -- Architecture, method signatures, internals, types
+- [Error Reference](./errors) -- Error conditions and troubleshooting

package/wiki/references/components/static-asset/api.md

@@ -0,0 +1,261 @@
+# Static Asset -- API Reference
+
+> Controller factory, storage interface, type definitions, and component internals.
+
+## Controller Factory
+
+The `AssetControllerFactory.defineAssetController()` method dynamically creates controller classes at runtime. For each storage backend in the options:
+
+1. A new class extending `BaseController` is created with `@controller({ path: basePath })`
+2. The class name is set dynamically via `Object.defineProperty(_controller, 'name', { value: name })`
+3. Routes are bound in the controller's `binding()` method using `this.bindRoute().to()`
+4. The controller is registered via `this.application.controller()`
+
+```
+StaticAssetComponent.binding()
+    | iterates options
+AssetControllerFactory.defineAssetController({ controller, storage, helper, ... })
+    | creates
+@controller({ path: basePath })
+class _controller extends BaseController { ... }
+    | registered via
+this.application.controller(_controller)
+```
+
+### IAssetControllerOptions
+
+The factory method accepts the following options:
+
+```typescript
+interface IAssetControllerOptions {
+  controller: {
+    name: string;
+    basePath: string;
+    isStrict?: boolean;   // Default: true
+  };
+  storage: TStaticAssetStorageType;
+  helper: IStorageHelper;
+  useMetaLink?: boolean;
+  metaLink?: TMetaLinkConfig;
+  options?: TStaticAssetExtraOptions;
+}
+```
+
+## StaticAssetStorageTypes
+
+A constants class following the Ignis pattern with `static readonly` fields, a `SCHEME_SET`, and an `isValid()` method:
+
+```typescript
+class StaticAssetStorageTypes {
+  static readonly DISK = 'disk';
+  static readonly MINIO = 'minio';
+
+  static readonly SCHEME_SET = new Set([this.DISK, this.MINIO]);
+
+  static isValid(orgType: string): boolean {
+    return this.SCHEME_SET.has(orgType);
+  }
+}
+
+type TStaticAssetStorageType = TConstValue<typeof StaticAssetStorageTypes>;
+// Resolves to: 'disk' | 'minio'
+```
+
+## MultipartBodySchema
+
+The Zod schema used to validate the upload request body:
+
+```typescript
+const MultipartBodySchema = z.object({
+  files: z.union([z.instanceof(File), z.array(z.instanceof(File))]).openapi({
+    type: 'array',
+    items: {
+      type: 'string',
+      format: 'binary',
+    },
+  }),
+});
+```
+
+This accepts either a single `File` or an array of `File` objects. The OpenAPI spec representation uses `type: 'array'` with `format: 'binary'` items for compatibility with Swagger/OpenAPI tooling.
+
+## Header Sanitization
+
+When streaming files (both inline and download), the controller forwards a specific set of whitelisted headers from the storage metadata to the response. All other metadata headers are dropped.
+
+### WHITELIST_HEADERS
+
+The exact list of forwarded headers:
+
+```typescript
+const WHITELIST_HEADERS = [
+  'content-type',
+  'content-encoding',
+  'cache-control',
+  'etag',
+  'last-modified',
+] as const;
+```
+
+These correspond to `HTTP.Headers.CONTENT_TYPE`, `HTTP.Headers.CONTENT_ENCODING`, `HTTP.Headers.CACHE_CONTROL`, `HTTP.Headers.ETAG`, and `HTTP.Headers.LAST_MODIFIED` from `@venizia/ignis-helpers`.
+
+All header values are sanitized by stripping `\r` and `\n` characters via `String(value).replace(/[\r\n]/g, '')` to prevent HTTP header injection attacks. If no `content-type` header is present in the storage metadata, the controller falls back to `application/octet-stream`.
+
+### HTTP Security Headers
+
+All file streaming responses include:
+
+```http
+X-Content-Type-Options: nosniff
+Content-Type: <from metadata or application/octet-stream>
+Content-Length: <file size in bytes>
+Content-Disposition: attachment; filename="..."  (download endpoint only)
+```
+
+Whitelisted metadata headers forwarded from storage: `content-type`, `content-encoding`, `cache-control`, `etag`, `last-modified`. All other metadata headers are dropped. Header values are sanitized (see [Header Sanitization](#header-sanitization)).
+
+## IStorageHelper Interface
+
+All storage helpers implement this unified interface:
+
+```typescript
+interface IStorageHelper {
+  isValidName(name: string): boolean;
+
+  // Bucket operations
+  isBucketExists(opts: { name: string }): Promise<boolean>;
+  getBuckets(): Promise<IBucketInfo[]>;
+  getBucket(opts: { name: string }): Promise<IBucketInfo | null>;
+  createBucket(opts: { name: string }): Promise<IBucketInfo | null>;
+  removeBucket(opts: { name: string }): Promise<boolean>;
+
+  // File operations
+  upload(opts: {
+    bucket: string;
+    files: IUploadFile[];
+    normalizeNameFn?: (opts: { originalName: string; folderPath?: string }) => string;
+    normalizeLinkFn?: (opts: { bucketName: string; normalizeName: string }) => string;
+  }): Promise<IUploadResult[]>;
+
+  getFile(opts: { bucket: string; name: string; options?: any }): Promise<Readable>;
+  getStat(opts: { bucket: string; name: string }): Promise<IFileStat>;
+  removeObject(opts: { bucket: string; name: string }): Promise<void>;
+  removeObjects(opts: { bucket: string; names: string[] }): Promise<void>;
+  listObjects(opts: IListObjectsOptions): Promise<IObjectInfo[]>;
+
+  // Utility
+  getFileType(opts: { mimeType: string }): string;
+}
+```
+
+### Supporting Types
+
+```typescript
+interface IUploadFile {
+  originalName: string;
+  mimetype: string;
+  buffer: Buffer;
+  size: number;
+  encoding?: string;
+  folderPath?: string;
+  [key: string | symbol]: any;
+}
+
+interface IUploadResult {
+  bucketName: string;
+  objectName: string;
+  link: string;
+  metaLink?: any;
+  metaLinkError?: any;
+}
+
+interface IFileStat {
+  size: number;
+  metadata: Record<string, any>;
+  lastModified?: Date;
+  etag?: string;
+  versionId?: string;
+}
+
+interface IBucketInfo {
+  name: string;
+  creationDate: Date;
+}
+
+interface IObjectInfo {
+  name?: string;
+  size?: number;
+  lastModified?: Date;
+  etag?: string;
+  prefix?: string;
+}
+
+interface IListObjectsOptions {
+  bucket: string;
+  prefix?: string;
+  useRecursive?: boolean;
+  maxKeys?: number;
+}
+```
+
+### Storage Helper Hierarchy
+
+```
+IStorageHelper (interface)
+    |
+BaseStorageHelper (abstract class)
+    |
+    +-- DiskHelper (local filesystem)
+    +-- MinioHelper (S3-compatible)
+```
+
+## MetaLink SQL Schema
+
+**Table:** `MetaLink`
+
+| Field | Type | Nullable | Default | Description |
+|-------|------|----------|---------|-------------|
+| `id` | TEXT | No | -- | Primary key (UUID) |
+| `created_at` | TIMESTAMP | No | `NOW()` | When record was created |
+| `modified_at` | TIMESTAMP | No | `NOW()` | When record was last updated |
+| `bucket_name` | TEXT | No | -- | Storage bucket name |
+| `object_name` | TEXT | No | -- | File object name |
+| `link` | TEXT | No | -- | Access URL to the file |
+| `mimetype` | TEXT | No | -- | File MIME type |
+| `size` | INTEGER | No | -- | File size in bytes |
+| `etag` | TEXT | Yes | -- | Entity tag for versioning |
+| `metadata` | JSONB | Yes | -- | Additional file metadata |
+| `storage_type` | TEXT | No | -- | Storage type (`'disk'` or `'minio'`) |
+| `is_synced` | BOOLEAN | No | `false` | Whether MetaLink is synchronized with storage |
+| `principal_type` | TEXT | Yes | -- | Type of the associated principal (e.g., `'user'`, `'service'`) |
+| `principal_id` | TEXT | Yes | -- | ID of the associated principal (always stored as string) |
+
+**Indexes:** `bucket_name`, `object_name`, `storage_type`, `is_synced`.
+
+> [!NOTE]
+> The `isSynced` field is automatically set to `true` when files are uploaded or synced via the meta-links endpoint. When a file is deleted, the MetaLink record is removed entirely. The `principalType` and `principalId` fields are only populated during upload when the corresponding query parameters are provided.
+
+### MetaLink Tracking
+
+When `useMetaLink: true`, the component:
+
+- **On upload:** Creates a MetaLink database record for each uploaded file after fetching file stats from storage. Stores `principalType` and `principalId` from query parameters (if provided). The `principalId` is always coerced to a string via `String()`. If MetaLink creation fails, the upload still succeeds and the response includes `metaLink: null` with a `metaLinkError` message.
+- **On delete:** Initiates MetaLink record deletion as fire-and-forget (the `.then()/.catch()` promise chain is not awaited). The HTTP response with `{ "success": true }` returns before the database deletion completes. Deletion errors are logged but do not fail the request.
+- **On sync (PUT meta-links):** Checks if a MetaLink exists for the object (matched by `bucketName` + `objectName`). Updates it if found, creates a new one if not. Always sets `isSynced: true`. Returns `{ success: true, metaLink: ... }`.
+
+## Component Lifecycle
+
+1. **`binding()`** -- Reads `STATIC_ASSET_COMPONENT_OPTIONS` from the DI container
+2. **Iterates each storage key** -- For each entry, calls `AssetControllerFactory.defineAssetController()`
+3. **Generates default `normalizeLinkFn`** -- If not provided, creates links in the format <code v-pre>{basePath}/buckets/{bucket}/objects/{encodedName}</code>
+4. **Registers controller** -- Calls `this.application.controller()` with the dynamically created class
+5. **Logs binding** -- Logs the storage key, type, and MetaLink status for each registered backend
+
+> [!TIP]
+> When MetaLink deletion fails on object delete, the error is logged but the HTTP response still returns `{ "success": true }`. Check your application logs if MetaLink records are not being cleaned up. Since the deletion is fire-and-forget, the response may return before the deletion attempt even starts.
+
+## See Also
+
+- [Setup & Configuration](./) - Quick Reference, Setup Steps, Configuration Options
+- [Usage & Examples](./usage) - API Endpoints and Frontend Integration
+- [Error Reference](./errors) - Name Validation and Troubleshooting

package/wiki/references/components/static-asset/errors.md

@@ -0,0 +1,89 @@
+# Static Asset -- Error Reference
+
+> Name validation rules and troubleshooting guide for common issues.
+
+## Name Validation
+
+All bucket and object names go through `helper.isValidName()` before any storage operation. The validation blocks:
+
+| Pattern | Example | Reason |
+|---------|---------|--------|
+| Path traversal | `../etc/passwd` | Contains `..`, `/`, or `\` |
+| Hidden files | `.hidden` | Starts with `.` |
+| Shell injection | `file;rm -rf /` | Contains `;`, `\|`, `&`, `$`, etc. |
+| Header injection | `file\ninjected` | Contains `\n`, `\r`, or `\0` |
+| Long names | 256+ chars | Exceeds 255 character limit |
+| Empty names | `""`, `"  "` | Empty or whitespace-only |
+
+Every endpoint that accepts `bucketName` validates it and returns HTTP 400 `"Invalid bucket name"` on failure. Every endpoint that accepts `objectName` validates it separately and returns HTTP 400 `"Invalid object name"` on failure.
+
+## Troubleshooting
+
+### "Invalid bucket/object name"
+
+**Cause:** The name fails `isValidName()` validation. Names cannot contain `..`, `/`, `\`, shell special characters, or start with `.`. Names must be <= 255 characters and non-empty.
+
+**Fix:** Ensure names follow these rules:
+- No path separators (`..`, `/`, `\`)
+- No leading dot (`.hidden`)
+- No shell special characters (`;`, `|`, `&`, `$`, `` ` ``, `<`, `>`, `(`, `)`, `{`, `}`, `[`, `]`, `!`, `#`)
+- No control characters (`\n`, `\r`, `\0`)
+- 255 characters or fewer
+- Not empty or whitespace-only
+
+> [!NOTE]
+> Every bucket-related endpoint (`GET`, `POST`, `DELETE` on `/buckets/:bucketName`) validates the bucket name and returns HTTP 400 with `"Invalid bucket name"` if validation fails. Object-related endpoints validate both bucket and object names.
+
+### "Controller not registering"
+
+**Cause:** Configuration key might be invalid or missing required fields.
+
+**Fix:** Ensure each storage configuration has all required fields:
+
+```typescript
+{
+  [uniqueKey]: {
+    controller: { name, basePath, isStrict },
+    storage: 'disk' | 'minio',
+    helper: IStorageHelper,
+    extra: {}
+  }
+}
+```
+
+### "Files not uploading (DiskHelper)"
+
+**Cause:** The `basePath` directory does not exist or the process lacks filesystem permissions.
+
+**Fix:** Ensure the `basePath` directory exists or can be created, and verify the process has read/write permissions to the target path.
+
+### "Files not uploading (MinioHelper)"
+
+**Cause:** MinIO server connectivity or authentication failure.
+
+**Fix:**
+- Verify MinIO server is running
+- Check credentials (`accessKey`, `secretKey`)
+- Verify network connectivity (`endPoint`, `port`)
+- Check if `useSSL` matches your server configuration
+
+### "Large file uploads failing"
+
+**Cause:** Memory-based multipart parsing cannot handle the file size.
+
+**Fix:** Switch to disk-based multipart parsing:
+
+```typescript
+extra: {
+  parseMultipartBody: {
+    storage: 'disk',
+    uploadDir: './uploads',
+  },
+}
+```
+
+## See Also
+
+- [Setup & Configuration](./) - Quick Reference, Setup Steps, Configuration Options
+- [Usage & Examples](./usage) - API Endpoints and Frontend Integration
+- [API Reference](./api) - Controller Factory, Storage Interface, MetaLink Schema