@shortlink-org/portolan 0.1.0

package/plugins/extract-watermill/extract_test.go

@@ -0,0 +1,234 @@
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/shortlink-org/portolan/catalog"
+	"github.com/shortlink-org/portolan/plugin"
+)
+
+func write(t *testing.T, root, name, contents string) {
+	t.Helper()
+	path := filepath.Join(root, name)
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(path, []byte(contents), 0o644); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func extracted(t *testing.T, root string) (catalog.Catalog, plugin.Response) {
+	t.Helper()
+	resp, err := extract(plugin.Input{Root: root, Commit: "abc", GeneratedAt: "2026-01-01T00:00:00Z"}, Options{Context: "sales", Service: "mailer"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var out catalog.Catalog
+	if err := json.Unmarshal([]byte(resp.Files[0].Contents), &out); err != nil {
+		t.Fatal(err)
+	}
+	return out, resp
+}
+
+func TestExtractsConfiguredHandlerAndHelperPublications(t *testing.T) {
+	root := t.TempDir()
+	write(t, root, "go.mod", "module example.com/mailer\n")
+	write(t, root, "config/config.go", `package config
+type Bus struct {
+  Input string `+"`envconfig:\"MAIL_INPUT_TOPIC\" default:\"mail.input\"`"+`
+  Output string `+"`envconfig:\"MAIL_OUTPUT_TOPIC\" default:\"mail.output\"`"+`
+  Errors string `+"`envconfig:\"MAIL_ERROR_TOPIC\" default:\"mail.error\"`"+`
+}
+`)
+	write(t, root, "api/messages.go", `package api
+type Input struct {
+  ID string `+"`json:\"id\"`"+`
+  Valid bool `+"`json:\"valid\"`"+`
+}
+type Output struct { Accepted bool `+"`json:\"accepted\"`"+` }
+type Failure struct { Reason string `+"`json:\"reason\"`"+` }
+`)
+	write(t, root, "app/router.go", `package app
+import (
+  "encoding/json"
+  "github.com/ThreeDotsLabs/watermill"
+  "github.com/ThreeDotsLabs/watermill/message"
+  "example.com/mailer/api"
+  "example.com/mailer/config"
+)
+const ConsumerGroup = "mail-workers"
+func NewSubscriber(config.Bus, string) (message.Subscriber, error) { return nil, nil }
+func publishFailure(pub message.Publisher, topic string) error {
+  value := api.Failure{Reason: "bad"}
+  payload, _ := json.Marshal(value)
+  msg := message.NewMessage(watermill.NewUUID(), payload)
+  return pub.Publish(topic, msg)
+}
+func Register(r *message.Router, cfg config.Bus, pub message.Publisher) {
+  sub, _ := NewSubscriber(cfg, ConsumerGroup)
+  handlerName := "mail_router"
+  r.AddHandler(handlerName, cfg.Input, sub, "", nil, func(msg *message.Message) ([]*message.Message, error) {
+    var input api.Input
+    _ = json.Unmarshal(msg.Payload, &input)
+    if !input.Valid {
+      _ = publishFailure(pub, cfg.Errors)
+      return nil, nil
+    }
+    value := api.Output{Accepted: true}
+    payload, _ := json.Marshal(value)
+    out := message.NewMessage(watermill.NewUUID(), payload)
+    _ = pub.Publish(cfg.Output, out)
+    return nil, nil
+  })
+}
+`)
+
+	out, _ := extracted(t, root)
+	service := out.Contexts[0].Services[0]
+	if len(service.Channels) != 3 {
+		t.Fatalf("channels = %+v", service.Channels)
+	}
+	byAddress := map[string]catalog.Channel{}
+	for _, channel := range service.Channels {
+		byAddress[channel.Address] = channel
+	}
+	if got := byAddress["mail.input"].Messages[0]; got.Direction != catalog.ChannelReceive || got.Name != "Input" || !strings.Contains(got.Doc, "id string") {
+		t.Fatalf("input = %+v", got)
+	}
+	if got := byAddress["mail.output"].Messages[0]; got.Direction != catalog.ChannelSend || got.Name != "Output" {
+		t.Fatalf("output = %+v", got)
+	}
+	if got := byAddress["mail.error"].Messages[0]; got.Name != "Failure" || !strings.Contains(got.Doc, "reason string") {
+		t.Fatalf("error = %+v", got)
+	}
+	if !strings.Contains(byAddress["mail.input"].Doc, "MAIL_INPUT_TOPIC") {
+		t.Fatalf("channel doc = %q", byAddress["mail.input"].Doc)
+	}
+	if len(out.Flows) != 1 {
+		t.Fatalf("flows = %+v", out.Flows)
+	}
+	flow := out.Flows[0]
+	if len(flow.Steps) != 2 || !strings.Contains(flow.Steps[0].(*catalog.Step).Note, "mail-workers") {
+		t.Fatalf("flow = %+v", flow)
+	}
+	branches := flow.Steps[1].(*catalog.Alt).Branches
+	if len(branches) != 2 || branches[0].Title != "!input.Valid" || branches[1].Title != "not (!input.Valid)" || !branches[0].Terminal {
+		t.Fatalf("branches = %+v", branches)
+	}
+	receive := flow.Steps[0].(*catalog.Step).Handoff
+	errorSend := branches[0].Steps[0].(*catalog.Step).Handoff
+	successSend := branches[1].Steps[0].(*catalog.Step).Handoff
+	if receive == nil || receive.Direction != "receive" || receive.Transport != "watermill" || receive.Channel != "mail.input" {
+		t.Fatalf("receive handoff = %+v", receive)
+	}
+	if errorSend == nil || errorSend.Direction != "send" || errorSend.Channel != "mail.error" || successSend == nil || successSend.Channel != "mail.output" {
+		t.Fatalf("publish handoffs = error %+v, success %+v", errorSend, successSend)
+	}
+}
+
+func TestExtractsNamedNoPublisherHandler(t *testing.T) {
+	root := t.TempDir()
+	write(t, root, "go.mod", "module example.com/consumer\n")
+	write(t, root, "consumer.go", `package consumer
+import (
+  "encoding/json"
+  "github.com/ThreeDotsLabs/watermill/message"
+)
+type Notice struct { Code string `+"`json:\"code\"`"+` }
+func consume(msg *message.Message) error {
+  var notice Notice
+  return json.Unmarshal(msg.Payload, &notice)
+}
+func Register(r *message.Router, sub message.Subscriber) {
+  r.AddNoPublisherHandler("notice_handler", "notice.input", sub, consume)
+}
+`)
+
+	out, _ := extracted(t, root)
+	service := out.Contexts[0].Services[0]
+	if len(service.Channels) != 1 || service.Channels[0].Messages[0].Name != "Notice" {
+		t.Fatalf("channels = %+v", service.Channels)
+	}
+	if len(out.Flows) != 1 || len(out.Flows[0].Steps) != 1 {
+		t.Fatalf("flows = %+v", out.Flows)
+	}
+	if got := out.Flows[0].Steps[0].(*catalog.Step).ContinuesAt; got != "consume" {
+		t.Fatalf("handler continuation = %q", got)
+	}
+	if got := out.Flows[0].Steps[0].(*catalog.Step).Handoff; got == nil || got.Kind != "message" || got.Channel != "notice.input" || got.Direction != "receive" {
+		t.Fatalf("handler handoff = %+v", got)
+	}
+}
+
+func TestExtractsGenericCQRSProcessors(t *testing.T) {
+	root := t.TempDir()
+	write(t, root, "go.mod", "module example.com/cqrsapp\n")
+	write(t, root, "cqrs.go", `package cqrsapp
+import (
+  "context"
+  "github.com/ThreeDotsLabs/watermill/components/cqrs"
+  "github.com/ThreeDotsLabs/watermill/message"
+)
+type OrderPlaced struct { OrderID string `+"`json:\"order_id\"`"+` }
+type BookOrder struct { CustomerID string `+"`json:\"customer_id\"`"+` }
+func Register(router *message.Router) {
+  events, _ := cqrs.NewEventProcessorWithConfig(router, cqrs.EventProcessorConfig{
+    GenerateSubscribeTopic: func(cqrs.EventProcessorGenerateSubscribeTopicParams) (string, error) { return "domain.events", nil },
+  })
+  project := cqrs.NewEventHandler("project_order", func(ctx context.Context, event *OrderPlaced) error { return nil })
+  _ = events.AddHandlers(project)
+
+  commands, _ := cqrs.NewCommandProcessorWithConfig(router, cqrs.CommandProcessorConfig{
+    GenerateSubscribeTopic: func(params cqrs.CommandProcessorGenerateSubscribeTopicParams) (string, error) { return params.CommandName, nil },
+  })
+  book := cqrs.NewCommandHandler("book_order", func(ctx context.Context, command *BookOrder) error { return nil })
+  _, _ = commands.AddHandler(book)
+}
+`)
+
+	out, _ := extracted(t, root)
+	service := out.Contexts[0].Services[0]
+	if len(service.Channels) != 2 {
+		t.Fatalf("channels = %+v", service.Channels)
+	}
+	byAddress := map[string]catalog.Channel{}
+	for _, channel := range service.Channels {
+		byAddress[channel.Address] = channel
+	}
+	if got := byAddress["domain.events"].Messages[0]; got.Name != "OrderPlaced" || got.Direction != catalog.ChannelReceive {
+		t.Fatalf("event = %+v", got)
+	}
+	if got := byAddress["BookOrder"].Messages[0]; got.Name != "BookOrder" || got.Direction != catalog.ChannelReceive {
+		t.Fatalf("command = %+v", got)
+	}
+	if len(out.Flows) != 2 {
+		t.Fatalf("flows = %+v", out.Flows)
+	}
+}
+
+func TestBranchesRequireSourceBackedConditions(t *testing.T) {
+	unstructured := []publication{
+		{topic: topic{address: "one"}, payload: "One"},
+		{topic: topic{address: "two"}, payload: "Two"},
+	}
+	if structuredBranches(unstructured) {
+		t.Fatal("two publications without control-flow evidence became an alt")
+	}
+
+	structured := []publication{
+		{topic: topic{address: "errors"}, conditions: []string{"ready", "err != nil"}},
+		{topic: topic{address: "success"}, conditions: []string{"ready", "not (err != nil)"}},
+	}
+	if !structuredBranches(structured) {
+		t.Fatal("complementary source paths did not become an alt")
+	}
+	got := branchConditions(structured)
+	if got[0] != "err != nil" || got[1] != "not (err != nil)" {
+		t.Fatalf("branch conditions = %v", got)
+	}
+}

package/plugins/extract-watermill/main.go

@@ -0,0 +1,41 @@
+// Package main is portolan-extract-watermill: Watermill router declarations
+// and publications in a Go repository in, channels and source-backed flows out.
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+
+	"github.com/shortlink-org/portolan/internal/goscan"
+	"github.com/shortlink-org/portolan/plugin"
+)
+
+type Options struct {
+	Context string `json:"context"`
+	Service string `json:"service"`
+	Out     string `json:"out,omitempty"`
+}
+
+func main() {
+	if err := run(os.Stdin, os.Stdout); err != nil {
+		fmt.Fprintln(os.Stderr, "portolan-extract-watermill:", err)
+		os.Exit(1)
+	}
+}
+
+func run(stdin io.Reader, stdout io.Writer) error {
+	return plugin.Serve(stdin, stdout, descriptor(), func(req plugin.Request, opts Options) (plugin.Response, error) {
+		if req.Input.Root == "" {
+			return plugin.Response{}, fmt.Errorf("no input root: an extractor has nothing to read")
+		}
+		if opts.Context == "" {
+			opts.Context = goscan.Slug(filepath.Base(req.Input.Root))
+		}
+		if opts.Service == "" {
+			opts.Service = goscan.Slug(filepath.Base(req.Input.Root))
+		}
+		return extract(req.Input, opts)
+	})
+}

package/plugins/extract-watermill/options.schema.json

@@ -0,0 +1,21 @@
+{
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "context": {
+      "type": "string",
+      "description": "Slug of the top-level group that owns the component. Defaults to the input directory name.",
+      "examples": ["avia"]
+    },
+    "service": {
+      "type": "string",
+      "description": "Slug of the component that registers Watermill handlers or publishes messages. Defaults to the input directory name.",
+      "examples": ["billing"]
+    },
+    "out": {
+      "type": "string",
+      "description": "Name of the fragment file inside the step output directory.",
+      "default": "watermill.json"
+    }
+  }
+}

package/plugins/extract-wsdl/describe.go

@@ -0,0 +1,19 @@
+package main
+
+import (
+	_ "embed"
+
+	"github.com/shortlink-org/portolan/plugin"
+)
+
+//go:embed options.schema.json
+var optionsSchema []byte
+
+func descriptor() plugin.Descriptor {
+	return plugin.Descriptor{
+		Name:    "extract-wsdl",
+		Summary: "Reads WSDL services, SOAP bindings, operations, messages, faults, and local XSD shapes.",
+		Phases:  []string{plugin.PhaseExtract},
+		Options: optionsSchema,
+	}
+}

package/plugins/extract-wsdl/describe_test.go

@@ -0,0 +1,11 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/shortlink-org/portolan/plugin/schematest"
+)
+
+func TestOptionsSchemaMatchesStruct(t *testing.T) {
+	schematest.Check(t, optionsSchema, Options{})
+}

package/plugins/extract-wsdl/extract.go

@@ -0,0 +1,148 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"sort"
+	"strings"
+
+	"github.com/shortlink-org/portolan/catalog"
+	"github.com/shortlink-org/portolan/internal/wsdl"
+	"github.com/shortlink-org/portolan/plugin"
+)
+
+func extract(in plugin.Input, opts Options) (plugin.Response, error) {
+	if opts.Mode != "" && opts.Mode != "service" && opts.Mode != "external" {
+		return plugin.Response{}, fmt.Errorf("mode %q is not service or external", opts.Mode)
+	}
+	if opts.External != "" && strings.Contains(opts.External, ".") {
+		return plugin.Response{}, fmt.Errorf("external %q has a dot in its id", opts.External)
+	}
+	var result wsdl.Result
+	var err error
+	if opts.Spec != "" {
+		result, err = wsdl.Read(in.Root, opts.Spec)
+	} else {
+		result, err = wsdl.Discover(in.Root)
+	}
+	if err != nil {
+		return plugin.Response{}, err
+	}
+	b := &plugin.Builder{}
+	for _, warning := range result.Warnings {
+		b.Warn(in.Root, warning)
+	}
+	fragment := catalog.Catalog{
+		GeneratedAt: in.GeneratedAt, Commit: in.Commit,
+		Contexts: []catalog.BoundedContext{}, Defs: map[string]catalog.TypeDef{},
+		Flows: []catalog.Flow{}, Adrs: []catalog.Adr{}, Externals: []catalog.External{},
+	}
+	apiIDs := wsdl.APIIDs(result.Contracts)
+	if opts.Mode == "external" || opts.External != "" {
+		fragment.Externals = externalContracts(result.Contracts, apiIDs, opts)
+	} else {
+		var provides []catalog.RpcService
+		for _, contract := range result.Contracts {
+			api := apiOf(contract, apiIDs, opts, len(result.Contracts))
+			provides = append(provides, servicesOf(contract, api)...)
+		}
+		sort.Slice(provides, func(i, j int) bool { return provides[i].ID < provides[j].ID })
+		fragment.Contexts = []catalog.BoundedContext{{
+			ID: opts.Context, Slug: opts.Context,
+			Services: []catalog.Service{{
+				ID: opts.Context + "." + opts.Service, Slug: opts.Service,
+				Provides: provides, Consumes: []catalog.RpcCall{}, Aggregates: []catalog.Aggregate{},
+			}},
+		}}
+	}
+	if len(result.Contracts) == 0 {
+		b.Warn(in.Root, "no WSDL service or port type was found")
+	}
+	encoded, err := json.MarshalIndent(fragment, "", "  ")
+	if err != nil {
+		return plugin.Response{}, err
+	}
+	b.File(firstNonEmpty(opts.Out, "wsdl.json"), string(encoded)+"\n")
+	return b.Response(), nil
+}
+
+func externalContracts(contracts []wsdl.Contract, apiIDs map[string]string, opts Options) []catalog.External {
+	byID := map[string]*catalog.External{}
+	for _, contract := range contracts {
+		api := apiOf(contract, apiIDs, opts, len(contracts))
+		id := firstNonEmpty(opts.External, opts.Externals[api], wsdl.ExternalID(contract))
+		external := byID[id]
+		if external == nil {
+			external = &catalog.External{
+				ID: id, Slug: id,
+				Name:    firstNonEmpty(opts.ExternalName, contract.Name),
+				Summary: firstNonEmpty(opts.ExternalSummary, contract.Summary),
+				URL:     opts.ExternalURL, Provides: []catalog.RpcService{},
+			}
+			byID[id] = external
+		}
+		if external.URL == "" {
+			for _, iface := range contract.Interfaces {
+				if iface.Endpoint != "" {
+					external.URL = iface.Endpoint
+					break
+				}
+			}
+		}
+		external.Provides = append(external.Provides, servicesOf(contract, api)...)
+	}
+	var out []catalog.External
+	for _, external := range byID {
+		sort.Slice(external.Provides, func(i, j int) bool { return external.Provides[i].ID < external.Provides[j].ID })
+		out = append(out, *external)
+	}
+	sort.Slice(out, func(i, j int) bool { return out[i].ID < out[j].ID })
+	return out
+}
+
+func apiOf(contract wsdl.Contract, apiIDs map[string]string, opts Options, count int) string {
+	if opts.API != "" && count == 1 {
+		return opts.API
+	}
+	return apiIDs[wsdl.ContractKey(contract)]
+}
+
+func servicesOf(contract wsdl.Contract, api string) []catalog.RpcService {
+	var out []catalog.RpcService
+	for _, iface := range contract.Interfaces {
+		methods := make([]catalog.RpcMethod, 0, len(iface.Operations))
+		for _, operation := range iface.Operations {
+			methods = append(methods, catalog.RpcMethod{
+				Name: operation.Name, Doc: operation.Doc,
+				Request: operation.Request, Response: operation.Response,
+				SOAP: &catalog.SoapRoute{
+					Action: operation.Action, Version: iface.Version, Style: iface.Style,
+					Endpoint: iface.Endpoint, Binding: iface.Binding,
+					Faults: append([]string(nil), operation.Faults...), Headers: append([]string(nil), operation.Headers...),
+				},
+			})
+		}
+		messages := make([]catalog.RpcMessage, 0, len(iface.Messages))
+		for _, message := range iface.Messages {
+			fields := make([]catalog.Field, 0, len(message.Fields))
+			for _, field := range message.Fields {
+				fields = append(fields, catalog.Field{Name: field.Name, Type: field.Type, Doc: field.Doc})
+			}
+			messages = append(messages, catalog.RpcMessage{Name: message.Name, Fields: fields})
+		}
+		out = append(out, catalog.RpcService{
+			ID: wsdl.InterfaceID(api, iface), Source: contract.Source,
+			Methods: methods, Messages: messages,
+		})
+	}
+	return out
+}
+
+func firstNonEmpty(values ...string) string {
+	for _, value := range values {
+		if strings.TrimSpace(value) != "" {
+			return strings.TrimSpace(value)
+		}
+	}
+	return ""
+}

package/plugins/extract-wsdl/extract_test.go

@@ -0,0 +1,45 @@
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/shortlink-org/portolan/catalog"
+	"github.com/shortlink-org/portolan/plugin"
+)
+
+func TestWSDLBecomesStructuredExternalAPI(t *testing.T) {
+	root := t.TempDir()
+	spec := `<definitions xmlns="http://schemas.xmlsoap.org/wsdl/" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:tns="urn:payments" name="Payments" targetNamespace="urn:payments">
+  <types><xsd:schema targetNamespace="urn:payments"><xsd:element name="Pay"><xsd:complexType><xsd:sequence><xsd:element name="amount" type="xsd:decimal"/></xsd:sequence></xsd:complexType></xsd:element></xsd:schema></types>
+  <message name="PayRequest"><part name="body" element="tns:Pay"/></message>
+  <message name="PayResponse"><part name="id" type="xsd:string"/></message>
+  <portType name="PaymentsPortType"><operation name="Pay"><input message="tns:PayRequest"/><output message="tns:PayResponse"/></operation></portType>
+  <binding name="PaymentsBinding" type="tns:PaymentsPortType"><soap:binding style="document"/><operation name="Pay"><soap:operation soapAction="urn:pay"/></operation></binding>
+  <service name="PaymentsService"><port name="PaymentsPort" binding="tns:PaymentsBinding"><soap:address location="https://pay.example/soap"/></port></service>
+</definitions>`
+	if err := os.WriteFile(filepath.Join(root, "payments.wsdl"), []byte(spec), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	resp, err := extract(plugin.Input{Root: root, Commit: "abc", GeneratedAt: "2026-01-01T00:00:00Z"}, Options{Mode: "external", Spec: "payments.wsdl"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var got catalog.Catalog
+	if err := json.Unmarshal([]byte(resp.Files[0].Contents), &got); err != nil {
+		t.Fatal(err)
+	}
+	if len(got.Externals) != 1 || got.Externals[0].ID != "payments" || got.Externals[0].URL != "https://pay.example/soap" {
+		t.Fatalf("externals = %+v", got.Externals)
+	}
+	provided := got.Externals[0].Provides[0]
+	if provided.ID != "paymentsservice.soap.PaymentsPort" || provided.Source != "payments.wsdl" || len(provided.Messages) != 2 {
+		t.Fatalf("provided = %+v", provided)
+	}
+	method := provided.Methods[0]
+	if method.Request != "PayRequest" || method.Response != "PayResponse" || method.SOAP == nil || method.SOAP.Action != "urn:pay" || method.SOAP.Version != "1.1" {
+		t.Fatalf("method = %+v", method)
+	}
+}

package/plugins/extract-wsdl/main.go

@@ -0,0 +1,53 @@
+// Package main is portolan-extract-wsdl: WSDL contracts and their local XSD
+// graph in, structured SOAP interfaces in the catalog out.
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+
+	"github.com/shortlink-org/portolan/internal/wsdl"
+	"github.com/shortlink-org/portolan/plugin"
+)
+
+type Options struct {
+	Context string `json:"context"`
+	Service string `json:"service"`
+	Spec    string `json:"spec,omitempty"`
+	API     string `json:"api,omitempty"`
+
+	// Mode is service for a contract implemented by this component, external
+	// for copies used to call systems outside the estate.
+	Mode      string            `json:"mode,omitempty"`
+	External  string            `json:"external,omitempty"`
+	Externals map[string]string `json:"externals,omitempty"`
+
+	ExternalName    string `json:"externalName,omitempty"`
+	ExternalSummary string `json:"externalSummary,omitempty"`
+	ExternalURL     string `json:"externalUrl,omitempty"`
+	Out             string `json:"out,omitempty"`
+}
+
+func main() {
+	if err := run(os.Stdin, os.Stdout); err != nil {
+		fmt.Fprintln(os.Stderr, "portolan-extract-wsdl:", err)
+		os.Exit(1)
+	}
+}
+
+func run(stdin io.Reader, stdout io.Writer) error {
+	return plugin.Serve(stdin, stdout, descriptor(), func(req plugin.Request, opts Options) (plugin.Response, error) {
+		if req.Input.Root == "" {
+			return plugin.Response{}, fmt.Errorf("no input root: an extractor has nothing to read")
+		}
+		if opts.Context == "" {
+			opts.Context = wsdl.Slug(filepath.Base(req.Input.Root))
+		}
+		if opts.Service == "" {
+			opts.Service = wsdl.Slug(filepath.Base(req.Input.Root))
+		}
+		return extract(req.Input, opts)
+	})
+}

package/plugins/extract-wsdl/options.schema.json

@@ -0,0 +1,59 @@
+{
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "context": {
+      "type": "string",
+      "description": "Top-level group that owns the component implementing the WSDL contract.",
+      "examples": ["booking"]
+    },
+    "service": {
+      "type": "string",
+      "description": "Component implementing the WSDL contract.",
+      "examples": ["gateway"]
+    },
+    "spec": {
+      "type": "string",
+      "description": "Root WSDL document relative to the input. Its local WSDL and XSD imports are followed. Left out, every WSDL in the tree is discovered.",
+      "examples": ["contracts/booking.wsdl"]
+    },
+    "api": {
+      "type": "string",
+      "description": "API id prefix for a single contract. Defaults to the WSDL service name plus .soap.",
+      "examples": ["booking.soap"]
+    },
+    "mode": {
+      "type": "string",
+      "enum": ["service", "external"],
+      "default": "service",
+      "description": "Whether the contract is implemented by this component or is a local copy used to call external systems."
+    },
+    "external": {
+      "type": "string",
+      "description": "One external id for all discovered contracts. In external mode, each WSDL service otherwise derives its own external id."
+    },
+    "externals": {
+      "type": "object",
+      "additionalProperties": { "type": "string" },
+      "description": "External id overrides keyed by derived API id.",
+      "examples": [{ "booking-service.soap": "booking-provider" }]
+    },
+    "externalName": {
+      "type": "string",
+      "description": "Display name when external names one combined system."
+    },
+    "externalSummary": {
+      "type": "string",
+      "description": "Description when external names one combined system."
+    },
+    "externalUrl": {
+      "type": "string",
+      "description": "Documentation URL when it differs from the SOAP endpoint."
+    },
+    "out": {
+      "type": "string",
+      "description": "Fragment file name inside the step output directory.",
+      "default": "wsdl.json"
+    }
+  }
+}