@onlineapps/service-wrapper 2.0.7 → 2.0.8

package/README.md

@@ -1,7 +1,18 @@
 # @onlineapps/service-wrapper
 
+**Main orchestration package for microservices - NO prefix as it's the primary integration point**
+
 Infrastructure wrapper that handles all workflow processing, message queue operations, and service registration for microservices.
 
+## Naming Convention
+
+This package uses `@onlineapps/service-wrapper` WITHOUT any connector prefix because:
+- It's the main orchestration layer, not a specific connector
+- All services depend on it directly
+- It aggregates all other connectors (base, infra, orch)
+
+Directory: `/shared/connector/conn-app-service-wrapper/` (historical, kept for backward compatibility)
+
 ## Purpose
 
 This package provides the infrastructure layer that sits between:

package/docs/API_STRUCTURE_STANDARD.md

@@ -0,0 +1,132 @@
+# API Structure Standard for Microservices
+
+## Endpoint Structure
+
+All microservices follow a simple, unversioned API structure.
+
+### URL Pattern
+
+```
+/                           # Service discovery
+/health                     # Health check
+/status                     # Service status
+/metrics                    # Prometheus metrics
+/specification              # Operations specification
+/api/{operation}            # Business operations
+```
+
+### Endpoint Categories
+
+- **System endpoints**: Health, status, metrics, specification
+- **Business endpoints** (`/api/*`): Application-specific operations
+
+## Standard Endpoints
+
+### Discovery Endpoint
+
+**GET /**
+```json
+{
+  "service": "service-name",
+  "version": "1.0.0",
+  "description": "Service description",
+  "specification": "/specification",
+  "health": "/health",
+  "status": "/status"
+}
+```
+
+### System Endpoints
+
+| Endpoint | Purpose | Response |
+|----------|---------|----------|
+| `GET /health` | Basic health check | `{"status": "healthy", "timestamp": "..."}` |
+| `GET /status` | Detailed service status | Service metrics and dependencies |
+| `GET /specification` | Operations specification | Operations JSON schema |
+| `GET /metrics` | Prometheus metrics | Metrics in Prometheus format |
+
+### Business Endpoints
+
+Service-specific operations under `/api/*`:
+- `POST /api/create-user`
+- `POST /api/process-order`
+- `GET /api/get-product`
+
+## Implementation Guide
+
+### Express.js Structure
+
+```javascript
+const express = require('express');
+const app = express();
+
+// Root endpoint - service discovery
+app.get('/', (req, res) => {
+  res.json({
+    service: process.env.SERVICE_NAME,
+    version: require('./package.json').version,
+    specification: '/specification',
+    health: '/health',
+    status: '/status'
+  });
+});
+
+// System endpoints
+app.get('/health', healthHandler);
+app.get('/status', statusHandler);
+app.get('/specification', specificationHandler);
+app.get('/metrics', metricsHandler);
+
+// Business endpoints under /api
+app.post('/api/create-user', createUserHandler);
+app.post('/api/process-order', processOrderHandler);
+app.get('/api/get-product', getProductHandler);
+```
+
+## Configuration Structure
+
+All service configurations are stored in `conn-config/` directory:
+
+```
+/your-service
+  /conn-config
+    /config.json        # Main configuration
+    /operations.json    # Operations specification
+    /middleware.json    # Middleware configuration
+```
+
+See [Configuration Guide](./CONFIGURATION_GUIDE.md) for details.
+
+## Migration Guide
+
+### From OpenAPI to Operations
+
+| Old | New | Purpose |
+|-----|-----|------|
+| `/api/v1/specification` | `/specification` | Operations schema |
+| `/v1/system/health` | `/health` | Health check |
+| `/v1/system/status` | `/status` | Service status |
+| `/v1/{operation}` | `/api/{operation}` | Business operations |
+
+### Simple Migration Steps
+
+1. Create `operations.json` from OpenAPI
+2. Remove version prefixes from endpoints
+3. Move business endpoints under `/api`
+4. Update service discovery response
+
+## Testing Requirements
+
+Tests must verify:
+
+1. **Discovery endpoint** returns service info and specification link
+2. **System endpoints** work correctly
+3. **Business endpoints** under `/api` process operations
+4. **Operations schema** is valid and complete
+
+## Benefits
+
+1. **Simplicity** - No version complexity
+2. **Clear structure** - System vs business separation
+3. **Direct mapping** - Operations to Cookbook steps
+4. **Lightweight** - Minimal configuration needed

package/docs/CONFIGURATION_GUIDE.md

@@ -0,0 +1,261 @@
+# Service Configuration Guide
+
+## Configuration Directory Structure
+
+Every service must have a `conn-config/` directory with these configuration files:
+
+```
+/service-root
+  /conn-config
+    config.json         # Main service configuration
+    operations.json     # Operations specification
+    middleware.json     # Middleware stack configuration
+```
+
+## Configuration Files
+
+### 1. config.json - Main Configuration
+
+Primary service configuration with environment overrides:
+
+```json
+{
+  "service": {
+    "name": "hello-service",
+    "version": "1.0.0",
+    "description": "Greeting service",
+    "environment": "${NODE_ENV:development}"
+  },
+  "server": {
+    "port": "${PORT:3000}",
+    "host": "${HOST:0.0.0.0}",
+    "timeout": 30000
+  },
+  "api": {
+    "versions": {
+      "available": ["v1"],
+      "current": "v1",
+      "deprecated": []
+    },
+    "rateLimit": {
+      "enabled": true,
+      "windowMs": 60000,
+      "max": 100
+    }
+  },
+  "monitoring": {
+    "healthCheck": {
+      "interval": 30000,
+      "timeout": 5000
+    },
+    "metrics": {
+      "enabled": "${METRICS_ENABLED:true}",
+      "port": "${METRICS_PORT:9090}"
+    }
+  },
+  "dependencies": {
+    "rabbitmq": {
+      "url": "${RABBITMQ_URL:amqp://localhost:5672}",
+      "enabled": "${MQ_ENABLED:true}"
+    },
+    "redis": {
+      "url": "${REDIS_URL:redis://localhost:6379}",
+      "enabled": "${CACHE_ENABLED:false}"
+    }
+  }
+}
+```
+
+### 2. operations.json - Service Operations
+
+Defines all operations the service provides:
+
+```json
+{
+  "operations": {
+    "create-greeting": {
+      "description": "Generate a greeting message",
+      "handler": "handlers.greetings.create",
+      "endpoint": "/api/create-greeting",
+      "method": "POST",
+      "input": {
+        "name": {
+          "type": "string",
+          "required": true,
+          "description": "Name to greet"
+        }
+      },
+      "output": {
+        "message": {
+          "type": "string",
+          "description": "Generated greeting"
+        },
+        "timestamp": {
+          "type": "datetime"
+        }
+      }
+    }
+  }
+}
+```
+
+### 3. middleware.json - Middleware Configuration
+
+Middleware stack and configuration:
+
+```json
+{
+  "global": [
+    {
+      "name": "cors",
+      "enabled": true,
+      "config": {
+        "origin": "${CORS_ORIGIN:*}",
+        "credentials": true
+      }
+    },
+    {
+      "name": "helmet",
+      "enabled": true,
+      "config": {}
+    },
+    {
+      "name": "requestLogger",
+      "enabled": true,
+      "config": {
+        "level": "info"
+      }
+    },
+    {
+      "name": "bodyParser",
+      "enabled": true,
+      "config": {
+        "limit": "10mb"
+      }
+    }
+  ],
+  "routes": {
+    "authenticate": {
+      "handler": "middleware/auth.authenticate",
+      "config": {
+        "required": true
+      }
+    },
+    "authorize": {
+      "handler": "middleware/auth.authorize",
+      "config": {
+        "roles": ["admin", "user"]
+      }
+    },
+    "validate": {
+      "handler": "middleware/validation.validate"
+    },
+    "rateLimit": {
+      "handler": "middleware/rateLimit",
+      "config": {
+        "max": 100,
+        "windowMs": 60000
+      }
+    }
+  },
+  "error": [
+    {
+      "name": "notFound",
+      "handler": "middleware/errors.notFound"
+    },
+    {
+      "name": "errorHandler",
+      "handler": "middleware/errors.handler"
+    }
+  ]
+}
+```
+
+
+## Environment Variables
+
+Configuration supports environment variable substitution:
+
+- Format: `${VARIABLE_NAME:default_value}`
+- Example: `${PORT:3000}` uses PORT env var or defaults to 3000
+
+### Standard Environment Variables
+
+| Variable | Purpose | Default |
+|----------|---------|---------|
+| `NODE_ENV` | Environment (development/production) | development |
+| `SERVICE_NAME` | Service name | From config.json |
+| `PORT` | Server port | 3000 |
+| `LOG_LEVEL` | Logging level | info |
+| `RABBITMQ_URL` | RabbitMQ connection | amqp://localhost:5672 |
+| `REDIS_URL` | Redis connection | redis://localhost:6379 |
+| `METRICS_ENABLED` | Enable metrics | true |
+
+## Loading Configuration
+
+Service wrapper automatically loads configuration:
+
+```javascript
+const ServiceWrapper = require('@onlineapps/service-wrapper');
+
+// Automatically loads from ./conn-config/
+const wrapper = new ServiceWrapper();
+
+// Or specify custom path
+const wrapper = new ServiceWrapper({
+  configPath: './custom-config/'
+});
+
+// Access configuration
+const config = wrapper.config;
+console.log(config.service.name);
+```
+
+## Validation
+
+Configuration is validated on startup:
+
+1. Required files exist
+2. JSON syntax is valid
+3. Required fields are present
+4. Environment variables are resolved
+5. Operations schema is valid
+
+## Best Practices
+
+1. **Keep sensitive data in environment variables** - Never commit secrets
+2. **Use defaults** - Provide sensible defaults for all configs
+3. **Document all options** - Include descriptions in configs
+4. **Validate early** - Fail fast on invalid configuration
+5. **Version your configs** - Track configuration changes
+
+## Service Configuration Example
+
+### config.json with Execution Mode
+```json
+{
+  "service": {
+    "name": "hello-service",
+    "version": "1.0.0",
+    "execution": {
+      "mode": "${EXECUTION_MODE:direct}",
+      "direct": {
+        "handler": "./src/handlers"
+      },
+      "http": {
+        "baseUrl": "${SERVICE_URL:http://localhost:3000}"
+      }
+    }
+  },
+  "monitoring": {
+    "healthCheck": {
+      "interval": 30000
+    }
+  }
+}
+```
+
+### Execution Modes
+
+- **direct**: Service Wrapper calls handlers directly (50% memory savings)
+- **http**: Service Wrapper makes HTTP calls (for external services)

package/docs/OPERATIONS_SCHEMA.md

@@ -0,0 +1,363 @@
+# Operations Schema Specification
+
+## Overview
+
+The Operations Schema replaces OpenAPI for internal microservices, providing a simpler, more focused specification for service operations that map directly to Cookbook workflow steps.
+
+## Why Operations Schema?
+
+- **Simpler than OpenAPI** - Only what's needed for workflow orchestration
+- **Direct Cookbook mapping** - Operations correspond 1:1 with workflow steps
+- **Flexible execution** - Supports both direct function calls and HTTP
+- **Extensible** - Easy to add support for external APIs (REST, GraphQL, gRPC)
+
+## File Location
+
+Operations are defined in `/conn-config/operations.json` for each service.
+
+## Schema Structure
+
+### Basic Operation (Internal Service)
+
+```json
+{
+  "operations": {
+    "operation-name": {
+      "description": "Human-readable description",
+      "handler": "path.to.handler.function",
+      "endpoint": "/api/operation-name",
+      "method": "POST",
+      "input": {
+        "field1": {
+          "type": "string",
+          "required": true,
+          "description": "Field description"
+        },
+        "field2": {
+          "type": "number",
+          "default": 0
+        }
+      },
+      "output": {
+        "result": {
+          "type": "string",
+          "description": "Result description"
+        },
+        "timestamp": {
+          "type": "datetime"
+        }
+      }
+    }
+  }
+}
+```
+
+### External REST API Operation
+
+```json
+{
+  "operations": {
+    "send-email": {
+      "description": "Send email via SendGrid",
+      "handler": "handlers.email.send",
+      "external": {
+        "type": "rest",
+        "endpoint": "https://api.sendgrid.com/v3/mail/send",
+        "method": "POST",
+        "headers": {
+          "Authorization": "Bearer ${SENDGRID_API_KEY}",
+          "Content-Type": "application/json"
+        },
+        "mapping": {
+          "input": {
+            "personalizations[0].to[0].email": "$.recipient",
+            "from.email": "${SENDER_EMAIL}",
+            "subject": "$.subject",
+            "content[0].value": "$.body"
+          },
+          "output": {
+            "messageId": "$.x-message-id",
+            "status": "$.status"
+          }
+        }
+      },
+      "input": {
+        "recipient": { "type": "string", "required": true },
+        "subject": { "type": "string", "required": true },
+        "body": { "type": "string", "required": true }
+      },
+      "output": {
+        "messageId": "string",
+        "status": "string"
+      }
+    }
+  }
+}
+```
+
+### GraphQL Operation
+
+```json
+{
+  "operations": {
+    "get-user-repos": {
+      "description": "Get user repositories from GitHub",
+      "external": {
+        "type": "graphql",
+        "endpoint": "https://api.github.com/graphql",
+        "headers": {
+          "Authorization": "Bearer ${GITHUB_TOKEN}"
+        },
+        "query": "query($login: String!) { user(login: $login) { repositories(first: 10) { nodes { name, description } } } }",
+        "variables": {
+          "login": "$.username"
+        },
+        "mapping": {
+          "output": {
+            "repositories": "$.data.user.repositories.nodes"
+          }
+        }
+      },
+      "input": {
+        "username": { "type": "string", "required": true }
+      },
+      "output": {
+        "repositories": { "type": "array" }
+      }
+    }
+  }
+}
+```
+
+## Field Types
+
+Supported types for input/output fields:
+
+- `string` - Text data
+- `number` - Numeric value (integer or float)
+- `boolean` - True/false
+- `object` - Nested object structure
+- `array` - Array of items
+- `datetime` - ISO 8601 datetime string
+- `date` - ISO 8601 date string
+- `email` - Email address (validated)
+- `url` - URL (validated)
+- `uuid` - UUID v4 (validated)
+
+## Execution Modes
+
+Services can run in different execution modes, configured in `config.json`:
+
+### Direct Mode (Internal Services)
+```json
+{
+  "service": {
+    "execution": {
+      "mode": "direct",
+      "handler": "./src/handlers"
+    }
+  }
+}
+```
+- Service Wrapper calls handlers directly
+- No HTTP overhead
+- 50% memory savings
+- Single process
+
+### HTTP Mode (Default/External)
+```json
+{
+  "service": {
+    "execution": {
+      "mode": "http",
+      "baseUrl": "${SERVICE_URL:http://localhost:3000}"
+    }
+  }
+}
+```
+- Service Wrapper makes HTTP calls
+- Service runs separately
+- Better for testing
+- Required for external APIs
+
+## Cookbook Integration
+
+Operations map directly to Cookbook workflow steps:
+
+### Cookbook Step
+```json
+{
+  "step_id": "greet_user",
+  "type": "service_call",
+  "service": "hello-service",
+  "operation": "good-day",
+  "input": {
+    "name": "$.user_name"
+  }
+}
+```
+
+### Corresponding Operation
+```json
+{
+  "operations": {
+    "good-day": {
+      "description": "Generate good day greeting",
+      "handler": "handlers.greetings.goodDay",
+      "endpoint": "/api/good-day",
+      "input": {
+        "name": { "type": "string", "required": true }
+      },
+      "output": {
+        "message": "string",
+        "timestamp": "datetime"
+      }
+    }
+  }
+}
+```
+
+## Handler Implementation
+
+### Direct Mode Handler
+```javascript
+// handlers/greetings.js
+exports.goodDay = async (input) => {
+  const { name } = input;
+  return {
+    message: `Good day, ${name}!`,
+    timestamp: new Date().toISOString()
+  };
+};
+```
+
+### HTTP Mode Endpoint
+```javascript
+// src/app.js
+app.post('/api/good-day', async (req, res) => {
+  const { name } = req.body;
+  res.json({
+    message: `Good day, ${name}!`,
+    timestamp: new Date().toISOString()
+  });
+});
+```
+
+## Validation
+
+Input/output validation is automatic based on the schema:
+
+```javascript
+// Service Wrapper validates automatically
+const operation = operations['good-day'];
+validateInput(input, operation.input);  // Throws if invalid
+const result = await executeOperation(operation, input);
+validateOutput(result, operation.output);  // Throws if invalid
+```
+
+## Migration from OpenAPI
+
+### Before (OpenAPI)
+```yaml
+paths:
+  /v1/good-day:
+    post:
+      operationId: createGoodDay
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/GreetingRequest'
+      responses:
+        '200':
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/GreetingResponse'
+```
+
+### After (Operations Schema)
+```json
+{
+  "operations": {
+    "good-day": {
+      "handler": "handlers.greetings.goodDay",
+      "endpoint": "/api/good-day",
+      "input": {
+        "name": { "type": "string", "required": true }
+      },
+      "output": {
+        "message": "string",
+        "timestamp": "datetime"
+      }
+    }
+  }
+}
+```
+
+## Best Practices
+
+1. **Keep operations focused** - One operation = one business action
+2. **Use descriptive names** - Operation names should be self-explanatory
+3. **Document fields** - Add descriptions to complex fields
+4. **Validate strictly** - Mark required fields appropriately
+5. **Handle errors gracefully** - Define error responses in output
+6. **Use environment variables** - For URLs, keys, and configuration
+7. **Test both modes** - Ensure operations work in both direct and HTTP mode
+
+## Service Wrapper Integration
+
+The Service Wrapper automatically:
+- Loads operations.json on startup
+- Routes Cookbook steps to operations
+- Validates input/output
+- Handles execution mode (direct/HTTP)
+- Manages external API calls
+- Provides metrics and logging
+
+## Example Service Structure
+
+```
+hello-service/
+├── conn-config/
+│   ├── config.json        # Service configuration
+│   ├── operations.json    # Operations schema
+│   └── middleware.json    # Middleware config
+├── src/
+│   ├── app.js            # Express app (for HTTP mode)
+│   └── handlers/         # Handler functions (for direct mode)
+│       └── greetings.js
+└── package.json
+```
+
+## Testing Operations
+
+```javascript
+// Test operation directly
+const operations = require('./conn-config/operations.json');
+const handlers = require('./src/handlers');
+
+test('good-day operation', async () => {
+  const input = { name: 'World' };
+  const result = await handlers.greetings.goodDay(input);
+
+  expect(result.message).toBe('Good day, World!');
+  expect(result.timestamp).toBeDefined();
+});
+```
+
+## Future Extensions
+
+The schema is designed to be extensible:
+
+- **WebSocket operations** - Real-time communication
+- **Message queue operations** - Direct MQ publishing
+- **Database operations** - Direct DB queries
+- **File operations** - S3, MinIO uploads
+- **Batch operations** - Bulk processing
+
+Each extension follows the same pattern:
+1. Define operation in operations.json
+2. Specify type in `external` block
+3. Map inputs/outputs
+4. Service Wrapper handles execution

package/docs/SERVICE_TESTING_STANDARD.md

@@ -0,0 +1,389 @@
+# Service Testing Standard and OpenAPI Generation
+
+## 1. OpenAPI Schema Generation
+
+### Step 1: Analyze Your Service Endpoints
+
+List all your service endpoints and their:
+- HTTP methods (GET, POST, PUT, DELETE)
+- Request parameters (query, path, body)
+- Response structures
+- Error responses
+
+### Step 2: Create openapi.yaml
+
+Create `openapi.yaml` in your service root directory with this structure:
+
+```yaml
+openapi: 3.0.0
+info:
+  title: # Your service name from package.json
+  version: # Your service version from package.json
+  description: # Brief description of what your service does
+
+servers:
+  - url: http://localhost:{your-port}
+    description: Local development
+  - url: http://{container-name}:3000
+    description: Docker container
+
+paths:
+  # Document each endpoint
+  /your-endpoint:
+    get/post/put/delete:
+      summary: # One line description
+      operationId: # Unique identifier (e.g., getUsers, createOrder)
+      parameters: # If applicable
+      requestBody: # If applicable
+      responses:
+        '200':
+          description: # Success response
+          content:
+            application/json:
+              schema:
+                # Define or reference schema
+        '400':
+          # Bad request
+        '500':
+          # Server error
+
+components:
+  schemas:
+    # Define reusable schemas here
+```
+
+### Step 3: Generate Schema from Code (Alternative)
+
+If you have many endpoints, generate initial schema:
+
+```bash
+# Install openapi generator
+npm install --save-dev @apidevtools/swagger-cli
+
+# For Express apps, use express-openapi-generator
+npm install --save-dev express-openapi-generator
+
+# Add generation script to package.json
+"scripts": {
+  "generate:openapi": "node scripts/generate-openapi.js"
+}
+```
+
+Create `scripts/generate-openapi.js`:
+```javascript
+const app = require('../src/app');
+const generator = require('express-openapi-generator');
+
+generator(app, {
+  outputFile: './openapi.yaml',
+  info: {
+    title: process.env.SERVICE_NAME,
+    version: require('../package.json').version
+  }
+});
+```
+
+### Step 4: Validate Your Schema
+
+```bash
+# Install validator
+npm install --save-dev @apidevtools/swagger-parser
+
+# Add validation script
+"scripts": {
+  "validate:openapi": "swagger-cli validate openapi.yaml"
+}
+```
+
+## 2. Test Structure
+
+### Directory Structure
+
+```
+/your-service
+  /test
+    /unit          # Unit tests for individual functions
+    /integration   # Integration tests with mocked dependencies
+    /api           # API endpoint tests
+    /compliance    # OpenAPI compliance tests
+    test.config.js # Shared test configuration
+```
+
+### Test Configuration
+
+Create `test/test.config.js`:
+```javascript
+module.exports = {
+  // Service configuration for tests
+  service: {
+    name: process.env.SERVICE_NAME || 'your-service',
+    port: process.env.PORT || 3000,
+    baseUrl: `http://localhost:${process.env.PORT || 3000}`
+  },
+
+  // Timeouts
+  timeouts: {
+    unit: 5000,
+    integration: 10000,
+    api: 15000
+  },
+
+  // Mock data
+  mocks: {
+    validRequest: { /* valid request data */ },
+    invalidRequest: { /* invalid request data */ }
+  }
+};
+```
+
+## 3. Test Implementation
+
+### Unit Tests (`test/unit/`)
+
+Test individual functions without external dependencies:
+
+```javascript
+describe('Business Logic', () => {
+  test('should process valid input', () => {
+    const result = processFunction(validInput);
+    expect(result).toBeDefined();
+    expect(result.status).toBe('success');
+  });
+
+  test('should handle invalid input', () => {
+    expect(() => processFunction(invalidInput)).toThrow();
+  });
+});
+```
+
+### API Tests (`test/api/`)
+
+Test actual HTTP endpoints:
+
+```javascript
+const request = require('supertest');
+const app = require('../../src/app');
+
+describe('API Endpoints', () => {
+  describe('GET /your-endpoint', () => {
+    test('should return 200 with valid response', async () => {
+      const response = await request(app)
+        .get('/your-endpoint')
+        .expect(200);
+
+      expect(response.body).toHaveProperty('expectedField');
+    });
+
+    test('should return 400 for invalid request', async () => {
+      const response = await request(app)
+        .get('/your-endpoint?invalid=true')
+        .expect(400);
+
+      expect(response.body).toHaveProperty('error');
+    });
+  });
+});
+```
+
+### Compliance Tests (`test/compliance/`)
+
+Test OpenAPI compliance:
+
+```javascript
+const SwaggerParser = require('@apidevtools/swagger-parser');
+const request = require('supertest');
+const app = require('../../src/app');
+const openApiSchema = require('../../openapi.yaml');
+
+describe('OpenAPI Compliance', () => {
+  let api;
+
+  beforeAll(async () => {
+    // Validate and parse schema
+    api = await SwaggerParser.validate(openApiSchema);
+  });
+
+  test('schema should be valid OpenAPI 3.0', () => {
+    expect(api.openapi).toBe('3.0.0');
+  });
+
+  test('all endpoints should match schema', async () => {
+    for (const [path, methods] of Object.entries(api.paths)) {
+      for (const [method, spec] of Object.entries(methods)) {
+        if (['get', 'post', 'put', 'delete'].includes(method)) {
+          const response = await request(app)[method](path);
+          // Validate response matches schema
+          expect(response.status).toBeDefined();
+        }
+      }
+    }
+  });
+});
+```
+
+## 4. NPM Scripts
+
+Add to `package.json`:
+
+```json
+{
+  "scripts": {
+    "test": "npm run test:unit && npm run test:api && npm run test:compliance",
+    "test:unit": "jest test/unit",
+    "test:integration": "jest test/integration",
+    "test:api": "jest test/api",
+    "test:compliance": "jest test/compliance",
+    "test:coverage": "jest --coverage",
+    "validate:openapi": "swagger-cli validate openapi.yaml",
+    "generate:openapi": "node scripts/generate-openapi.js",
+    "serve:docs": "swagger-ui-express openapi.yaml"
+  }
+}
+```
+
+### Coverage Requirements
+
+**Minimum recommended coverage: 80%**
+
+Configure Jest coverage thresholds in `package.json`:
+
+```json
+{
+  "jest": {
+    "coverageThreshold": {
+      "global": {
+        "branches": 80,
+        "functions": 80,
+        "lines": 80,
+        "statements": 80
+      }
+    },
+    "collectCoverageFrom": [
+      "src/**/*.js",
+      "!src/**/*.test.js",
+      "!src/**/*.spec.js"
+    ]
+  }
+}
+```
+
+## 5. Service Wrapper Integration
+
+### Endpoint for OpenAPI Schema
+
+Your service must expose its schema:
+
+```javascript
+// In your app.js or routes
+const fs = require('fs');
+const yaml = require('js-yaml');
+
+app.get('/openapi', (req, res) => {
+  try {
+    const doc = yaml.load(fs.readFileSync('./openapi.yaml', 'utf8'));
+    res.json(doc);
+  } catch (e) {
+    res.status(500).json({ error: 'Schema not available' });
+  }
+});
+```
+
+### Validation Middleware
+
+Use Service Wrapper's validation:
+
+```javascript
+const { validateRequest } = require('@onlineapps/service-wrapper/middleware');
+const openApiSchema = require('./openapi.yaml');
+
+// Apply validation to routes
+app.post('/your-endpoint',
+  validateRequest(openApiSchema, '/your-endpoint', 'post'),
+  (req, res) => {
+    // Request is already validated
+  }
+);
+```
+
+## 6. Continuous Validation
+
+### Pre-commit Hook
+
+`.husky/pre-commit`:
+```bash
+#!/bin/sh
+npm run validate:openapi
+npm run test:compliance
+```
+
+### CI/CD Pipeline
+
+```yaml
+# .github/workflows/test.yml or gitlab-ci.yml
+test:
+  script:
+    - npm install
+    - npm run validate:openapi
+    - npm run test
+    - npm run test:coverage
+  coverage: '/Lines\s*:\s*(\d+\.\d+)%/'
+```
+
+## 7. Validation Checklist
+
+Before deployment, ensure:
+
+- [ ] OpenAPI schema exists at `/openapi.yaml`
+- [ ] Schema validates with `swagger-cli validate`
+- [ ] All endpoints documented in schema
+- [ ] Request/response schemas defined
+- [ ] Error responses documented
+- [ ] Schema version matches package.json
+- [ ] `/openapi` endpoint returns schema
+- [ ] Unit tests pass (>80% coverage)
+- [ ] API tests pass
+- [ ] Compliance tests pass
+- [ ] Service Wrapper can load schema
+- [ ] Validation middleware works
+
+## 8. Common Issues and Solutions
+
+### Issue: Schema doesn't match implementation
+**Solution**: Generate schema from code first, then refine manually
+
+### Issue: Validation too strict
+**Solution**: Use `additionalProperties: true` in schemas during development
+
+### Issue: Complex nested objects
+**Solution**: Break into components and use `$ref`
+
+### Issue: Different environments need different configs
+**Solution**: Use environment variables in schema:
+```yaml
+servers:
+  - url: ${API_BASE_URL}
+    description: Configured base URL
+```
+
+## 9. Testing with conn-e2e-testing
+
+The connector testing framework will:
+1. Load your OpenAPI schema
+2. Start your service
+3. Test each endpoint against schema
+4. Validate requests and responses
+5. Generate compliance report
+
+Ensure your service is ready by:
+1. Exposing `/openapi` endpoint
+2. Having all endpoints documented
+3. Returning proper HTTP status codes
+4. Using consistent error format
+
+## 10. Resources
+
+- [OpenAPI 3.0 Specification](https://swagger.io/specification/)
+- [JSON Schema Validation](https://json-schema.org/draft/2019-09/json-schema-validation.html)
+- [swagger-cli Documentation](https://apitools.dev/swagger-cli/)
+- Service Wrapper documentation: `/shared/connector/service-wrapper/README.md`
+- Testing examples: `/shared/connector/conn-e2e-testing/examples/`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/service-wrapper",
-  "version": "2.0.7",
+  "version": "2.0.8",
   "description": "Thin orchestration layer for microservices - delegates all infrastructure concerns to specialized connectors",
   "main": "src/index.js",
   "scripts": {
@@ -25,13 +25,14 @@
   "license": "MIT",
   "dependencies": {
     "@onlineapps/conn-base-cache": "^1.0.0",
-    "@onlineapps/conn-base-logger": "^1.0.0",
+    "@onlineapps/conn-base-monitoring": "file:../conn-base-monitoring/onlineapps-conn-base-monitoring-1.0.0.tgz",
     "@onlineapps/conn-infra-error-handler": "^1.0.0",
     "@onlineapps/conn-infra-mq": "^1.1.0",
     "@onlineapps/conn-orch-api-mapper": "^1.0.0",
     "@onlineapps/conn-orch-cookbook": "^2.0.0",
     "@onlineapps/conn-orch-orchestrator": "^1.0.1",
-    "@onlineapps/conn-orch-registry": "^1.1.4"
+    "@onlineapps/conn-orch-registry": "^1.1.4",
+    "@onlineapps/monitoring-core": "file:../../../api/shared/monitoring-core/onlineapps-monitoring-core-1.0.0.tgz"
   },
   "devDependencies": {
     "express": "^5.1.0",

package/src/ServiceWrapper.js

@@ -13,7 +13,7 @@
 // Import connectors
 const MQConnector = require('@onlineapps/conn-infra-mq');
 const RegistryConnector = require('@onlineapps/conn-orch-registry');
-const LoggerConnector = require('@onlineapps/conn-base-logger');
+const MonitoringConnector = require('@onlineapps/conn-base-monitoring');
 const OrchestratorConnector = require('@onlineapps/conn-orch-orchestrator');
 const ApiMapperConnector = require('@onlineapps/conn-orch-api-mapper');
 const CookbookConnector = require('@onlineapps/conn-orch-cookbook');
@@ -69,7 +69,8 @@ class ServiceWrapper {
     this.config = options.config || {};
 
     // Initialize connectors
-    this.logger = new LoggerConnector({ serviceName: this.serviceName });
+    this.logger = MonitoringConnector; // Singleton, will be initialized later
+    this.monitoring = MonitoringConnector; // Also expose as monitoring for clarity
     this.mqClient = null;
     this.registryClient = null;
     this.orchestrator = null;
@@ -109,11 +110,14 @@ class ServiceWrapper {
    */
   async start() {
     if (this.isRunning) {
-      this.logger.warn('Service wrapper already running');
+      console.warn('Service wrapper already running');
       return;
     }
 
     try {
+      // Initialize monitoring first
+      await this.monitoring.init({ serviceName: this.serviceName });
+
       this.logger.info(`Starting service wrapper for ${this.serviceName}`);
 
       // 1. Initialize infrastructure connectors

package/test/monitoring-integration.test.js

@@ -0,0 +1,150 @@
+/**
+ * Test monitoring integration in service-wrapper
+ */
+
+describe('ServiceWrapper Monitoring Integration', () => {
+  let ServiceWrapper;
+  let express;
+
+  beforeEach(() => {
+    // Reset modules
+    jest.resetModules();
+
+    // Mock dependencies
+    jest.mock('@onlineapps/conn-infra-mq', () => {
+      return jest.fn().mockImplementation(() => ({
+        connect: jest.fn().mockResolvedValue(true),
+        disconnect: jest.fn().mockResolvedValue(true),
+        consume: jest.fn().mockResolvedValue(true),
+        isConnected: jest.fn().mockReturnValue(true)
+      }));
+    });
+
+    jest.mock('@onlineapps/conn-orch-registry', () => ({
+      ServiceRegistryClient: jest.fn().mockImplementation(() => ({
+        register: jest.fn().mockResolvedValue(true),
+        unregister: jest.fn().mockResolvedValue(true),
+        sendHeartbeat: jest.fn().mockResolvedValue(true),
+        isConnected: jest.fn().mockReturnValue(true)
+      }))
+    }));
+
+    jest.mock('@onlineapps/conn-base-monitoring', () => ({
+      init: jest.fn().mockResolvedValue({
+        info: jest.fn(),
+        warn: jest.fn(),
+        error: jest.fn(),
+        debug: jest.fn()
+      }),
+      info: jest.fn(),
+      warn: jest.fn(),
+      error: jest.fn(),
+      debug: jest.fn()
+    }));
+
+    jest.mock('@onlineapps/conn-orch-orchestrator', () => ({
+      create: jest.fn().mockReturnValue({
+        processWorkflowMessage: jest.fn().mockResolvedValue({ success: true })
+      })
+    }));
+
+    jest.mock('@onlineapps/conn-orch-api-mapper', () => ({
+      create: jest.fn().mockReturnValue({})
+    }));
+
+    jest.mock('@onlineapps/conn-orch-cookbook', () => ({}));
+    jest.mock('@onlineapps/conn-base-cache', () => jest.fn());
+    jest.mock('@onlineapps/conn-infra-error-handler', () => jest.fn());
+
+    ServiceWrapper = require('../src/ServiceWrapper');
+    express = require('express');
+  });
+
+  test('should initialize monitoring on start', async () => {
+    const app = express();
+    const monitoring = require('@onlineapps/conn-base-monitoring');
+
+    const wrapper = new ServiceWrapper({
+      service: app,
+      serviceName: 'test-service',
+      openApiSpec: { info: { version: '1.0.0' } },
+      config: {}
+    });
+
+    await wrapper.start();
+
+    expect(monitoring.init).toHaveBeenCalledWith({
+      serviceName: 'test-service'
+    });
+
+    expect(wrapper.logger).toBeDefined();
+    expect(wrapper.monitoring).toBeDefined();
+  });
+
+  test('should use monitoring for logging', async () => {
+    const app = express();
+    const wrapper = new ServiceWrapper({
+      service: app,
+      serviceName: 'test-service',
+      openApiSpec: { info: { version: '1.0.0' } },
+      config: {}
+    });
+
+    await wrapper.start();
+
+    // Test logger methods are available
+    expect(wrapper.logger.info).toBeDefined();
+    expect(wrapper.logger.error).toBeDefined();
+    expect(wrapper.logger.warn).toBeDefined();
+    expect(wrapper.logger.debug).toBeDefined();
+
+    // Test logger is used
+    wrapper.logger.info('Test message', { data: 'test' });
+    wrapper.logger.error('Error message', { error: 'test' });
+  });
+
+  test('should pass monitoring to orchestrator', async () => {
+    const app = express();
+    const OrchestratorConnector = require('@onlineapps/conn-orch-orchestrator');
+
+    const wrapper = new ServiceWrapper({
+      service: app,
+      serviceName: 'test-service',
+      openApiSpec: { info: { version: '1.0.0' } },
+      config: {}
+    });
+
+    await wrapper.start();
+
+    expect(OrchestratorConnector.create).toHaveBeenCalledWith(
+      expect.objectContaining({
+        logger: expect.objectContaining({
+          info: expect.any(Function),
+          error: expect.any(Function),
+          warn: expect.any(Function),
+          debug: expect.any(Function)
+        })
+      })
+    );
+  });
+
+  test('should handle monitoring mode from config', async () => {
+    const app = express();
+    const monitoring = require('@onlineapps/conn-base-monitoring');
+
+    const wrapper = new ServiceWrapper({
+      service: app,
+      serviceName: 'test-service',
+      openApiSpec: { info: { version: '1.0.0' } },
+      config: {
+        monitoringMode: 'debug'
+      }
+    });
+
+    await wrapper.start();
+
+    // Monitoring should be initialized but mode is not passed
+    // because ServiceWrapper doesn't pass it through yet
+    expect(monitoring.init).toHaveBeenCalled();
+  });
+});