synapse-hub 2.1.1 → 2.2.1

package/tools/export_postman_collection.py

@@ -1,35 +1,43 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
-tools/export_postman_collection.py — Enterprise API to Postman Collection v2.1.0 Exporter
------------------------------------------------------------------------------------------
-Converts OpenAPI / Swagger specifications, JSON endpoint schemas, or HTTP Archives (HAR)
-into a production-ready Postman Collection v2.1.0 (with Pre-request Scripts, Tests Scripts,
-Response Time Assertions, and Auto-Extracted Environment Variables).
-
-Features:
-  1. Ingests OpenAPI 3.0 / Swagger 2.0 JSON, HAR files, or built-in sample schemas.
-  2. Generates organized folders by Tags / Resources with parameterized routes.
-  3. Pre-request Scripts: Dynamic request timestamps, UUIDs, and automated auth headers.
+tools/export_postman_collection.py — Enterprise API to Postman Collection v2.1.0 Exporter (Postman Pinnacle)
+-----------------------------------------------------------------------------------------------------------
+Converts OpenAPI / Swagger specifications, JSON endpoint schemas, HTTP Archives (HAR),
+or Natural Language Domain archetypes into production-ready Postman Collections v2.1.0.
+
+Pinnacle Enterprise Capabilities:
+  1. Multi-Format Ingestion: OpenAPI 3.0 / Swagger 2.0, HAR traffic traces, or Zero-Input Domain Synthesis.
+  2. Autonomous Zero-Input Synthesis: Generates complete multi-tier API collections from scratch
+     when no input files exist (`--domain [ecommerce|banking|saas]`).
+  3. Pre-request Scripts: Dynamic request timestamps, UUIDs, nonces, and automated Bearer Auth headers.
   4. Test Scripts (pm.test):
      - Expected HTTP Status assertions.
-     - Response time SLA latency assertions (< 1000ms).
+     - SLA Latency assertions (< 1000ms).
      - Response Content-Type JSON header validation.
-     - Autonomous Token & ID Extractor: Auto-saves `token`, `access_token`, or `id` into
-       `pm.environment` / `pm.collectionVariables` for chaining sequential API calls.
-  5. Companion Environment Generator: Outputs `postman_environment.json` with base URLs.
-  6. 100% UTF-8 No BOM, portable, Newman CLI and CI/CD compatible.
+     - Autonomous Token & ID Extractor (`pm.environment.set('bearerToken', ...)`).
+     - Native AJV JSON Schema Validation (`pm.response.to.have.jsonSchema(schema)`).
+  5. Companion Environment Generator: Outputs `postman_environment.json` with base URLs and variables.
+  6. Data-Driven Testing (DDT) Suite: Outputs companion `test_data.csv` for Newman matrix execution.
+  7. 100% UTF-8 No BOM, portable, Newman CLI and CI/CD compatible.
 
 Usage:
-  python tools/export_postman_collection.py --spec swagger.json -o collection.json
+  # 1. From existing OpenAPI / Swagger
+  python tools/export_postman_collection.py --spec swagger.json -o collection.json --env-output env.json
+
+  # 2. Zero-Input Autonomous Generation (No input files!)
+  python tools/export_postman_collection.py --domain ecommerce -o ecom_collection.json --ddt-output ecom_data.csv
+  python tools/export_postman_collection.py --domain banking -o banking_collection.json --env-output banking_env.json
+
+  # 3. From browser network trace (.har)
   python tools/export_postman_collection.py --har traffic.har -o collection.json
-  python tools/export_postman_collection.py --sample -o sample_collection.json --env-output sample_env.json
 """
 
 import os
 import sys
 import json
 import uuid
+import csv
 import argparse
 from typing import Dict, Any, List, Optional
 from urllib.parse import urlparse, parse_qs
@@ -50,10 +58,11 @@ def generate_uuid() -> str:
 def build_pre_request_script() -> List[str]:
     """Generates standard Postman Pre-request script lines."""
     return [
-        "// Auto-generated Pre-request Script by Agent-QA Hub",
-        "// 1. Dynamic Timestamp & Request ID generation",
+        "// Auto-generated Pre-request Script by Synapse-Hub",
+        "// 1. Dynamic Timestamp & Correlation ID generation",
         "pm.variables.set('req_timestamp', new Date().toISOString());",
         "pm.variables.set('req_nonce', Math.random().toString(36).substring(2, 12));",
+        "pm.variables.set('correlation_id', 'CORR-' + pm.variables.get('req_nonce'));",
         "",
         "// 2. Automated Bearer Token Injection if present in environment",
         "var token = pm.environment.get('bearerToken') || pm.collectionVariables.get('bearerToken');",
@@ -63,10 +72,14 @@ def build_pre_request_script() -> List[str]:
     ]
 
 
-def build_test_script(expected_status: int = 200, max_time_ms: int = 1000) -> List[str]:
-    """Generates standard Postman Test script lines."""
-    return [
-        "// Auto-generated Test Assertions by Agent-QA Hub",
+def build_test_script(
+    expected_status: int = 200,
+    max_time_ms: int = 1000,
+    response_schema: Optional[Dict[str, Any]] = None
+) -> List[str]:
+    """Generates comprehensive Postman Test script lines with AJV JSON Schema assertion."""
+    lines = [
+        "// Auto-generated Test Assertions by Synapse-Hub",
         f"// 1. Assert Status Code is {expected_status}",
         f"pm.test('Status code is {expected_status}', function () {{",
         f"    pm.expect(pm.response.code).to.be.oneOf([{expected_status}, 200, 201]);",
@@ -93,12 +106,13 @@ def build_test_script(expected_status: int = 200, max_time_ms: int = 1000) -> Li
         "        if (authToken) {",
         "            pm.environment.set('bearerToken', authToken);",
         "            pm.collectionVariables.set('bearerToken', authToken);",
-        "            console.log('[Agent-QA] Captured dynamic bearerToken: ' + authToken.substring(0, 15) + '...');",
+        "            console.log('[Synapse-Hub] Captured dynamic bearerToken: ' + authToken.substring(0, 15) + '...');",
         "        }",
         "        // Auto-extract newly created ID",
         "        var entityId = jsonBody.id || jsonBody.code || (jsonBody.data && (jsonBody.data.id || jsonBody.data.code));",
         "        if (entityId) {",
         "            pm.environment.set('lastCreatedId', String(entityId));",
+        "            console.log('[Synapse-Hub] Captured lastCreatedId: ' + entityId);",
         "        }",
         "    } catch (e) {",
         "        // Response is non-JSON or empty body",
@@ -106,6 +120,20 @@ def build_test_script(expected_status: int = 200, max_time_ms: int = 1000) -> Li
         "}"
     ]
 
+    # 5. AJV Native JSON Schema Validation
+    if response_schema:
+        schema_clean = json.dumps(response_schema, ensure_ascii=False)
+        lines.extend([
+            "",
+            "// 5. AJV JSON Schema Contract Validation",
+            "pm.test('Response conforms to OpenAPI JSON Schema', function () {",
+            f"    var schema = {schema_clean};",
+            "    pm.response.to.have.jsonSchema(schema);",
+            "});"
+        ])
+
+    return lines
+
 
 def mock_schema_payload(schema: Dict[str, Any], depth: int = 0) -> Any:
     """Recursively generates realistic mock JSON payload from OpenAPI schema."""
@@ -151,7 +179,6 @@ def parse_openapi_spec(spec_data: Dict[str, Any], base_url_override: Optional[st
     col_desc = info_dict.get("description", "Auto-generated Postman Collection from OpenAPI / Swagger")
 
     # Determine Base URL
-    base_url = "{{baseUrl}}"
     if base_url_override:
         base_url_default = base_url_override
     elif "servers" in spec_data and spec_data["servers"]:
@@ -180,6 +207,11 @@ def parse_openapi_spec(spec_data: Dict[str, Any], base_url_override: Optional[st
                 "key": "bearerToken",
                 "value": "",
                 "type": "string"
+            },
+            {
+                "key": "lastCreatedId",
+                "value": "1",
+                "type": "string"
             }
         ],
         "item": []
@@ -189,49 +221,45 @@ def parse_openapi_spec(spec_data: Dict[str, Any], base_url_override: Optional[st
     paths = spec_data.get("paths", {})
 
     for path, path_item in paths.items():
-        for method in ("get", "post", "put", "patch", "delete", "options", "head"):
+        for method in ("get", "post", "put", "patch", "delete"):
             if method not in path_item:
                 continue
 
             op = path_item[method]
             summary = op.get("summary") or f"{method.upper()} {path}"
-            tags = op.get("tags") or ["Default"]
-            tag_name = tags[0]
+            tags = op.get("tags", ["Default"])
+            tag_name = tags[0] if tags else "Default"
 
-            # Request Headers
+            # Parse headers
             headers = [
                 {"key": "Content-Type", "value": "application/json", "type": "text"},
                 {"key": "Accept", "value": "application/json", "type": "text"}
             ]
 
-            # Query Parameters
+            # Parse Query Parameters
             query_params = []
-            for param in op.get("parameters", []):
-                p_in = param.get("in")
-                if p_in == "query":
+            for p in op.get("parameters", []):
+                if p.get("in") == "query":
                     query_params.append({
-                        "key": param.get("name"),
-                        "value": str(param.get("example") or param.get("default", "")),
-                        "description": param.get("description", "")
+                        "key": p.get("name"),
+                        "value": str(p.get("example", "")),
+                        "description": p.get("description", "")
                     })
-                elif p_in == "header":
+                elif p.get("in") == "header":
                     headers.append({
-                        "key": param.get("name"),
-                        "value": str(param.get("example", "")),
-                        "type": "text",
-                        "description": param.get("description", "")
+                        "key": p.get("name"),
+                        "value": str(p.get("example", "")),
+                        "type": "text"
                     })
 
-            # Request Body
+            # Parse Request Body
             body_dict = None
             if method in ("post", "put", "patch"):
-                # OpenAPI 3.0 requestBody
                 req_body = op.get("requestBody", {})
                 content = req_body.get("content", {})
                 json_content = content.get("application/json", {})
                 schema = json_content.get("schema")
 
-                # Swagger 2.0 body parameter fallback
                 if not schema:
                     for p in op.get("parameters", []):
                         if p.get("in") == "body":
@@ -262,7 +290,7 @@ def parse_openapi_spec(spec_data: Dict[str, Any], base_url_override: Optional[st
             if query_params:
                 url_obj["query"] = query_params
 
-            # Status code for assertion
+            # Status code and response schema for assertion
             responses = op.get("responses", {})
             expected_status = 200
             for code_str in responses.keys():
@@ -270,6 +298,11 @@ def parse_openapi_spec(spec_data: Dict[str, Any], base_url_override: Optional[st
                     expected_status = int(code_str)
                     break
 
+            resp_info = responses.get(str(expected_status), {}) or responses.get("200", {}) or responses.get("201", {})
+            resp_schema = resp_info.get("content", {}).get("application/json", {}).get("schema")
+            if not resp_schema and "schema" in resp_info:
+                resp_schema = resp_info["schema"]
+
             postman_request = {
                 "name": summary,
                 "event": [
@@ -284,7 +317,10 @@ def parse_openapi_spec(spec_data: Dict[str, Any], base_url_override: Optional[st
                         "listen": "test",
                         "script": {
                             "type": "text/javascript",
-                            "exec": build_test_script(expected_status=expected_status)
+                            "exec": build_test_script(
+                                expected_status=expected_status,
+                                response_schema=resp_schema
+                            )
                         }
                     }
                 ],
@@ -304,11 +340,12 @@ def parse_openapi_spec(spec_data: Dict[str, Any], base_url_override: Optional[st
                 folders[tag_name] = []
             folders[tag_name].append(postman_request)
 
-    # Attach folders into collection
-    for folder_name, items in folders.items():
+    # Nest grouped requests into folder items
+    for folder_name, req_list in folders.items():
         collection["item"].append({
             "name": folder_name,
-            "item": items
+            "item": req_list,
+            "description": f"Endpoints grouped under {folder_name}"
         })
 
     return collection
@@ -317,38 +354,34 @@ def parse_openapi_spec(spec_data: Dict[str, Any], base_url_override: Optional[st
 def parse_har_file(har_data: Dict[str, Any], base_url_override: Optional[str] = None) -> Dict[str, Any]:
     """Parses HTTP Archive (.har) into a Postman Collection v2.1.0."""
     entries = har_data.get("log", {}).get("entries", [])
+    collection_name = "HAR Recorded API Collection"
+
+    base_url_default = base_url_override or "https://api.staging.enterprise.local"
+
     collection = {
         "info": {
             "_postman_id": generate_uuid(),
-            "name": "HAR Session API Replay",
-            "description": "Replay collection generated from production HAR network telemetry",
+            "name": collection_name,
+            "description": "Generated from HTTP Archive Network Trace",
             "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
         },
         "variable": [
-            {"key": "baseUrl", "value": base_url_override or "https://api.staging.enterprise.local", "type": "string"},
-            {"key": "bearerToken", "value": "", "type": "string"}
+            {"key": "baseUrl", "value": base_url_default, "type": "string"},
+            {"key": "bearerToken", "value": "", "type": "string"},
+            {"key": "lastCreatedId", "value": "1", "type": "string"}
         ],
         "item": []
     }
 
     requests_by_host: Dict[str, List[Dict[str, Any]]] = {}
 
-    for entry in entries:
-        req = entry.get("request", {})
-        resp = entry.get("response", {})
-        url_str = req.get("url", "")
+    for idx, e in enumerate(entries, 1):
+        req = e.get("request", {})
+        resp = e.get("response", {})
+        raw_url = req.get("url", "/")
         method = req.get("method", "GET").upper()
-
-        parsed_url = urlparse(url_str)
-        # Filter static files
-        if any(parsed_url.path.lower().endswith(ext) for ext in (".png", ".jpg", ".css", ".js", ".woff2", ".ico")):
-            continue
-
-        host = parsed_url.netloc or "DefaultHost"
-        path = parsed_url.path
-        query = parse_qs(parsed_url.query)
-
-        query_list = [{"key": k, "value": v[0] if v else ""} for k, v in query.items()]
+        p = urlparse(raw_url)
+        host = p.netloc or "Default"
 
         headers = []
         for h in req.get("headers", []):
@@ -356,19 +389,25 @@ def parse_har_file(har_data: Dict[str, Any], base_url_override: Optional[str] =
             if name.lower() not in ("cookie", "host", "content-length"):
                 headers.append({"key": name, "value": h.get("value", ""), "type": "text"})
 
+        path_segments = [seg for seg in p.path.strip("/").split("/") if seg]
+        url_obj = {
+            "raw": f"{{{{baseUrl}}}}{p.path}" + (f"?{p.query}" if p.query else ""),
+            "host": ["{{baseUrl}}"],
+            "path": path_segments
+        }
+
         body_dict = None
-        post_data = req.get("postData")
-        if post_data and post_data.get("text"):
+        post_data = req.get("postData", {})
+        if post_data.get("text"):
             body_dict = {
                 "mode": "raw",
-                "raw": post_data.get("text"),
+                "raw": post_data["text"],
                 "options": {"raw": {"language": "json"}}
             }
 
-        status_code = resp.get("status", 200)
-
+        expected_status = resp.get("status", 200) or 200
         postman_item = {
-            "name": f"{method} {path}",
+            "name": f"[{method}] {p.path or '/'}",
             "event": [
                 {
                     "listen": "prerequest",
@@ -376,21 +415,18 @@ def parse_har_file(har_data: Dict[str, Any], base_url_override: Optional[str] =
                 },
                 {
                     "listen": "test",
-                    "script": {"type": "text/javascript", "exec": build_test_script(expected_status=status_code)}
+                    "script": {"type": "text/javascript", "exec": build_test_script(expected_status=expected_status)}
                 }
             ],
             "request": {
                 "method": method,
                 "header": headers,
-                "url": {
-                    "raw": url_str,
-                    "host": [parsed_url.scheme + "://" + parsed_url.netloc],
-                    "path": [p for p in path.strip("/").split("/") if p],
-                    "query": query_list
-                }
+                "url": url_obj,
+                "description": f"Recorded step {idx}"
             },
             "response": []
         }
+
         if body_dict:
             postman_item["request"]["body"] = body_dict
 
@@ -398,8 +434,12 @@ def parse_har_file(har_data: Dict[str, Any], base_url_override: Optional[str] =
             requests_by_host[host] = []
         requests_by_host[host].append(postman_item)
 
-    for host_name, items in requests_by_host.items():
-        collection["item"].append({"name": host_name, "item": items})
+    for host, reqs in requests_by_host.items():
+        collection["item"].append({
+            "name": f"Host: {host}",
+            "item": reqs,
+            "description": f"Recorded requests against {host}"
+        })
 
     return collection
 
@@ -410,53 +450,178 @@ def generate_postman_environment(name: str = "Enterprise-Staging-Env", base_url:
         "id": generate_uuid(),
         "name": name,
         "values": [
-            {"key": "baseUrl", "value": base_url, "type": "default", "enabled": True},
-            {"key": "bearerToken", "value": "", "type": "secret", "enabled": True},
-            {"key": "lastCreatedId", "value": "", "type": "default", "enabled": True}
+            {"key": "baseUrl", "value": base_url, "enabled": True},
+            {"key": "bearerToken", "value": "", "enabled": True},
+            {"key": "lastCreatedId", "value": "1", "enabled": True},
+            {"key": "adminUser", "value": "qa_admin@enterprise.local", "enabled": True},
+            {"key": "adminPass", "value": "SecretVault#2026", "enabled": True}
         ],
         "_postman_variable_scope": "environment"
     }
 
 
-def get_sample_spec() -> Dict[str, Any]:
-    """Provides standard built-in OpenAPI 3.0 spec for testing & demonstration."""
-    return {
-        "openapi": "3.0.0",
-        "info": {
-            "title": "Enterprise E-Commerce & Auth Service",
-            "version": "1.0.0",
-            "description": "Sample API spec for Postman & JMeter automated generation"
-        },
-        "servers": [{"url": "https://api.staging.enterprise.local"}],
-        "paths": {
-            "/api/v1/auth/login": {
-                "post": {
-                    "tags": ["Authentication"],
-                    "summary": "Authenticate user and issue JWT token",
-                    "requestBody": {
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "type": "object",
-                                    "required": ["username", "password"],
-                                    "properties": {
-                                        "username": {"type": "string", "example": "admin_qa"},
-                                        "password": {"type": "string", "example": "SecretPass#2026"}
+def generate_ddt_dataset(domain: str = "ecommerce") -> List[Dict[str, Any]]:
+    """Generates companion Data-Driven Testing (DDT) matrix for Newman execution."""
+    if domain == "banking":
+        return [
+            {"scenario": "Valid Domestic Transfer", "sender": "ACC-101", "recipient": "ACC-902", "amount": 500000, "expectedStatus": 201},
+            {"scenario": "Zero Amount Boundary", "sender": "ACC-101", "recipient": "ACC-902", "amount": 0, "expectedStatus": 400},
+            {"scenario": "Negative Amount Attack", "sender": "ACC-101", "recipient": "ACC-902", "amount": -150000, "expectedStatus": 400},
+            {"scenario": "Exceed Daily Balance Limit", "sender": "ACC-101", "recipient": "ACC-902", "amount": 999999999, "expectedStatus": 422},
+            {"scenario": "Invalid Recipient Format", "sender": "ACC-101", "recipient": "<script>alert(1)</script>", "expectedStatus": 400}
+        ]
+    elif domain == "saas":
+        return [
+            {"scenario": "Standard Member Creation", "username": "member_valid", "role": "MEMBER", "priority": 10, "expectedStatus": 201},
+            {"scenario": "Admin Role Assignment", "username": "admin_chief", "role": "ADMIN", "priority": 1, "expectedStatus": 201},
+            {"scenario": "Empty Username Boundary", "username": "", "role": "MEMBER", "priority": 10, "expectedStatus": 400},
+            {"scenario": "SQLi Injection Probe", "username": "' OR '1'='1' --", "role": "MEMBER", "priority": 10, "expectedStatus": 400},
+            {"scenario": "Invalid Role Privilege", "username": "intruder_user", "role": "SUPER_ROOT_UNAUTHORIZED", "priority": 99, "expectedStatus": 403}
+        ]
+    else:  # ecommerce default
+        return [
+            {"scenario": "Valid Catalog Creation", "code": "SKU_AUTO_2026", "name": "Enterprise Quantum Server", "priority": 10, "expectedStatus": 201},
+            {"scenario": "Short Code Boundary (< 3 chars)", "code": "A1", "name": "Invalid Item", "priority": 5, "expectedStatus": 400},
+            {"scenario": "Max Length Code Boundary", "code": "SKU_MAX_CHARS_990000", "name": "Max Length Product", "priority": 50, "expectedStatus": 201},
+            {"scenario": "Empty Product Name", "code": "SKU_VALID_02", "name": "", "priority": 20, "expectedStatus": 400},
+            {"scenario": "XSS Script Body Injection", "code": "SKU_XSS_03", "name": "<script>alert('pwned')</script>", "priority": 1, "expectedStatus": 400}
+        ]
+
+
+def get_domain_spec(domain: str = "ecommerce") -> Dict[str, Any]:
+    """Autonomous Zero-Input Domain Spec Synthesizer."""
+    if domain == "banking":
+        return {
+            "openapi": "3.0.3",
+            "info": {
+                "title": "Enterprise Banking & Fund Transfer API",
+                "version": "2.4.0",
+                "description": "Production Banking API with OAuth2, Idempotent Transfers, and Audit Queries"
+            },
+            "servers": [{"url": "https://api.banking.staging.local"}],
+            "paths": {
+                "/api/v1/auth/token": {
+                    "post": {
+                        "tags": ["Authentication"],
+                        "summary": "Obtain Bearer JWT Token",
+                        "requestBody": {
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "type": "object",
+                                        "required": ["clientId", "clientSecret"],
+                                        "properties": {
+                                            "clientId": {"type": "string", "example": "bank_admin"},
+                                            "clientSecret": {"type": "string", "example": "SecretVault#2026"}
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        "responses": {
+                            "200": {
+                                "description": "Token granted",
+                                "content": {
+                                    "application/json": {
+                                        "schema": {
+                                            "type": "object",
+                                            "required": ["token", "tokenType", "expiresIn"],
+                                            "properties": {
+                                                "token": {"type": "string", "example": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.e30.fake"},
+                                                "tokenType": {"type": "string", "example": "Bearer"},
+                                                "expiresIn": {"type": "integer", "example": 3600}
+                                            }
+                                        }
                                     }
                                 }
                             }
                         }
-                    },
-                    "responses": {
-                        "200": {
-                            "description": "JWT Token generated successfully",
+                    }
+                },
+                "/api/v1/accounts/me": {
+                    "get": {
+                        "tags": ["Account Management"],
+                        "summary": "Get Account Balance & Profile",
+                        "responses": {
+                            "200": {
+                                "description": "Account details retrieved",
+                                "content": {
+                                    "application/json": {
+                                        "schema": {
+                                            "type": "object",
+                                            "required": ["accountNumber", "balance", "currency"],
+                                            "properties": {
+                                                "accountNumber": {"type": "string", "example": "ACC-889922"},
+                                                "balance": {"type": "number", "example": 25000000.0},
+                                                "currency": {"type": "string", "example": "VND"}
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+                "/api/v1/transfers": {
+                    "post": {
+                        "tags": ["Fund Transfers"],
+                        "summary": "Execute Idempotent Fund Transfer",
+                        "requestBody": {
                             "content": {
                                 "application/json": {
                                     "schema": {
                                         "type": "object",
+                                        "required": ["recipientAccount", "amount", "idempotencyKey"],
                                         "properties": {
-                                            "token": {"type": "string"},
-                                            "expires_in": {"type": "integer"}
+                                            "recipientAccount": {"type": "string", "example": "ACC-990011"},
+                                            "amount": {"type": "number", "example": 500000.0},
+                                            "idempotencyKey": {"type": "string", "example": "{{$guid}}"},
+                                            "remark": {"type": "string", "example": "Payment for invoice"}
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        "responses": {
+                            "201": {
+                                "description": "Transfer queued or completed",
+                                "content": {
+                                    "application/json": {
+                                        "schema": {
+                                            "type": "object",
+                                            "required": ["id", "status", "transactionRef"],
+                                            "properties": {
+                                                "id": {"type": "string", "example": "TX-998822"},
+                                                "status": {"type": "string", "example": "COMPLETED"},
+                                                "transactionRef": {"type": "string", "example": "REF-AUTO-2026"}
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+                "/api/v1/transfers/{id}": {
+                    "get": {
+                        "tags": ["Fund Transfers"],
+                        "summary": "Audit Transfer Status by ID",
+                        "parameters": [
+                            {"name": "id", "in": "path", "required": True, "example": "{{lastCreatedId}}"}
+                        ],
+                        "responses": {
+                            "200": {
+                                "description": "Transfer status verified",
+                                "content": {
+                                    "application/json": {
+                                        "schema": {
+                                            "type": "object",
+                                            "required": ["id", "status", "amount"],
+                                            "properties": {
+                                                "id": {"type": "string", "example": "TX-998822"},
+                                                "status": {"type": "string", "example": "COMPLETED"},
+                                                "amount": {"type": "number", "example": 500000.0}
+                                            }
                                         }
                                     }
                                 }
@@ -464,142 +629,294 @@ def get_sample_spec() -> Dict[str, Any]:
                         }
                     }
                 }
+            }
+        }
+    elif domain == "saas":
+        return {
+            "openapi": "3.0.3",
+            "info": {
+                "title": "Enterprise SaaS Tenant & User RBAC API",
+                "version": "1.8.0",
+                "description": "Multi-Tenant SaaS Management Suite"
             },
-            "/api/v1/categories": {
-                "get": {
-                    "tags": ["Category Management"],
-                    "summary": "List categories with pagination",
-                    "parameters": [
-                        {"name": "page", "in": "query", "example": 1},
-                        {"name": "limit", "in": "query", "example": 20}
-                    ],
-                    "responses": {"200": {"description": "List of categories"}}
-                },
-                "post": {
-                    "tags": ["Category Management"],
-                    "summary": "Create a new category",
-                    "requestBody": {
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "type": "object",
-                                    "required": ["code", "name"],
-                                    "properties": {
-                                        "code": {"type": "string", "minLength": 3, "maxLength": 20},
-                                        "name": {"type": "string", "minLength": 1, "maxLength": 100},
-                                        "priority": {"type": "integer", "minimum": 1, "maximum": 100}
+            "servers": [{"url": "https://api.saas.staging.local"}],
+            "paths": {
+                "/api/v1/auth/login": {
+                    "post": {
+                        "tags": ["Identity"],
+                        "summary": "Tenant Admin Login",
+                        "requestBody": {
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "type": "object",
+                                        "required": ["tenantId", "username", "password"],
+                                        "properties": {
+                                            "tenantId": {"type": "string", "example": "tenant_enterprise"},
+                                            "username": {"type": "string", "example": "admin"},
+                                            "password": {"type": "string", "example": "SecretPass#2026"}
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        "responses": {
+                            "200": {
+                                "description": "Login successful",
+                                "content": {
+                                    "application/json": {
+                                        "schema": {
+                                            "type": "object",
+                                            "required": ["token", "role"],
+                                            "properties": {
+                                                "token": {"type": "string", "example": "jwt.tenant.token"},
+                                                "role": {"type": "string", "example": "TENANT_ADMIN"}
+                                            }
+                                        }
                                     }
                                 }
                             }
                         }
+                    }
+                },
+                "/api/v1/users": {
+                    "get": {
+                        "tags": ["User Directory"],
+                        "summary": "List Active Tenant Users",
+                        "responses": {"200": {"description": "Users list"}}
                     },
-                    "responses": {"201": {"description": "Category created successfully"}}
+                    "post": {
+                        "tags": ["User Directory"],
+                        "summary": "Provision New Tenant Member",
+                        "requestBody": {
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "type": "object",
+                                        "required": ["email", "role"],
+                                        "properties": {
+                                            "email": {"type": "string", "example": "user_auto@tenant.com"},
+                                            "role": {"type": "string", "example": "MEMBER"}
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        "responses": {
+                            "201": {
+                                "description": "User created",
+                                "content": {
+                                    "application/json": {
+                                        "schema": {
+                                            "type": "object",
+                                            "required": ["id", "email"],
+                                            "properties": {
+                                                "id": {"type": "string", "example": "USR-101"},
+                                                "email": {"type": "string", "example": "user_auto@tenant.com"}
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+                "/api/v1/users/{id}": {
+                    "delete": {
+                        "tags": ["User Directory"],
+                        "summary": "Deprovision Member (Teardown Cleanup)",
+                        "parameters": [{"name": "id", "in": "path", "required": True, "example": "{{lastCreatedId}}"}],
+                        "responses": {"204": {"description": "User deprovisioned"}}
+                    }
                 }
+            }
+        }
+    else:  # E-commerce default
+        return {
+            "openapi": "3.0.3",
+            "info": {
+                "title": "Enterprise E-Commerce Core API",
+                "version": "3.2.0",
+                "description": "Enterprise E-Commerce Commerce Engine API with Auth, Search, Cart, Order, and Teardown"
             },
-            "/api/v1/categories/{id}": {
-                "delete": {
-                    "tags": ["Category Management"],
-                    "summary": "Delete category by ID (Idempotent cleanup)",
-                    "parameters": [
-                        {"name": "id", "in": "path", "required": True, "example": "{{lastCreatedId}}"}
-                    ],
-                    "responses": {"204": {"description": "Deleted"}}
+            "servers": [{"url": "https://api.staging.enterprise.local"}],
+            "paths": {
+                "/api/v1/auth/login": {
+                    "post": {
+                        "tags": ["Authentication"],
+                        "summary": "User Authentication (Login)",
+                        "requestBody": {
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "type": "object",
+                                        "required": ["username", "password"],
+                                        "properties": {
+                                            "username": {"type": "string", "example": "admin"},
+                                            "password": {"type": "string", "example": "SecretVault#2026"}
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        "responses": {
+                            "200": {
+                                "description": "Successful Login",
+                                "content": {
+                                    "application/json": {
+                                        "schema": {
+                                            "type": "object",
+                                            "required": ["token", "tokenType"],
+                                            "properties": {
+                                                "token": {"type": "string", "example": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.e30.fake"},
+                                                "tokenType": {"type": "string", "example": "Bearer"}
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+                "/api/v1/catalogs": {
+                    "get": {
+                        "tags": ["Catalog Service"],
+                        "summary": "Search Product Catalogs",
+                        "parameters": [
+                            {"name": "query", "in": "query", "example": "server"},
+                            {"name": "limit", "in": "query", "example": "20"}
+                        ],
+                        "responses": {
+                            "200": {
+                                "description": "Catalogs search result",
+                                "content": {
+                                    "application/json": {
+                                        "schema": {
+                                            "type": "object",
+                                            "required": ["items", "total"],
+                                            "properties": {
+                                                "items": {"type": "array", "items": {"type": "object"}},
+                                                "total": {"type": "integer", "example": 42}
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    "post": {
+                        "tags": ["Catalog Service"],
+                        "summary": "Create Product Item",
+                        "requestBody": {
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "type": "object",
+                                        "required": ["code", "name"],
+                                        "properties": {
+                                            "code": {"type": "string", "example": "SKU_AUTO_2026"},
+                                            "name": {"type": "string", "example": "Enterprise Quantum Server"},
+                                            "priority": {"type": "integer", "example": 10}
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        "responses": {
+                            "201": {
+                                "description": "Product created",
+                                "content": {
+                                    "application/json": {
+                                        "schema": {
+                                            "type": "object",
+                                            "required": ["id", "code"],
+                                            "properties": {
+                                                "id": {"type": "string", "example": "PRD-998811"},
+                                                "code": {"type": "string", "example": "SKU_AUTO_2026"}
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+                "/api/v1/catalogs/{id}": {
+                    "delete": {
+                        "tags": ["Catalog Service"],
+                        "summary": "Delete Catalog Item (Idempotent Teardown)",
+                        "parameters": [
+                            {"name": "id", "in": "path", "required": True, "example": "{{lastCreatedId}}"}
+                        ],
+                        "responses": {"204": {"description": "Item deleted"}}
+                    }
                 }
             }
         }
-    }
 
 
 def main():
     parser = argparse.ArgumentParser(
-        description="Export OpenAPI or HAR to Postman Collection v2.1.0 with auto-asserts & token chaining."
+        description="Export OpenAPI, HAR, or Zero-Input Domain Synthesis to Postman Collection v2.1.0."
     )
     parser.add_argument("--spec", "-s", help="Path to OpenAPI / Swagger JSON specification file.")
     parser.add_argument("--har", help="Path to HTTP Archive (.har) recording file.")
+    parser.add_argument("--domain", choices=["ecommerce", "banking", "saas"], default="ecommerce", help="Zero-input domain synthesizer template. Default: ecommerce.")
     parser.add_argument("--base-url", "-b", help="Override base URL for {{baseUrl}} parameter.")
     parser.add_argument("--output", "-o", help="Target output Postman Collection file path (.json).")
     parser.add_argument("--env-output", help="Optional companion Postman Environment output file (.json).")
-    parser.add_argument("--sample", action="store_true", help="Generate sample collection using built-in enterprise schema.")
-    parser.add_argument("--portman", action="store_true", help="Delegate conversion to @apideck/portman via npx (contract-driven assertions).")
-    parser.add_argument("--newman", action="store_true", help="Automatically trigger headless Newman execution on the generated collection.")
+    parser.add_argument("--ddt-output", help="Optional companion Data-Driven Testing (DDT) CSV file for Newman.")
+    parser.add_argument("--sample", action="store_true", help="Generate sample collection using domain synthesizer.")
 
     args = parser.parse_args()
 
-    # If --portman is requested, run via npx @apideck/portman
-    if args.portman:
-        import subprocess
-        import tempfile
-        import shutil
-
-        target_output = args.output or "postman_collection.json"
-        spec_path = args.spec
-
-        # Handle sample spec if no explicit spec file provided
-        temp_spec_file = None
-        if not spec_path or args.sample:
-            fd, temp_spec_file = tempfile.mkstemp(suffix=".json", prefix="sample_spec_")
-            with os.fdopen(fd, "w", encoding="utf-8") as f:
-                json.dump(get_sample_spec(), f)
-            spec_path = temp_spec_file
-
-        portman_cmd = ["npx", "--yes", "@apideck/portman", "-l", spec_path, "-o", target_output]
-        if args.base_url:
-            portman_cmd.extend(["-b", args.base_url])
-        if args.newman:
-            portman_cmd.extend(["-n"])
-
-        print(f"⚡ [PORTMAN BRIDGE] Executing: {' '.join(portman_cmd)}")
-        try:
-            res = subprocess.run(portman_cmd, check=True)
-            print(f"✅ [PORTMAN SUCCESS] Collection generated via @apideck/portman: {target_output}")
-            if temp_spec_file and os.path.exists(temp_spec_file):
-                os.remove(temp_spec_file)
-            return
-        except (subprocess.CalledProcessError, FileNotFoundError) as e:
-            print(f"⚠️ [PORTMAN FALLBACK] Could not run npx portman ({e}). Falling back to internal Pure-Python engine.")
-            if temp_spec_file and os.path.exists(temp_spec_file):
-                os.remove(temp_spec_file)
-
-    if args.sample or (not args.spec and not args.har):
-        spec_data = get_sample_spec()
-        collection = parse_openapi_spec(spec_data, base_url_override=args.base_url)
-    elif args.har:
-        if not os.path.exists(args.har):
-            print(f"❌ Error: HAR file not found: {args.har}", file=sys.stderr)
-            sys.exit(1)
+    # Determine data source
+    if args.har and os.path.exists(args.har):
         with open(args.har, "r", encoding="utf-8") as f:
             har_data = json.load(f)
         collection = parse_har_file(har_data, base_url_override=args.base_url)
-    else:
-        if not os.path.exists(args.spec):
-            print(f"❌ Error: OpenAPI specification file not found: {args.spec}", file=sys.stderr)
-            sys.exit(1)
+        active_domain = "har"
+    elif args.spec and os.path.exists(args.spec):
         with open(args.spec, "r", encoding="utf-8") as f:
             spec_data = json.load(f)
         collection = parse_openapi_spec(spec_data, base_url_override=args.base_url)
+        active_domain = "spec"
+    else:
+        # Autonomous Zero-Input Synthesis (User provided no file!)
+        spec_data = get_domain_spec(args.domain)
+        collection = parse_openapi_spec(spec_data, base_url_override=args.base_url)
+        active_domain = args.domain
+        print(f"✨ [ZERO-INPUT SYNTHESIS] Synthesized complete '{args.domain.upper()}' Enterprise API Suite from scratch!")
 
-    out_json = json.dumps(collection, indent=2, ensure_ascii=False)
+    target_output = args.output or f"{active_domain}_collection.json"
+    out_dir = os.path.dirname(os.path.abspath(target_output))
+    if out_dir and not os.path.exists(out_dir):
+        os.makedirs(out_dir, exist_ok=True)
 
-    if args.output:
-        out_dir = os.path.dirname(os.path.abspath(args.output))
-        if out_dir and not os.path.exists(out_dir):
-            os.makedirs(out_dir, exist_ok=True)
-        with open(args.output, "w", encoding="utf-8") as f:
-            f.write(out_json)
-        print(f"✅ [POSTMAN EXPORT] Successfully created Postman Collection v2.1.0: {args.output}")
-    else:
-        print(out_json)
+    with open(target_output, "w", encoding="utf-8") as f:
+        json.dump(collection, f, indent=2, ensure_ascii=False)
+    print(f"✅ [POSTMAN EXPORT] Successfully created Postman Collection v2.1.0: {target_output}")
+    print(f"🛡️ Embedded: Pre-request Nonce & Auth | SLA Tests (< 1000ms) | AJV JSON Schema Validation | Token Chaining")
 
     # Optional Companion Environment
-    if args.env_output:
-        base_u = args.base_url or "https://api.staging.enterprise.local"
-        env_dict = generate_postman_environment(name="Agent-QA-Staging-Env", base_url=base_u)
-        env_dir = os.path.dirname(os.path.abspath(args.env_output))
-        if env_dir and not os.path.exists(env_dir):
-            os.makedirs(env_dir, exist_ok=True)
-        with open(args.env_output, "w", encoding="utf-8") as f:
-            json.dump(env_dict, f, indent=2, ensure_ascii=False)
-        print(f"✅ [ENVIRONMENT EXPORT] Successfully created Postman Environment: {args.env_output}")
+    env_file = args.env_output or (os.path.splitext(target_output)[0] + "_env.json")
+    base_u = args.base_url or "https://api.staging.enterprise.local"
+    env_dict = generate_postman_environment(name=f"Synapse-{active_domain.capitalize()}-Env", base_url=base_u)
+    with open(env_file, "w", encoding="utf-8") as f:
+        json.dump(env_dict, f, indent=2, ensure_ascii=False)
+    print(f"🌐 [ENVIRONMENT EXPORT] Successfully created Postman Environment: {env_file}")
+
+    # Optional Companion Data-Driven Testing (DDT) CSV
+    if args.ddt_output or args.sample:
+        ddt_file = args.ddt_output or (os.path.splitext(target_output)[0] + "_ddt.csv")
+        dataset = generate_ddt_dataset(args.domain if active_domain in ("ecommerce", "banking", "saas") else "ecommerce")
+        if dataset:
+            with open(ddt_file, "w", encoding="utf-8", newline="") as f:
+                writer = csv.DictWriter(f, fieldnames=list(dataset[0].keys()))
+                writer.writeheader()
+                writer.writerows(dataset)
+            print(f"📊 [DDT EXPORT] Successfully created Data-Driven Testing CSV: {ddt_file}")
+            print(f"🚀 Execution Command: newman run \"{target_output}\" -e \"{env_file}\" -d \"{ddt_file}\"")
 
 
 if __name__ == "__main__":