@xyd-js/opencli2go 0.1.0-build.0

package/__fixtures__/-2.complex.openai/videos__retrieve/output.go

@@ -0,0 +1,57 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+
+	"example.com/openai/internal/runtime"
+	"github.com/urfave/cli/v3"
+)
+
+func NewVideosCommand() *cli.Command {
+	return &cli.Command{
+		Name: "videos",
+		Commands: []*cli.Command{
+			&cli.Command{
+				Name: "list",
+				Usage: "List recently generated videos for the current project.",
+				Flags: []cli.Flag{
+					&cli.IntFlag{
+						Name: "limit",
+						Usage: "Number of items to retrieve",
+					},
+					&cli.StringFlag{
+						Name: "order",
+						Usage: "Sort order of results by timestamp. Use `asc` for ascending order or `desc` for descending order.",
+					},
+					&cli.StringFlag{
+						Name: "after",
+						Usage: "Identifier for the last item from the previous pagination request",
+					},
+				},
+				Action: handleVideosList,
+			},
+		},
+	}
+}
+
+func handleVideosList(ctx context.Context, cmd *cli.Command) error {
+	path := "/videos"
+	query := url.Values{}
+	if cmd.IsSet("limit") {
+		query.Set("limit", fmt.Sprint(cmd.Int("limit")))
+	}
+	if cmd.IsSet("order") {
+		query.Set("order", cmd.String("order"))
+	}
+	if cmd.IsSet("after") {
+		query.Set("after", cmd.String("after"))
+	}
+	req := runtime.Request{
+		Method: "GET",
+		Path: path,
+		Query: query,
+	}
+	return runtime.Do(ctx, req)
+}

package/__fixtures__/-2.complex.openai/videos__retrieve/recorded.json

@@ -0,0 +1,13 @@
+{
+  "args": [
+    "videos",
+    "list"
+  ],
+  "request": {
+    "method": "get",
+    "path": "/videos",
+    "query": [],
+    "bodyFields": [],
+    "auth": "bearer"
+  }
+}

package/__fixtures__/1.basic/input.json

@@ -0,0 +1,74 @@
+{
+  "opencli": "1.0.0",
+  "info": {
+    "title": "sample-api",
+    "version": "1.2.0",
+    "description": "A tiny sample API for testing openapi2opencli.",
+    "contact": {
+      "name": "API Support",
+      "url": "https://example.com/support",
+      "email": "support@example.com"
+    },
+    "license": {
+      "name": "MIT",
+      "url": "https://opensource.org/licenses/MIT"
+    }
+  },
+  "x-openapi": {
+    "servers": [
+      "https://api.example.com/v1"
+    ],
+    "security": [
+      {
+        "type": "http",
+        "kind": "bearer",
+        "envVar": "SAMPLE_API_API_KEY",
+        "scheme": "bearer",
+        "bearerFormat": "JWT"
+      }
+    ]
+  },
+  "commands": [
+    {
+      "name": "models",
+      "commands": [
+        {
+          "name": "list",
+          "description": "Lists the currently available models.",
+          "x-openapi": {
+            "method": "get",
+            "path": "/models",
+            "operationId": "listModels"
+          }
+        },
+        {
+          "name": "retrieve",
+          "aliases": [
+            "get"
+          ],
+          "description": "Retrieves a model instance.",
+          "arguments": [
+            {
+              "name": "model",
+              "required": true,
+              "description": "The ID of the model to use for this request."
+            }
+          ],
+          "x-openapi": {
+            "method": "get",
+            "path": "/models/{model}",
+            "operationId": "retrieveModel",
+            "params": [
+              {
+                "in": "path",
+                "name": "model",
+                "from": "argument:model",
+                "required": true
+              }
+            ]
+          }
+        }
+      ]
+    }
+  ]
+}

package/__fixtures__/1.basic/output/cmd/sample-api/main.go

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"context"
+	"log"
+	"os"
+
+	"example.com/sample-api/pkg/cmd"
+	"github.com/urfave/cli/v3"
+)
+
+func main() {
+	app := &cli.Command{
+		Name: "sample-api",
+		Usage: "A tiny sample API for testing openapi2opencli.",
+		Version: "1.2.0",
+		Commands: []*cli.Command{
+			cmd.NewModelsCommand(),
+		},
+	}
+	if err := app.Run(context.Background(), os.Args); err != nil {
+		log.Fatal(err)
+	}
+}

package/__fixtures__/1.basic/output/go.mod

@@ -0,0 +1,3 @@
+module example.com/sample-api
+
+go 1.22

package/__fixtures__/1.basic/output/internal/runtime/config.go

@@ -0,0 +1,23 @@
+package runtime
+
+import (
+	"net/http"
+	"os"
+)
+
+const defaultBaseURL = "https://api.example.com/v1"
+
+// BaseURL returns the API base URL, overridable via SAMPLE_API_BASE_URL.
+func BaseURL() string {
+	if v := os.Getenv("SAMPLE_API_BASE_URL"); v != "" {
+		return v
+	}
+	return defaultBaseURL
+}
+
+// applyAuth attaches credentials read from the environment to the request.
+func applyAuth(req *http.Request) {
+	if v := os.Getenv("SAMPLE_API_API_KEY"); v != "" {
+		req.Header.Set("Authorization", "Bearer "+v)
+	}
+}

package/__fixtures__/1.basic/output/internal/runtime/runtime.go

@@ -0,0 +1,64 @@
+package runtime
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+)
+
+// Request is a generic API request assembled by a generated command handler.
+type Request struct {
+	Method  string
+	Path    string
+	Query   url.Values
+	Headers http.Header
+	Body    []byte
+}
+
+// Do executes the request against the configured base URL (applying auth) and
+// prints the response body to stdout.
+func Do(ctx context.Context, req Request) error {
+	endpoint := strings.TrimRight(BaseURL(), "/") + req.Path
+	if len(req.Query) > 0 {
+		endpoint += "?" + req.Query.Encode()
+	}
+
+	var body io.Reader
+	if len(req.Body) > 0 {
+		body = bytes.NewReader(req.Body)
+	}
+
+	httpReq, err := http.NewRequestWithContext(ctx, req.Method, endpoint, body)
+	if err != nil {
+		return err
+	}
+	for key, values := range req.Headers {
+		for _, value := range values {
+			httpReq.Header.Add(key, value)
+		}
+	}
+	if len(req.Body) > 0 && httpReq.Header.Get("Content-Type") == "" {
+		httpReq.Header.Set("Content-Type", "application/json")
+	}
+	applyAuth(httpReq)
+
+	resp, err := http.DefaultClient.Do(httpReq)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	out, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+	fmt.Println(string(out))
+	if resp.StatusCode >= 400 {
+		return fmt.Errorf("request failed: %s", resp.Status)
+	}
+	return nil
+}

package/__fixtures__/1.basic/output/pkg/cmd/models.go

@@ -0,0 +1,49 @@
+package cmd
+
+import (
+	"context"
+	"net/url"
+
+	"example.com/sample-api/internal/runtime"
+	"github.com/urfave/cli/v3"
+)
+
+func NewModelsCommand() *cli.Command {
+	return &cli.Command{
+		Name: "models",
+		Commands: []*cli.Command{
+			&cli.Command{
+				Name: "list",
+				Usage: "Lists the currently available models.",
+				Action: handleModelsList,
+			},
+			&cli.Command{
+				Name: "retrieve",
+				Aliases: []string{
+					"get",
+				},
+				Usage: "Retrieves a model instance.",
+				Action: handleModelsRetrieve,
+			},
+		},
+	}
+}
+
+func handleModelsList(ctx context.Context, cmd *cli.Command) error {
+	path := "/models"
+	req := runtime.Request{
+		Method: "GET",
+		Path: path,
+	}
+	return runtime.Do(ctx, req)
+}
+
+func handleModelsRetrieve(ctx context.Context, cmd *cli.Command) error {
+	model := cmd.Args().Get(0)
+	path := "/models/" + url.PathEscape(model)
+	req := runtime.Request{
+		Method: "GET",
+		Path: path,
+	}
+	return runtime.Do(ctx, req)
+}

package/__fixtures__/2.crud/input.json

@@ -0,0 +1,281 @@
+{
+  "opencli": "1.0.0",
+  "info": {
+    "title": "widgets-api",
+    "version": "2.0.0"
+  },
+  "x-openapi": {
+    "servers": [
+      "https://api.widgets.test"
+    ],
+    "security": [
+      {
+        "type": "apiKey",
+        "kind": "apiKey-header",
+        "envVar": "WIDGETS_API_API_KEY",
+        "in": "header",
+        "name": "X-Api-Key"
+      }
+    ]
+  },
+  "commands": [
+    {
+      "name": "widgets",
+      "commands": [
+        {
+          "name": "list",
+          "description": "List all widgets.",
+          "options": [
+            {
+              "name": "limit",
+              "description": "Maximum number of widgets to return.",
+              "group": "query",
+              "arguments": [
+                {
+                  "name": "integer"
+                }
+              ]
+            },
+            {
+              "name": "status",
+              "description": "Filter by status.",
+              "group": "query",
+              "arguments": [
+                {
+                  "name": "string",
+                  "acceptedValues": [
+                    "active",
+                    "archived",
+                    "draft"
+                  ]
+                }
+              ]
+            }
+          ],
+          "x-openapi": {
+            "method": "get",
+            "path": "/widgets",
+            "operationId": "listWidgets",
+            "params": [
+              {
+                "in": "query",
+                "name": "limit",
+                "from": "option:limit"
+              },
+              {
+                "in": "query",
+                "name": "status",
+                "from": "option:status"
+              }
+            ]
+          }
+        },
+        {
+          "name": "create",
+          "description": "Create a widget.",
+          "options": [
+            {
+              "name": "name",
+              "group": "body",
+              "required": true,
+              "description": "The widget name.",
+              "arguments": [
+                {
+                  "name": "string"
+                }
+              ]
+            },
+            {
+              "name": "color",
+              "group": "body",
+              "arguments": [
+                {
+                  "name": "string",
+                  "acceptedValues": [
+                    "red",
+                    "green",
+                    "blue"
+                  ]
+                }
+              ]
+            },
+            {
+              "name": "tags",
+              "group": "body",
+              "arguments": [
+                {
+                  "name": "string",
+                  "arity": {
+                    "minimum": 0
+                  }
+                }
+              ]
+            },
+            {
+              "name": "enabled",
+              "group": "body"
+            },
+            {
+              "name": "config",
+              "group": "body",
+              "arguments": [
+                {
+                  "name": "json"
+                }
+              ]
+            }
+          ],
+          "x-openapi": {
+            "method": "post",
+            "path": "/widgets",
+            "operationId": "createWidget",
+            "contentType": "application/json",
+            "body": {
+              "style": "flatten",
+              "contentType": "application/json",
+              "properties": [
+                {
+                  "name": "name",
+                  "from": "option:name",
+                  "jsonPath": "name",
+                  "encoding": "string",
+                  "required": true
+                },
+                {
+                  "name": "color",
+                  "from": "option:color",
+                  "jsonPath": "color",
+                  "encoding": "string"
+                },
+                {
+                  "name": "tags",
+                  "from": "option:tags",
+                  "jsonPath": "tags",
+                  "encoding": "array"
+                },
+                {
+                  "name": "enabled",
+                  "from": "option:enabled",
+                  "jsonPath": "enabled",
+                  "encoding": "boolean"
+                },
+                {
+                  "name": "config",
+                  "from": "option:config",
+                  "jsonPath": "config",
+                  "encoding": "json"
+                }
+              ]
+            }
+          }
+        },
+        {
+          "name": "retrieve",
+          "aliases": [
+            "get"
+          ],
+          "description": "Retrieve a widget.",
+          "arguments": [
+            {
+              "name": "widget-id",
+              "required": true
+            }
+          ],
+          "x-openapi": {
+            "method": "get",
+            "path": "/widgets/{widget_id}",
+            "operationId": "retrieveWidget",
+            "params": [
+              {
+                "in": "path",
+                "name": "widget_id",
+                "from": "argument:widget-id",
+                "required": true
+              }
+            ]
+          }
+        },
+        {
+          "name": "update",
+          "description": "Update a widget.",
+          "arguments": [
+            {
+              "name": "widget-id",
+              "required": true
+            }
+          ],
+          "options": [
+            {
+              "name": "name",
+              "group": "body",
+              "arguments": [
+                {
+                  "name": "string"
+                }
+              ]
+            },
+            {
+              "name": "enabled",
+              "group": "body"
+            }
+          ],
+          "x-openapi": {
+            "method": "patch",
+            "path": "/widgets/{widget_id}",
+            "operationId": "updateWidget",
+            "contentType": "application/json",
+            "params": [
+              {
+                "in": "path",
+                "name": "widget_id",
+                "from": "argument:widget-id",
+                "required": true
+              }
+            ],
+            "body": {
+              "style": "flatten",
+              "contentType": "application/json",
+              "properties": [
+                {
+                  "name": "name",
+                  "from": "option:name",
+                  "jsonPath": "name",
+                  "encoding": "string"
+                },
+                {
+                  "name": "enabled",
+                  "from": "option:enabled",
+                  "jsonPath": "enabled",
+                  "encoding": "boolean"
+                }
+              ]
+            }
+          }
+        },
+        {
+          "name": "delete",
+          "description": "Delete a widget.",
+          "arguments": [
+            {
+              "name": "widget-id",
+              "required": true
+            }
+          ],
+          "x-openapi": {
+            "method": "delete",
+            "path": "/widgets/{widget_id}",
+            "operationId": "deleteWidget",
+            "params": [
+              {
+                "in": "path",
+                "name": "widget_id",
+                "from": "argument:widget-id",
+                "required": true
+              }
+            ]
+          }
+        }
+      ]
+    }
+  ]
+}

package/__fixtures__/2.crud/output/cmd/widgets-api/main.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"context"
+	"log"
+	"os"
+
+	"example.com/widgets-api/pkg/cmd"
+	"github.com/urfave/cli/v3"
+)
+
+func main() {
+	app := &cli.Command{
+		Name: "widgets-api",
+		Version: "2.0.0",
+		Commands: []*cli.Command{
+			cmd.NewWidgetsCommand(),
+		},
+	}
+	if err := app.Run(context.Background(), os.Args); err != nil {
+		log.Fatal(err)
+	}
+}

package/__fixtures__/2.crud/output/go.mod

@@ -0,0 +1,3 @@
+module example.com/widgets-api
+
+go 1.22

package/__fixtures__/2.crud/output/internal/runtime/config.go

@@ -0,0 +1,23 @@
+package runtime
+
+import (
+	"net/http"
+	"os"
+)
+
+const defaultBaseURL = "https://api.widgets.test"
+
+// BaseURL returns the API base URL, overridable via WIDGETS_API_BASE_URL.
+func BaseURL() string {
+	if v := os.Getenv("WIDGETS_API_BASE_URL"); v != "" {
+		return v
+	}
+	return defaultBaseURL
+}
+
+// applyAuth attaches credentials read from the environment to the request.
+func applyAuth(req *http.Request) {
+	if v := os.Getenv("WIDGETS_API_API_KEY"); v != "" {
+		req.Header.Set("X-Api-Key", v)
+	}
+}