@rivetkit/engine 1.0.0

package/sdks/go/api-full/core/core.go

@@ -0,0 +1,220 @@
+package core
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/http"
+)
+
+const (
+	// contentType specifies the JSON Content-Type header value.
+	contentType       = "application/json"
+	contentTypeHeader = "Content-Type"
+)
+
+// HTTPClient is an interface for a subset of the *http.Client.
+type HTTPClient interface {
+	Do(*http.Request) (*http.Response, error)
+}
+
+// WriteMultipartJSON writes the given value as a JSON part.
+// This is used to serialize non-primitive multipart properties
+// (i.e. lists, objects, etc).
+func WriteMultipartJSON(writer *multipart.Writer, field string, value interface{}) error {
+	bytes, err := json.Marshal(value)
+	if err != nil {
+		return err
+	}
+	return writer.WriteField(field, string(bytes))
+}
+
+// APIError is a lightweight wrapper around the standard error
+// interface that preserves the status code from the RPC, if any.
+type APIError struct {
+	err error
+
+	StatusCode int `json:"-"`
+}
+
+// NewAPIError constructs a new API error.
+func NewAPIError(statusCode int, err error) *APIError {
+	return &APIError{
+		err:        err,
+		StatusCode: statusCode,
+	}
+}
+
+// Unwrap returns the underlying error. This also makes the error compatible
+// with errors.As and errors.Is.
+func (a *APIError) Unwrap() error {
+	if a == nil {
+		return nil
+	}
+	return a.err
+}
+
+// Error returns the API error's message.
+func (a *APIError) Error() string {
+	if a == nil || (a.err == nil && a.StatusCode == 0) {
+		return ""
+	}
+	if a.err == nil {
+		return fmt.Sprintf("%d", a.StatusCode)
+	}
+	if a.StatusCode == 0 {
+		return a.err.Error()
+	}
+	return fmt.Sprintf("%d: %s", a.StatusCode, a.err.Error())
+}
+
+// ErrorDecoder decodes *http.Response errors and returns a
+// typed API error (e.g. *APIError).
+type ErrorDecoder func(statusCode int, body io.Reader) error
+
+// Caller calls APIs and deserializes their response, if any.
+type Caller struct {
+	client HTTPClient
+}
+
+// NewCaller returns a new *Caller backed by the given HTTP client.
+func NewCaller(client HTTPClient) *Caller {
+	return &Caller{
+		client: client,
+	}
+}
+
+// CallParams represents the parameters used to issue an API call.
+type CallParams struct {
+	URL                string
+	Method             string
+	Headers            http.Header
+	Request            interface{}
+	Response           interface{}
+	ResponseIsOptional bool
+	ErrorDecoder       ErrorDecoder
+}
+
+// Call issues an API call according to the given call parameters.
+func (c *Caller) Call(ctx context.Context, params *CallParams) error {
+	req, err := newRequest(ctx, params.URL, params.Method, params.Headers, params.Request)
+	if err != nil {
+		return err
+	}
+
+	// If the call has been cancelled, don't issue the request.
+	if err := ctx.Err(); err != nil {
+		return err
+	}
+
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return err
+	}
+
+	// Close the response body after we're done.
+	defer resp.Body.Close()
+
+	// Check if the call was cancelled before we return the error
+	// associated with the call and/or unmarshal the response data.
+	if err := ctx.Err(); err != nil {
+		return err
+	}
+
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return decodeError(resp, params.ErrorDecoder)
+	}
+
+	// Mutate the response parameter in-place.
+	if params.Response != nil {
+		if writer, ok := params.Response.(io.Writer); ok {
+			_, err = io.Copy(writer, resp.Body)
+		} else {
+			err = json.NewDecoder(resp.Body).Decode(params.Response)
+		}
+		if err != nil {
+			if err == io.EOF {
+				if params.ResponseIsOptional {
+					// The response is optional, so we should ignore the
+					// io.EOF error
+					return nil
+				}
+				return fmt.Errorf("expected a %T response, but the server responded with nothing", params.Response)
+			}
+			return err
+		}
+	}
+
+	return nil
+}
+
+// newRequest returns a new *http.Request with all of the fields
+// required to issue the call.
+func newRequest(
+	ctx context.Context,
+	url string,
+	method string,
+	endpointHeaders http.Header,
+	request interface{},
+) (*http.Request, error) {
+	requestBody, err := newRequestBody(request)
+	if err != nil {
+		return nil, err
+	}
+	req, err := http.NewRequestWithContext(ctx, method, url, requestBody)
+	if err != nil {
+		return nil, err
+	}
+	req = req.WithContext(ctx)
+	req.Header.Set(contentTypeHeader, contentType)
+	for name, values := range endpointHeaders {
+		req.Header[name] = values
+	}
+	return req, nil
+}
+
+// newRequestBody returns a new io.Reader that represents the HTTP request body.
+func newRequestBody(request interface{}) (io.Reader, error) {
+	var requestBody io.Reader
+	if request != nil {
+		if body, ok := request.(io.Reader); ok {
+			requestBody = body
+		} else {
+			requestBytes, err := json.Marshal(request)
+			if err != nil {
+				return nil, err
+			}
+			requestBody = bytes.NewReader(requestBytes)
+		}
+	}
+	return requestBody, nil
+}
+
+// decodeError decodes the error from the given HTTP response. Note that
+// it's the caller's responsibility to close the response body.
+func decodeError(response *http.Response, errorDecoder ErrorDecoder) error {
+	if errorDecoder != nil {
+		// This endpoint has custom errors, so we'll
+		// attempt to unmarshal the error into a structured
+		// type based on the status code.
+		return errorDecoder(response.StatusCode, response.Body)
+	}
+	// This endpoint doesn't have any custom error
+	// types, so we just read the body as-is, and
+	// put it into a normal error.
+	bytes, err := io.ReadAll(response.Body)
+	if err != nil && err != io.EOF {
+		return err
+	}
+	if err == io.EOF {
+		// The error didn't have a response body,
+		// so all we can do is return an error
+		// with the status code.
+		return NewAPIError(response.StatusCode, nil)
+	}
+	return NewAPIError(response.StatusCode, errors.New(string(bytes)))
+}

package/sdks/go/api-full/core/core_test.go

@@ -0,0 +1,219 @@
+package core
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strconv"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TestCase represents a single test case.
+type TestCase struct {
+	description string
+
+	// Server-side assertions.
+	giveMethod             string
+	giveResponseIsOptional bool
+	giveHeader             http.Header
+	giveErrorDecoder       ErrorDecoder
+	giveRequest            *Request
+
+	// Client-side assertions.
+	wantResponse *Response
+	wantError    error
+}
+
+// Request a simple request body.
+type Request struct {
+	Id string `json:"id"`
+}
+
+// Response a simple response body.
+type Response struct {
+	Id string `json:"id"`
+}
+
+// NotFoundError represents a 404.
+type NotFoundError struct {
+	*APIError
+
+	Message string `json:"message"`
+}
+
+func TestCall(t *testing.T) {
+	tests := []*TestCase{
+		{
+			description: "GET success",
+			giveMethod:  http.MethodGet,
+			giveHeader: http.Header{
+				"X-API-Status": []string{"success"},
+			},
+			giveRequest: &Request{
+				Id: "123",
+			},
+			wantResponse: &Response{
+				Id: "123",
+			},
+		},
+		{
+			description: "GET not found",
+			giveMethod:  http.MethodGet,
+			giveHeader: http.Header{
+				"X-API-Status": []string{"fail"},
+			},
+			giveRequest: &Request{
+				Id: strconv.Itoa(http.StatusNotFound),
+			},
+			giveErrorDecoder: newTestErrorDecoder(t),
+			wantError: &NotFoundError{
+				APIError: NewAPIError(
+					http.StatusNotFound,
+					errors.New(`{"message":"ID \"404\" not found"}`),
+				),
+			},
+		},
+		{
+			description: "POST optional response",
+			giveMethod:  http.MethodPost,
+			giveHeader: http.Header{
+				"X-API-Status": []string{"success"},
+			},
+			giveRequest: &Request{
+				Id: "123",
+			},
+			giveResponseIsOptional: true,
+		},
+		{
+			description: "POST API error",
+			giveMethod:  http.MethodPost,
+			giveHeader: http.Header{
+				"X-API-Status": []string{"fail"},
+			},
+			giveRequest: &Request{
+				Id: strconv.Itoa(http.StatusInternalServerError),
+			},
+			wantError: NewAPIError(
+				http.StatusInternalServerError,
+				errors.New("failed to process request"),
+			),
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.description, func(t *testing.T) {
+			var (
+				server = newTestServer(t, test)
+				client = server.Client()
+			)
+			caller := NewCaller(client)
+			var response *Response
+			err := caller.Call(
+				context.Background(),
+				&CallParams{
+					URL:                server.URL,
+					Method:             test.giveMethod,
+					Headers:            test.giveHeader,
+					Request:            test.giveRequest,
+					Response:           &response,
+					ResponseIsOptional: test.giveResponseIsOptional,
+					ErrorDecoder:       test.giveErrorDecoder,
+				},
+			)
+			if test.wantError != nil {
+				assert.EqualError(t, err, test.wantError.Error())
+				return
+			}
+			require.NoError(t, err)
+			assert.Equal(t, test.wantResponse, response)
+		})
+	}
+}
+
+// newTestServer returns a new *httptest.Server configured with the
+// given test parameters.
+func newTestServer(t *testing.T, tc *TestCase) *httptest.Server {
+	return httptest.NewServer(
+		http.HandlerFunc(
+			func(w http.ResponseWriter, r *http.Request) {
+				assert.Equal(t, tc.giveMethod, r.Method)
+				assert.Equal(t, contentType, r.Header.Get(contentTypeHeader))
+				for header, value := range tc.giveHeader {
+					assert.Equal(t, value, r.Header.Values(header))
+				}
+
+				bytes, err := io.ReadAll(r.Body)
+				require.NoError(t, err)
+
+				request := new(Request)
+				require.NoError(t, json.Unmarshal(bytes, request))
+
+				switch request.Id {
+				case strconv.Itoa(http.StatusNotFound):
+					notFoundError := &NotFoundError{
+						APIError: &APIError{
+							StatusCode: http.StatusNotFound,
+						},
+						Message: fmt.Sprintf("ID %q not found", request.Id),
+					}
+					bytes, err = json.Marshal(notFoundError)
+					require.NoError(t, err)
+
+					w.WriteHeader(http.StatusNotFound)
+					_, err = w.Write(bytes)
+					require.NoError(t, err)
+					return
+
+				case strconv.Itoa(http.StatusInternalServerError):
+					w.WriteHeader(http.StatusInternalServerError)
+					_, err = w.Write([]byte("failed to process request"))
+					require.NoError(t, err)
+					return
+				}
+
+				if tc.giveResponseIsOptional {
+					w.WriteHeader(http.StatusOK)
+					return
+				}
+
+				response := &Response{
+					Id: request.Id,
+				}
+				bytes, err = json.Marshal(response)
+				require.NoError(t, err)
+
+				_, err = w.Write(bytes)
+				require.NoError(t, err)
+			},
+		),
+	)
+}
+
+// newTestErrorDecoder returns an error decoder suitable for tests.
+func newTestErrorDecoder(t *testing.T) func(int, io.Reader) error {
+	return func(statusCode int, body io.Reader) error {
+		raw, err := io.ReadAll(body)
+		require.NoError(t, err)
+
+		var (
+			apiError = NewAPIError(statusCode, errors.New(string(raw)))
+			decoder  = json.NewDecoder(bytes.NewReader(raw))
+		)
+		switch statusCode {
+		case 404:
+			value := new(NotFoundError)
+			value.APIError = apiError
+			require.NoError(t, decoder.Decode(value))
+
+			return value
+		}
+		return apiError
+	}
+}

package/sdks/go/api-full/core/stringer.go

@@ -0,0 +1,13 @@
+package core
+
+import "encoding/json"
+
+// StringifyJSON returns a pretty JSON string representation of
+// the given value.
+func StringifyJSON(value interface{}) (string, error) {
+	bytes, err := json.MarshalIndent(value, "", "  ")
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}

package/sdks/go/api-full/datacenters/client.go

@@ -0,0 +1,50 @@
+// This file was auto-generated by Fern from our API Definition.
+
+package datacenters
+
+import (
+	context "context"
+	http "net/http"
+	sdk "sdk"
+	core "sdk/core"
+)
+
+type Client struct {
+	baseURL string
+	caller  *core.Caller
+	header  http.Header
+}
+
+func NewClient(opts ...core.ClientOption) *Client {
+	options := core.NewClientOptions()
+	for _, opt := range opts {
+		opt(options)
+	}
+	return &Client{
+		baseURL: options.BaseURL,
+		caller:  core.NewCaller(options.HTTPClient),
+		header:  options.ToHeader(),
+	}
+}
+
+func (c *Client) List(ctx context.Context) (*sdk.DatacentersListResponse, error) {
+	baseURL := ""
+	if c.baseURL != "" {
+		baseURL = c.baseURL
+	}
+	endpointURL := baseURL + "/" + "datacenters"
+
+	var response *sdk.DatacentersListResponse
+	if err := c.caller.Call(
+		ctx,
+		&core.CallParams{
+			URL:      endpointURL,
+			Method:   http.MethodGet,
+			Headers:  c.header,
+			Response: &response,
+		},
+	); err != nil {
+		return nil, err
+	}
+	return response, nil
+}

package/sdks/go/api-full/go.mod

@@ -0,0 +1,8 @@
+module sdk
+
+go 1.13
+
+require (
+	github.com/stretchr/testify v1.7.0
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

package/sdks/go/api-full/go.sum

@@ -0,0 +1,12 @@
+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

package/sdks/go/api-full/health/client.go

@@ -0,0 +1,50 @@
+// This file was auto-generated by Fern from our API Definition.
+
+package health
+
+import (
+	context "context"
+	http "net/http"
+	sdk "sdk"
+	core "sdk/core"
+)
+
+type Client struct {
+	baseURL string
+	caller  *core.Caller
+	header  http.Header
+}
+
+func NewClient(opts ...core.ClientOption) *Client {
+	options := core.NewClientOptions()
+	for _, opt := range opts {
+		opt(options)
+	}
+	return &Client{
+		baseURL: options.BaseURL,
+		caller:  core.NewCaller(options.HTTPClient),
+		header:  options.ToHeader(),
+	}
+}
+
+func (c *Client) Fanout(ctx context.Context) (*sdk.HealthFanoutResponse, error) {
+	baseURL := ""
+	if c.baseURL != "" {
+		baseURL = c.baseURL
+	}
+	endpointURL := baseURL + "/" + "health/fanout"
+
+	var response *sdk.HealthFanoutResponse
+	if err := c.caller.Call(
+		ctx,
+		&core.CallParams{
+			URL:      endpointURL,
+			Method:   http.MethodGet,
+			Headers:  c.header,
+			Response: &response,
+		},
+	); err != nil {
+		return nil, err
+	}
+	return response, nil
+}

package/sdks/go/api-full/namespaces/client.go

@@ -0,0 +1,92 @@
+// This file was auto-generated by Fern from our API Definition.
+
+package namespaces
+
+import (
+	context "context"
+	fmt "fmt"
+	http "net/http"
+	url "net/url"
+	sdk "sdk"
+	core "sdk/core"
+)
+
+type Client struct {
+	baseURL string
+	caller  *core.Caller
+	header  http.Header
+}
+
+func NewClient(opts ...core.ClientOption) *Client {
+	options := core.NewClientOptions()
+	for _, opt := range opts {
+		opt(options)
+	}
+	return &Client{
+		baseURL: options.BaseURL,
+		caller:  core.NewCaller(options.HTTPClient),
+		header:  options.ToHeader(),
+	}
+}
+
+func (c *Client) List(ctx context.Context, request *sdk.NamespacesListRequest) (*sdk.NamespaceListResponse, error) {
+	baseURL := ""
+	if c.baseURL != "" {
+		baseURL = c.baseURL
+	}
+	endpointURL := baseURL + "/" + "namespaces"
+
+	queryParams := make(url.Values)
+	if request.Limit != nil {
+		queryParams.Add("limit", fmt.Sprintf("%v", *request.Limit))
+	}
+	if request.Cursor != nil {
+		queryParams.Add("cursor", fmt.Sprintf("%v", *request.Cursor))
+	}
+	if request.Name != nil {
+		queryParams.Add("name", fmt.Sprintf("%v", *request.Name))
+	}
+	if request.NamespaceIds != nil {
+		queryParams.Add("namespace_ids", fmt.Sprintf("%v", *request.NamespaceIds))
+	}
+	if len(queryParams) > 0 {
+		endpointURL += "?" + queryParams.Encode()
+	}
+
+	var response *sdk.NamespaceListResponse
+	if err := c.caller.Call(
+		ctx,
+		&core.CallParams{
+			URL:      endpointURL,
+			Method:   http.MethodGet,
+			Headers:  c.header,
+			Response: &response,
+		},
+	); err != nil {
+		return nil, err
+	}
+	return response, nil
+}
+
+func (c *Client) Create(ctx context.Context, request *sdk.NamespacesCreateRequest) (*sdk.NamespacesCreateResponse, error) {
+	baseURL := ""
+	if c.baseURL != "" {
+		baseURL = c.baseURL
+	}
+	endpointURL := baseURL + "/" + "namespaces"
+
+	var response *sdk.NamespacesCreateResponse
+	if err := c.caller.Call(
+		ctx,
+		&core.CallParams{
+			URL:      endpointURL,
+			Method:   http.MethodPost,
+			Headers:  c.header,
+			Request:  request,
+			Response: &response,
+		},
+	); err != nil {
+		return nil, err
+	}
+	return response, nil
+}

package/sdks/go/api-full/namespaces.go

@@ -0,0 +1,15 @@
+// This file was auto-generated by Fern from our API Definition.
+
+package api
+
+type NamespacesCreateRequest struct {
+	DisplayName string `json:"display_name"`
+	Name        string `json:"name"`
+}
+
+type NamespacesListRequest struct {
+	Limit        *int    `json:"-"`
+	Cursor       *string `json:"-"`
+	Name         *string `json:"-"`
+	NamespaceIds *string `json:"-"`
+}