@onlineapps/conn-orch-cookbook 2.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 ONLINE APPS s.r.o.; info@onlineapps.cz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,281 @@
+# @onlineapps/connector-cookbook
+
+> Complete cookbook toolkit for ALL services - unified wrapper including core, executor, transformer, and router functionality
+
+## 🚀 Version 2.0 - Major Update
+
+The `connector-cookbook` package (v2.0) is now a complete toolkit that combines all cookbook functionality in one unified package. This ensures architectural consistency across ALL services including infrastructure components like workflow_launcher.
+
+### What's New in v2.0
+
+- **Modular architecture** - Four specialized modules combined
+- **Backward compatibility** - All v1.x APIs still work
+- **Unified approach** - Same package for ALL services (infrastructure and business)
+- **Complete toolkit** - Parsing, execution, transformation, and routing
+
+### Why Unified Approach?
+
+Per architectural decision, ALL services including workflow_launcher use this single package to ensure:
+- **Consistency** - Same API everywhere
+- **Predictability** - No special cases
+- **Maintainability** - Single source of truth
+- **Simplicity** - One package to learn
+
+## 📦 Installation
+
+```bash
+npm install @onlineapps/connector-cookbook
+# or
+yarn add @onlineapps/connector-cookbook
+```
+
+## 🔧 Quick Start
+
+### Backward Compatible (v1.x style)
+
+```javascript
+const {
+  parseCookbookFromFile,
+  validateCookbook
+} = require('@onlineapps/connector-cookbook');
+
+// Works exactly as before
+const cookbook = await parseCookbookFromFile('./workflow.json');
+validateCookbook(cookbook);
+```
+
+### New Modular Approach (v2.0)
+
+```javascript
+const cookbook = require('@onlineapps/connector-cookbook');
+
+// Use specific modules
+const { CookbookExecutor } = cookbook.executor;
+const { CookbookRouter } = cookbook.router;
+const { CookbookGenerator } = cookbook.transformer;
+
+// Or use factory functions
+const processor = cookbook.createProcessor({
+  cookbook: myCookbook,
+  maxRetries: 3
+});
+```
+
+## 📚 Included Modules
+
+### 1. Core Module (@onlineapps/cookbook-core)
+- JSON Schema validation
+- Recursive step validation
+- Parsing from file/object
+- Lightweight (~50KB)
+
+### 2. Executor Module (@onlineapps/cookbook-executor)
+- Workflow execution engine
+- Context management
+- Variable resolution ($api_input, $steps)
+- Step processing for all types
+
+### 3. Transformer Module (@onlineapps/cookbook-transformer)
+- OpenAPI to cookbook generation
+- API spec analysis
+- Response mapping
+- JSONPath transformations
+
+### 4. Router Module (@onlineapps/cookbook-router)
+- Service discovery
+- Queue management
+- Retry with exponential backoff
+- Dead letter queue handling
+
+## 🎯 Usage Examples
+
+### Complete Service Implementation
+
+```javascript
+const cookbook = require('@onlineapps/connector-cookbook');
+const MQClient = require('@onlineapps/connector-mq-client');
+const RegistryClient = require('@onlineapps/connector-registry-client');
+
+class MyService {
+  constructor() {
+    // Initialize clients
+    this.mqClient = new MQClient(mqConfig);
+    this.registryClient = new RegistryClient(registryConfig);
+
+    // Create router for message handling
+    this.router = cookbook.createRouter(
+      this.mqClient,
+      this.registryClient
+    );
+  }
+
+  async processWorkflow(message) {
+    // Parse and validate
+    const workflowDef = cookbook.parseCookbookFromObject(message.cookbook);
+
+    // Create executor
+    const executor = new cookbook.CookbookExecutor(workflowDef);
+
+    // Execute workflow
+    const result = await executor.execute(message.context);
+
+    // Route to next service
+    await this.router.routeToNextService(
+      workflowDef,
+      result,
+      message.current_step
+    );
+  }
+}
+```
+
+### Infrastructure Service (workflow_launcher)
+
+```javascript
+// workflow_launcher uses the SAME package
+const cookbook = require('@onlineapps/connector-cookbook');
+
+class WorkflowLauncher {
+  async handleWorkflowInit(message) {
+    // Validate cookbook
+    cookbook.validateCookbook(message.cookbook);
+
+    // Route to first service
+    await this.router.routeWorkflow(
+      message.cookbook,
+      message.context
+    );
+  }
+}
+```
+
+### OpenAPI Integration
+
+```javascript
+const { CookbookGenerator } = require('@onlineapps/connector-cookbook');
+
+const generator = new CookbookGenerator({
+  defaultTimeout: 10000,
+  defaultRetry: { maxAttempts: 3, delayMs: 2000 }
+});
+
+// Generate cookbook from OpenAPI spec
+const openApiSpec = require('./api-spec.json');
+const cookbook = generator.generate(openApiSpec);
+```
+
+## 📖 Cookbook Structure
+
+### Basic Example
+```json
+{
+  "version": "1.0.0",
+  "api_input": {
+    "customer": "ACME Corp",
+    "amount": 1000
+  },
+  "steps": [
+    {
+      "id": "invoice_step",
+      "type": "task",
+      "service": "invoice_service",
+      "input": {
+        "customer": "$api_input.customer",
+        "amount": "$api_input.amount"
+      },
+      "output": {
+        "invoice_id": "$.invoice_id"
+      },
+      "retry": {
+        "maxAttempts": 3,
+        "delayMs": 2000
+      }
+    }
+  ]
+}
+```
+
+## 📚 Step Types
+
+All 7 step types are fully supported:
+
+- **task** - Service operation execution
+- **foreach** - Iteration over arrays
+- **fork_join** - Parallel execution
+- **switch** - Conditional branching
+- **sub_workflow** - Nested workflows
+- **wait** - Time delays
+- **dispatch** - Webhook dispatching
+
+## 🔄 Migration from v1.x
+
+Version 2.0 maintains full backward compatibility. Existing code continues to work without changes:
+
+```javascript
+// This still works exactly as before
+const { parseCookbookFromFile } = require('@onlineapps/connector-cookbook');
+const cookbook = await parseCookbookFromFile('./workflow.json');
+```
+
+To access new features, use the modular exports:
+
+```javascript
+// New modular approach
+const { executor, router, transformer } = require('@onlineapps/connector-cookbook');
+```
+
+## 📋 API Reference
+
+### Legacy Exports (v1.x compatible)
+- `parseCookbookFromFile(path)` - Parse from file
+- `parseCookbookFromObject(obj)` - Parse from object
+- `validateCookbook(cookbook)` - Validate structure
+- `CookbookValidationError` - Error class
+
+### New Modular Exports (v2.0)
+- `core` - Core parsing and validation
+- `executor` - Workflow execution
+- `transformer` - OpenAPI transformation
+- `router` - Message routing
+- `createProcessor(options)` - Factory for complete processor
+- `createRouter(mqClient, registryClient, options)` - Factory for router
+
+## 🧪 Testing
+
+```bash
+npm test              # Run all tests
+npm run test:unit     # Unit tests only
+npm run test:integration  # Integration tests
+```
+
+## ⚠️ Important Notes
+
+### Schema Validation Strictness
+The current schema validation is very strict. See [Schema Audit Report](/shared/cookbook/cookbook-core/docs/SCHEMA_AUDIT.md) for detailed analysis and recommendations.
+
+**Known Issues:**
+- All step types incorrectly require `service`, `input`, and `output` fields
+- `type` field should be required but isn't
+- Some control flow steps (foreach, switch) have unnecessary field requirements
+
+**Workaround:** Until schema is updated, include all required fields even if not used:
+```javascript
+{
+  type: 'foreach',
+  service: 'dummy-service',  // Not actually used
+  input: {},                 // Not actually used
+  output: {},                // Optional but may be required by schema
+  // ... actual foreach fields
+}
+```
+
+## 📄 License
+
+PROPRIETARY - All rights reserved
+
+## 🤝 Contributing
+
+Internal package - contributions via internal GitLab only.
+
+---
+*For detailed documentation on individual modules, see their respective README files in the shared/ directory.*

package/examples/basicUsage.js

@@ -0,0 +1,84 @@
+/**
+ * basicUsage.js
+ *
+ * Example demonstrating full lifecycle of ServiceRegistryClient:
+ * 1. Load environment variables
+ * 2. Instantiate client
+ * 3. Initialize (setup queues and start listening for requests)
+ * 4. Register event listeners (apiDescriptionRequest, heartbeatSent, apiDescriptionSent, error)
+ * 5. Start heartbeat loop
+ * 6. Graceful shutdown on process signals
+ */
+
+// Load environment variables from .env file
+require('dotenv').config();
+
+const { ServiceRegistryClient, EVENTS } = require('agent-registry-client');
+
+// Step 1: Create a new ServiceRegistryClient instance
+const registryClient = new ServiceRegistryClient({
+  amqpUrl: process.env.AMQP_URL,
+  serviceName: process.env.SERVICE_NAME || 'invoicing',
+  version: process.env.SERVICE_VERSION || '1.0.0',
+  heartbeatInterval: parseInt(process.env.HEARTBEAT_INTERVAL, 10) || 10000,
+  apiQueue: process.env.API_QUEUE,
+  registryQueue: process.env.REGISTRY_QUEUE
+});
+
+// Step 2: Register event listeners
+registryClient.on(EVENTS.HEARTBEAT_SENT, (msg) => {
+  console.log(`[Heartbeat] Sent at ${msg.timestamp} for ${msg.serviceName}@${msg.version}`);
+});
+
+registryClient.on(EVENTS.API_DESCRIPTION_REQUEST, async (payload) => {
+  console.log(`[API Description Request] for ${payload.serviceName}@${payload.version}`);
+  // Load local API description (from file or in-memory)
+  const apiDesc = await loadLocalApiDescription();
+  await registryClient.sendApiDescription(apiDesc);
+});
+
+registryClient.on(EVENTS.API_DESCRIPTION_SENT, (msg) => {
+  console.log(`[API Description Sent] at ${msg.timestamp} for ${msg.serviceName}@${msg.version}`);
+});
+
+registryClient.on(EVENTS.ERROR, (err) => {
+  console.error('[RegistryClient Error]', err);
+});
+
+(async () => {
+  try {
+    // Step 3: Initialize client (setup queues and listeners)
+    await registryClient.init();
+    console.log('RegistryClient initialized: queues are ready.');
+
+    // Step 4: Start heartbeat loop
+    registryClient.startHeartbeat();
+    console.log('Heartbeat loop started.');
+
+    // Step 5: Graceful shutdown on SIGINT/SIGTERM
+    const shutdown = async () => {
+      console.log('Shutting down RegistryClient...');
+      await registryClient.close();
+      process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+  } catch (err) {
+    console.error('Failed to initialize RegistryClient', err);
+    process.exit(1);
+  }
+})();
+
+/**
+ * Helper: Load local API description
+ * In a real application, this could read from a JSON file,
+ * introspect OpenAPI spec, or build dynamically.
+ */
+async function loadLocalApiDescription() {
+  return {
+    endpoints: [
+      { path: '/invoices', method: 'POST', description: 'Create a new invoice' },
+      { path: '/invoices/:id', method: 'GET', description: 'Retrieve invoice by ID' }
+    ]
+  };
+}

package/examples/cookbook-experimental.json

@@ -0,0 +1,169 @@
+{
+  "version": "1.0.0",
+  "api_input": {
+    "customer": "ACME Corp.",
+    "amount": 1000,
+    "currency": "USD",
+    "requested_formats": ["html", "pdf"],
+    "items": [
+      { "sku": "A1", "qty": 2 },
+      { "sku": "B2", "qty": 1 }
+    ],
+    "priority": "high",
+    "order_details": {
+      "order_id": "ORD-123",
+      "date": "2025-06-01"
+    }
+  },
+  "workflow_steps": [
+    {
+      "step": "1",
+      "type": "task",
+      "service": "invoice_service",
+      "queue": "invoice.process",
+      "input_mapping": {
+        "customer": "api_input.customer",
+        "amount": "api_input.amount",
+        "currency": "api_input.currency"
+      },
+      "output_schema": {
+        "invoice_id": "invoice_service.invoice_id",
+        "total_amount": "invoice_service.total_amount"
+      },
+      "retry": {
+        "max_attempts": 3,
+        "delay": 2000
+      },
+      "timeout": 10000
+    },
+    {
+      "step": "2",
+      "type": "foreach",
+      "iterator": "api_input.items",
+      "steps": [
+        {
+          "step": "2.1",
+          "type": "task",
+          "service": "item_processing_service",
+          "queue": "item.process",
+          "input_mapping": {
+            "invoice_id": "workflow_steps[0].result.invoice_id",
+            "item": "foreach.item"
+          },
+          "output_schema": {
+            "processed_item": "item_processing_service.result"
+          }
+        }
+      ]
+    },
+    {
+      "step": "3",
+      "type": "fork_join",
+      "fork": [
+        {
+          "service": "template_service",
+          "queue": "template.generate",
+          "input_mapping": {
+            "invoice_id": "workflow_steps[0].result.invoice_id",
+            "customer": "api_input.customer"
+          },
+          "output_schema": {
+            "generated_html": "template_service.generated_html"
+          }
+        },
+        {
+          "service": "analytics_service",
+          "queue": "analytics.process",
+          "input_mapping": {
+            "invoice_id": "workflow_steps[0].result.invoice_id",
+            "amount": "workflow_steps[0].result.total_amount"
+          },
+          "output_schema": {
+            "analytics_report": "analytics_service.report"
+          }
+        }
+      ],
+      "join": {
+        "strategy": "merge",
+        "result_mapping": {
+          "combined_html": ["fork[0].generated_html"],
+          "analytics": ["fork[1].analytics_report"]
+        }
+      }
+    },
+    {
+      "step": "4",
+      "type": "switch",
+      "expression": "api_input.priority",
+      "cases": {
+        "high": {
+          "service": "priority_service",
+          "queue": "priority.process",
+          "input_mapping": {
+            "invoice_id": "workflow_steps[0].result.invoice_id",
+            "priority_flag": "api_input.priority"
+          },
+          "output_schema": {
+            "priority_result": "priority_service.result"
+          }
+        },
+        "low": {
+          "service": "standard_service",
+          "queue": "standard.process",
+          "input_mapping": {
+            "invoice_id": "workflow_steps[0].result.invoice_id"
+          },
+          "output_schema": {
+            "standard_result": "standard_service.result"
+          }
+        }
+      },
+      "default": {
+        "service": "fallback_service",
+        "queue": "fallback.process",
+        "input_mapping": {
+          "invoice_id": "workflow_steps[0].result.invoice_id"
+        },
+        "output_schema": {
+          "fallback_result": "fallback_service.result"
+        }
+      }
+    },
+    {
+      "step": "5",
+      "type": "sub_workflow",
+      "workflow_id": "generate_invoice_pdf",
+      "parameters": {
+        "invoice_id": "workflow_steps[0].result.invoice_id",
+        "html_content": "workflow_steps[3].result.combined_html"
+      }
+    },
+    {
+      "step": "6",
+      "type": "wait",
+      "duration": 30000,
+      "message": "Čekání 30 s než se vygeneruje PDF na úložišti"
+    },
+    {
+      "step": "7",
+      "type": "task",
+      "service": "pdf_service",
+      "queue": "pdf.convert",
+      "input_mapping": {
+        "html": "workflow_steps[3].result.combined_html",
+        "invoice_id": "workflow_steps[0].result.invoice_id"
+      },
+      "output_schema": {
+        "pdf_url": "pdf_service.pdf_url"
+      },
+      "retry": {
+        "max_attempts": 2,
+        "delay": 1000
+      }
+    }
+  ],
+  "final_delivery": {
+    "method": "webhook",
+    "target": "https://client.example.com/webhook"
+  }
+}

package/examples/cookbook-generalized-experimental.json

@@ -0,0 +1,180 @@
+{
+    "version": "1.0.0",                         # Version of the workflow schema X.X.X
+    "api_input": {                              # Input parameters for the API call
+      "customer": "ACME Corp.",         
+      "amount": 1000,
+      "currency": "USD",
+      "requested_formats": ["html", "pdf"],     
+      "items": [
+        { "sku": "A1", "qty": 2 },
+        { "sku": "B2", "qty": 1 }
+      ],
+      "priority": "high",
+      "order_details": {
+        "order_id": "ORD-123",
+        "date": "2025-06-01"
+      }
+    },
+    "general_workflow": [                               # Steps in the workflow  
+      {                                         # typical step structure
+        "step": "1",                            # Unique identifier for the step ("1", "A", etc.)
+        "type": "task",                         # Type of the step (task, foreach, fork_join, sub_workflow, switch, wait, dispatch) 
+        "service": "invoice_service",           # Service and its queue to be called
+        "input_mapping": {                      # Mapping of input parameters to the service  
+          "customer": "api_input.customer",
+          "amount": "api_input.amount",
+          "currency": "api_input.currency"
+        },
+        "output_schema": {                      # Schema of the output from the service 
+          "invoice_id": "this.invoice_id",      # Reference to the output field, "this" refers to the current step's output
+          "total_amount": "this.total_amount"
+        },
+        "retry": {                              # Retry configuration for the step 
+          "max_attempts": 3,                    # Maximum number of retry attempts 
+          "delay": 2000                         # Delay between retries in milliseconds
+        },
+        "timeout": 10000                        # Timeout for the step in milliseconds
+      },
+      {                                         # Foreach step to process each item in the input array 
+        "step": "B",
+        "type": "foreach",
+        "input_iterator": "api_input.items",    # Input for the foreach loop, in case of an array
+        "workflow": [     
+          {
+            "step": "2.1",
+            "type": "task",
+            "service": "item_processing_service",
+            "input_mapping": {
+              "invoice_id": "parent.previous.result.invoice_id",    # Reference to the parent and previous step's output
+              "item": "foreach.item"            # Reference to the current item in the foreach loop
+            },
+            "output_schema": {  
+              "processed_item": "this.result"
+            }
+          }
+        ],
+        "output_mapping": {
+            "items": "foreach.processed_item"  # Output schema for the foreach step}
+      },
+      {
+        "step": "3X",
+        "type": "fork_join",
+        "fork": [
+          {
+            "service": "template_service",
+            "queue": "template.generate",
+            "input_mapping": {
+              "invoice_id": "workflow_steps[0].result.invoice_id",
+              "customer": "api_input.customer"
+            },
+            "output_schema": {
+              "generated_html": "template_service.generated_html"
+            }
+          },
+          {
+            "service": "analytics_service",
+            "queue": "analytics.process",
+            "input_mapping": {
+              "invoice_id": "workflow_steps[0].result.invoice_id",
+              "amount": "workflow_steps[0].result.total_amount"
+            },
+            "output_schema": {
+              "analytics_report": "analytics_service.report"
+            }
+          }
+        ],
+        "join": {
+          "strategy": "merge",
+          "result_mapping": {
+            "combined_html": ["fork[0].generated_html"],
+            "analytics": ["fork[1].analytics_report"]
+          }
+        }
+      },
+      {
+        "step": "4",
+        "type": "switch",
+        "expression": "api_input.priority",
+        "cases": {
+          "high": {
+            "service": "priority_service",
+            "queue": "priority.process",
+            "input_mapping": {
+              "invoice_id": "workflow_steps[0].result.invoice_id",
+              "priority_flag": "api_input.priority"
+            },
+            "output_schema": {
+              "priority_result": "priority_service.result"
+            }
+          },
+          "low": {
+            "service": "standard_service",
+            "queue": "standard.process",
+            "input_mapping": {
+              "invoice_id": "workflow_steps[0].result.invoice_id"
+            },
+            "output_schema": {
+              "standard_result": "standard_service.result"
+            }
+          }
+        },
+        "default": {
+          "service": "fallback_service",
+          "queue": "fallback.process",
+          "input_mapping": {
+            "invoice_id": "workflow_steps[0].result.invoice_id"
+          },
+          "output_schema": {
+            "fallback_result": "fallback_service.result"
+          }
+        }
+      },
+      {
+        "step": "5",
+        "type": "sub_workflow",
+        "workflow_id": "generate_invoice_pdf",
+        "parameters": {
+          "invoice_id": "workflow_steps[0].result.invoice_id",
+          "html_content": "workflow_steps[3].result.combined_html"
+        }
+      },
+      {
+        "step": "6",
+        "type": "wait",
+        "duration": 30000,
+        "message": "Čekání 30 s než se vygeneruje PDF na úložišti"
+      },
+      {
+        "step": "7",
+        "type": "task",
+        "service": "pdf_service",
+        "queue": "pdf.convert",
+        "input_mapping": {
+          "html": "workflow_steps[3].result.combined_html",
+          "invoice_id": "workflow_steps[0].result.invoice_id"
+        },
+        "output_schema": {
+          "pdf_url": "pdf_service.pdf_url"
+        },
+        "retry": {
+          "max_attempts": 2,
+          "delay": 1000
+        }
+      },
+      {
+        "step": "7",
+        "type": "dispatch",
+        "method": "webhook",
+        "target": "https://client.example.com/webhook",
+        "input_mapping": {
+          "html": "workflow_steps[3].result.combined_html",
+          "invoice_id": "workflow_steps[0].result.invoice_id"
+        },
+        "retry": {
+          "max_attempts": 2,
+          "delay": 1000
+        }
+      }
+    ]
+  }
+  

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@onlineapps/conn-orch-cookbook",
+  "version": "2.0.0",
+  "description": "Complete cookbook toolkit for all services - unified wrapper including core, executor, transformer, and router functionality",
+  "main": "src/index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/onlineapps/connector-cookbook.git"
+  },
+  "files": [
+    "src/",
+    "docs/",
+    "examples/",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "test": "jest --coverage",
+    "test:unit": "jest --testPathPattern=unit --coverage",
+    "test:component": "jest --testPathPattern=component --coverage",
+    "test:integration": "jest --testPathPattern=integration --coverage",
+    "test:fixtures": "jest test/integration/cookbook-fixtures.test.js",
+    "test:smoke": "jest test/smoke.test.js",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage --coverageReporters=text-lcov html",
+    "lint": "eslint \"src/**/*.js\" \"tests/**/*.js\"",
+    "prettier:check": "prettier --check \"src/**/*.js\" \"tests/**/*.js\"",
+    "prettier:fix": "prettier --write \"src/**/*.js\" \"tests/**/*.js\"",
+    "docs": "jsdoc2md --files src/**/*.js > API.md"
+  },
+  "keywords": [
+    "connector",
+    "cookbook",
+    "workflow",
+    "orchestration",
+    "microservice",
+    "parser",
+    "validator",
+    "json-schema"
+  ],
+  "author": "OnlineApps Team <dev@onlineapps.io>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/onlineapps/connector-cookbook/issues"
+  },
+  "homepage": "https://github.com/onlineapps/connector-cookbook#readme",
+  "dependencies": {},
+  "devDependencies": {
+    "eslint": "^8.30.0",
+    "eslint-config-prettier": "^8.5.0",
+    "jest": "^29.5.0",
+    "prettier": "^2.8.0"
+  },
+  "engines": {
+    "node": ">=12"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/index.js

@@ -0,0 +1,230 @@
+'use strict';
+
+/**
+ * @module @onlineapps/conn-orch-cookbook
+ * @description Unified cookbook connector for service-wrapper integration.
+ * This is a THIN WRAPPER around cookbook-* modules, providing a single
+ * unified interface for all cookbook functionality.
+ *
+ * NO DUPLICATION: All implementation is in cookbook-* modules.
+ * This connector only re-exports and provides compatibility layer.
+ *
+ * @see {@link https://github.com/onlineapps/oa-drive/tree/main/shared/connector/conn-orch-cookbook|GitHub Repository}
+ * @author OA Drive Team
+ * @license MIT
+ * @since 2.0.0
+ */
+
+// Import from shared cookbook modules - NO LOCAL IMPLEMENTATIONS!
+const cookbookCore = require('../../../cookbook/cookbook-core');
+const cookbookExecutor = require('../../../cookbook/cookbook-executor');
+const cookbookTransformer = require('../../../cookbook/cookbook-transformer');
+const cookbookRouter = require('../../../cookbook/cookbook-router');
+
+// Re-export all from cookbook-core (parser and validator)
+const {
+  parseCookbookFromFile,
+  parseCookbookFromFileSync,
+  parseCookbookFromObject,
+  validateCookbook,
+  validateStep,
+  CookbookValidationError,
+  validateAllReferences,
+  validateDependsOnReferences,
+  validateVariableReferences,
+  validateErrorHandlerReferences,
+  CookbookSchema,
+  loadSchema
+} = cookbookCore;
+
+// Re-export all from cookbook-executor
+const {
+  CookbookExecutor,
+  ContextManager,
+  StepProcessor,
+  VariableResolver
+} = cookbookExecutor;
+
+// Re-export all from cookbook-transformer
+const {
+  CookbookGenerator,
+  ApiSpecAnalyzer,
+  StepTranslator,
+  ResponseMapper,
+  createTransformer
+} = cookbookTransformer;
+
+// Re-export all from cookbook-router
+const {
+  CookbookRouter,
+  ServiceDiscovery,
+  QueueManager,
+  RetryHandler,
+  createRouter
+} = cookbookRouter;
+
+
+/**
+ * Create a cookbook processor with all capabilities
+ * Factory function that creates a processor with parser, validator, executor, and router
+ *
+ * @function createProcessor
+ * @param {Object} [config={}] - Processor configuration
+ * @param {Object} [config.executor] - Executor configuration
+ * @param {Object} [config.router] - Router configuration
+ * @param {Object} [config.transformer] - Transformer configuration
+ * @param {Object} [config.mqClient] - Message queue client for router
+ * @param {Object} [config.registryClient] - Registry client for router
+ * @returns {Object} Processor instance with process method
+ *
+ * @example
+ * const processor = createProcessor({
+ *   executor: { timeout: 30000 },
+ *   router: { baseUrl: "http://api.example.com" },
+ *   mqClient: mqConnector,
+ *   registryClient: registryConnector
+ * });
+ *
+ * const result = await processor.process(cookbook);
+ */
+function createProcessor(config = {}) {
+  const executor = new CookbookExecutor(config.executor);
+  const router = config.mqClient && config.registryClient
+    ? createRouter(config.mqClient, config.registryClient, config.router)
+    : null;
+  const transformer = createTransformer(config.transformer);
+  const mapper = new ResponseMapper(config.transformer);
+
+  return {
+    /**
+     * Process a cookbook through the full pipeline
+     * @param {Object|string} cookbook - Cookbook object or file path
+     * @param {Object} [context={}] - Execution context
+     * @returns {Promise<Object>} Execution result
+     */
+    async process(cookbook, context = {}) {
+      // Parse if string (file path)
+      if (typeof cookbook === 'string') {
+        cookbook = await parseCookbookFromFile(cookbook);
+      }
+
+      // Validate
+      validateCookbook(cookbook);
+
+      // Validate all references
+      validateAllReferences(cookbook);
+
+      // Execute with routing and transformation
+      const executionContext = {
+        ...context,
+        router,
+        transformer,
+        mapper
+      };
+
+      return executor.execute(cookbook, executionContext);
+    },
+
+    // Expose components for direct access
+    executor,
+    router,
+    transformer,
+    mapper
+  };
+}
+
+/**
+ * Helper function to execute a single step
+ * Convenience wrapper around CookbookExecutor
+ *
+ * @function executeStep
+ * @param {Object} step - Step to execute
+ * @param {Object} [context={}] - Execution context
+ * @returns {Promise<Object>} Step execution result
+ *
+ * @example
+ * const result = await executeStep({
+ *   id: "step1",
+ *   type: "task",
+ *   service: "api",
+ *   action: "GET",
+ *   endpoint: "/users"
+ * });
+ */
+async function executeStep(step, context = {}) {
+  const executor = new CookbookExecutor();
+  return executor.executeStep(step, context);
+}
+
+/**
+ * Helper function to execute a complete workflow
+ * Convenience wrapper around CookbookExecutor
+ *
+ * @function executeWorkflow
+ * @param {Object} cookbook - Cookbook to execute
+ * @param {Object} [context={}] - Execution context
+ * @returns {Promise<Object>} Workflow execution result
+ *
+ * @example
+ * const result = await executeWorkflow(cookbook, {
+ *   variables: { userId: 123 }
+ * });
+ */
+async function executeWorkflow(cookbook, context = {}) {
+  const executor = new CookbookExecutor();
+  return executor.execute(cookbook, context);
+}
+
+// Export everything as unified interface
+module.exports = {
+  // Parser functions (from cookbook-core)
+  parseCookbookFromFile,
+  parseCookbookFromFileSync,
+  parseCookbookFromObject,
+
+  // Validator functions (from cookbook-core)
+  validateCookbook,
+  validateStep,
+  CookbookValidationError,
+
+  // Reference validators (from cookbook-core)
+  validateAllReferences,
+  validateDependsOnReferences,
+  validateVariableReferences,
+  validateErrorHandlerReferences,
+
+  // Schema (from cookbook-core)
+  CookbookSchema,
+  loadSchema,
+
+  // Executor classes (from cookbook-executor)
+  CookbookExecutor,
+  ContextManager,
+  StepProcessor,
+  VariableResolver,
+
+  // Transformer classes (from cookbook-transformer)
+  CookbookGenerator,
+  ApiSpecAnalyzer,
+  StepTranslator,
+  ResponseMapper,
+  createTransformer,
+
+  // Router classes (from cookbook-router)
+  CookbookRouter,
+  ServiceDiscovery,
+  QueueManager,
+  RetryHandler,
+  createRouter,
+
+
+  // Factory and helper functions
+  createProcessor,
+  executeStep,
+  executeWorkflow,
+
+  // Version info
+  VERSION: '2.0.0',
+  COMPATIBLE_CORE_VERSION: cookbookCore.VERSION,
+  COMPATIBLE_SCHEMA_VERSION: cookbookCore.SCHEMA_VERSION
+};