@synopackageland/cli 0.5.3 → 0.6.0

package/templates/native-go/backend/internal/filestation/read_file_test.go

@@ -32,14 +32,13 @@ func identityServer(t *testing.T, size int, user string) *Client {
 }
 
 func fileService(t *testing.T, c *Client) (*Service, string) {
-	s := NewService(c, NewGrantRepository(t.TempDir()))
-	s.lookupUID = func(string) (string, error) { return "1000", nil }
+	s := NewService(c)
 	return s, "/home"
 }
 
 func alice(t *testing.T) api.Caller {
 	var got api.Caller
-	srv, _ := api.NewServer(testAuth{"alice"}, api.UserRequest("a.b", func(_ context.Context, c api.Caller, _ *http.Request, _ json.RawMessage) (any, error) {
+	srv, _ := sessionTestServer(testAuth{"alice"}, api.HandleRequest("a.b", func(_ context.Context, c api.Caller, _ *http.Request, _ json.RawMessage) (any, error) {
 		got = c
 		return nil, nil
 	}))

package/templates/native-go/backend/internal/filestation/service.go

@@ -3,52 +3,101 @@ package filestation
 import (
 	"bytes"
 	"context"
+	"dsmapp/internal/api"
 	"encoding/json"
 	"io"
 	"net/http"
-	"os/user"
+	"strings"
 	"time"
-
-	"dsmapp/internal/api"
 )
 
-type Service struct {
-	client     *Client
-	repository *GrantRepository
-	lookupUID  func(string) (string, error)
+// DSMClient has only request-scoped session operations. It cannot open a NAS
+// path, log in as a package account, or acquire an offline credential.
+type DSMClient interface {
+	Verify(context.Context, *http.Request, string) error
+	Discover(context.Context, *http.Request, int) (Page, error)
+	List(context.Context, *http.Request, string, ListOptions) (Page, error)
+	Stat(context.Context, *http.Request, string) (Entry, error)
+	Create(context.Context, *http.Request, string, string) error
+	UploadStream(context.Context, *http.Request, string, string, io.Reader, int64) error
+	DownloadStream(context.Context, *http.Request, string) (Download, error)
+	Read(context.Context, *http.Request, string) ([]byte, error)
 }
+type Service struct{ client DSMClient }
 
-func NewService(client *Client, repository *GrantRepository) *Service {
-	return &Service{client: client, repository: repository, lookupUID: func(name string) (string, error) {
-		u, e := user.Lookup(name)
-		if e != nil {
-			return "", e
-		}
-		return u.Uid, nil
-	}}
-}
+func NewService(client DSMClient) *Service { return &Service{client: client} }
 
-// Local is the production assembly. DSM's HTTP loopback port is fixed here,
-// never selected from Host, request params or a browser-supplied URL.
-func Local(dataDir string) *Service {
+// Local uses the startup-owned loopback address; dataDir is never used to
+// store sessions or infer NAS permissions.
+func Local(_ string) *Service {
 	c, e := NewClient("http://127.0.0.1:5000")
 	if e != nil {
 		return nil
 	}
-	return NewService(c, NewGrantRepository(dataDir))
+	return NewService(c)
+}
+func (s *Service) verify(ctx context.Context, c api.Caller, r *http.Request) error {
+	if !c.Authenticated() {
+		return fail("session_required")
+	}
+	if s == nil || s.client == nil {
+		return fail("unavailable")
+	}
+	check, cancel := context.WithTimeout(ctx, 20*time.Second)
+	defer cancel()
+	return s.client.Verify(check, r, c.User())
+}
+func (s *Service) ListShares(ctx context.Context, c api.Caller, r *http.Request, offset int) (Page, error) {
+	if e := s.verify(ctx, c, r); e != nil {
+		return Page{}, e
+	}
+	return s.client.Discover(ctx, r, offset)
+}
+func (s *Service) List(ctx context.Context, c api.Caller, r *http.Request, path string, opts ListOptions) (Page, error) {
+	if e := s.verify(ctx, c, r); e != nil {
+		return Page{}, e
+	}
+	return s.client.List(ctx, r, path, opts)
+}
+func (s *Service) Info(ctx context.Context, c api.Caller, r *http.Request, path string) (Entry, error) {
+	if e := s.verify(ctx, c, r); e != nil {
+		return Entry{}, e
+	}
+	return s.client.Stat(ctx, r, path)
 }
+func (s *Service) CreateFolder(ctx context.Context, c api.Caller, r *http.Request, parent, name string) error {
+	if e := s.verify(ctx, c, r); e != nil {
+		return e
+	}
+	return s.client.Create(ctx, r, parent, name)
+}
+func (s *Service) Upload(ctx context.Context, c api.Caller, r *http.Request, parent, name string, source io.Reader, size int64) error {
+	if e := s.verify(ctx, c, r); e != nil {
+		return e
+	}
+	return s.client.UploadStream(ctx, r, parent, name, source, size)
+}
+func (s *Service) Download(ctx context.Context, c api.Caller, r *http.Request, path string) (Download, error) {
+	if e := s.verify(ctx, c, r); e != nil {
+		return Download{}, e
+	}
+	return s.client.DownloadStream(ctx, r, path)
+}
+
+// Routes exposes JSON metadata and HTTP streaming operations. Every entry
+// passes through the central authenticator and immutable SDK policy.
 func (s *Service) Routes() []api.Route {
 	if s == nil {
 		return nil
 	}
 	routes := []api.Route{}
-	for _, name := range []string{"nas.session.status", "nas.discovery", "nas.grants.confirm", "nas.grants.list", "nas.grants.revoke", "nas.files.stat", "nas.files.list", "nas.files.read", "nas.files.create", "nas.files.write", "nas.files.stream", "nas.files.publish"} {
-		method := name
-		routes = append(routes, api.UserRequest(method, func(ctx context.Context, c api.Caller, r *http.Request, p json.RawMessage) (any, error) {
-			return s.handle(ctx, c, r, method, p)
+	for _, method := range []string{"nas.session.status", "nas.files.shares", "nas.files.list", "nas.files.info", "nas.files.create_folder"} {
+		name := method
+		routes = append(routes, api.HandleRequest(name, func(ctx context.Context, c api.Caller, r *http.Request, p json.RawMessage) (any, error) {
+			return s.handle(ctx, c, r, name, p)
 		}))
 	}
-	return routes
+	return append(routes, api.HandleStream("nas.files.download", s.downloadHTTP), api.HandleStream("nas.files.upload", s.uploadHTTP))
 }
 func strict(p json.RawMessage, dst any) error {
 	d := json.NewDecoder(bytes.NewReader(p))
@@ -59,122 +108,73 @@ func strict(p json.RawMessage, dst any) error {
 	return nil
 }
 func (s *Service) handle(ctx context.Context, c api.Caller, r *http.Request, method string, p json.RawMessage) (any, error) {
-	if !c.Authenticated() {
-		return nil, fail("session_required")
-	}
-	ctx, cancel := context.WithTimeout(ctx, 20*time.Second)
-	defer cancel()
-	if method == "nas.session.status" {
+	switch method {
+	case "nas.session.status":
 		if e := strict(p, &struct{}{}); e != nil {
 			return nil, e
 		}
-		return map[string]string{"interactive": "session-required", "background": "unavailable", "mode": "filestation-session", "validation": "local-only"}, nil
-	}
-	if method == "nas.files.stream" || method == "nas.files.publish" {
-		return nil, fail("unsupported")
-	}
-	if s.client == nil || s.repository == nil {
-		return nil, fail("unavailable")
-	}
-	uid, e := s.verifiedUID(ctx, c, r)
-	if e != nil {
-		return nil, e
-	}
-	switch method {
-	case "nas.discovery":
+		if e := s.verify(ctx, c, r); e != nil {
+			return nil, e
+		}
+		return map[string]string{"mode": "filestation-session"}, nil
+	case "nas.files.shares":
 		var in struct {
-			Folder string `json:"folder"`
-			Offset int    `json:"offset"`
+			Offset int `json:"offset"`
 		}
 		if e := strict(p, &in); e != nil {
 			return nil, e
 		}
-		return s.discover(ctx, r, in.Folder, in.Offset)
-	case "nas.grants.confirm":
+		return s.ListShares(ctx, c, r, in.Offset)
+	case "nas.files.list":
 		var in struct {
-			Folder   string `json:"folder"`
-			Writable bool   `json:"writable"`
+			Path string `json:"path"`
+			ListOptions
 		}
 		if e := strict(p, &in); e != nil {
 			return nil, e
 		}
-		item, e := s.client.Stat(ctx, r, in.Folder)
-		if e != nil {
-			return nil, e
-		}
-		if !item.IsDir {
-			return nil, fail("invalid-request")
+		return s.List(ctx, c, r, in.Path, in.ListOptions)
+	case "nas.files.info":
+		var in struct {
+			Path string `json:"path"`
 		}
-		return s.repository.Confirm(ctx, c.User(), uid, in.Folder, in.Writable)
-	case "nas.grants.list":
-		if e := strict(p, &struct{}{}); e != nil {
+		if e := strict(p, &in); e != nil {
 			return nil, e
 		}
-		return s.repository.List(ctx, c.User(), uid)
-	case "nas.grants.revoke":
+		return s.Info(ctx, c, r, in.Path)
+	case "nas.files.create_folder":
 		var in struct {
-			ID string `json:"grantId"`
+			Parent string `json:"parent"`
+			Name   string `json:"name"`
 		}
 		if e := strict(p, &in); e != nil {
 			return nil, e
 		}
-		e := s.repository.Revoke(ctx, c.User(), uid, in.ID)
-		return map[string]bool{"revoked": e == nil}, e
+		e := s.CreateFolder(ctx, c, r, in.Parent, in.Name)
+		return map[string]bool{"created": e == nil}, e
 	}
-	var in struct {
-		ID       string `json:"grantId"`
-		Relative string `json:"relative"`
-		Name     string `json:"name"`
-		Offset   int    `json:"offset"`
-		Data     []byte `json:"data"`
-	}
-	if e := strict(p, &in); e != nil {
-		return nil, e
+	return nil, fail("unsupported")
+}
+
+// relative constructs the existing job-import path; it is syntax validation,
+// never a permission decision. DSM checks the resulting path with this session.
+func relative(root, rel string) (string, error) {
+	if !validPath(root) {
+		return "", fail("invalid-request")
 	}
-	write := method == "nas.files.create" || method == "nas.files.write"
-	if len(in.Data) > MaxBytes {
-		return nil, fail("limit-exceeded")
+	if rel == "" {
+		return root, nil
 	}
-	var result any
-	e = s.repository.WithGrant(ctx, c.User(), uid, in.ID, write, func(g Selection) error {
-		target, e := relative(g.Folder, in.Relative)
-		if e != nil {
-			return e
-		}
-		switch method {
-		case "nas.files.list":
-			result, e = s.client.List(ctx, r, target, in.Offset)
-		case "nas.files.stat":
-			result, e = s.client.Stat(ctx, r, target)
-		case "nas.files.read":
-			var b []byte
-			b, e = s.readRegularFile(ctx, r, target)
-			result = map[string]any{"data": b, "bytes": len(b)}
-		case "nas.files.create":
-			e = s.client.Create(ctx, r, target, in.Name)
-			result = map[string]bool{"created": e == nil}
-		case "nas.files.write":
-			e = s.client.Write(ctx, r, target, in.Name, in.Data)
-			result = map[string]bool{"written": e == nil}
-		default:
-			return fail("unsupported")
+	for _, part := range strings.Split(rel, "/") {
+		if !validName(part) {
+			return "", fail("invalid-request")
 		}
-		return e
-	})
-	return result, e
-}
-
-// verifiedUID proves the request's DSM session belongs to the caller and
-// returns the caller's UID.
-func (s *Service) verifiedUID(ctx context.Context, c api.Caller, r *http.Request) (string, error) {
-	if e := s.client.Verify(ctx, r, c.User()); e != nil {
-		return "", e
 	}
-	uid, e := s.lookupUID(c.User())
-	if e != nil || uid == "" {
-		return "", fail("auth_unavailable")
+	target := root + "/" + rel
+	if !validPath(target) {
+		return "", fail("invalid-request")
 	}
-	return uid, nil
+	return target, nil
 }
 
 // readRegularFile avoids downloading a folder as an archive. DSM still enforces
@@ -198,7 +198,7 @@ func (s *Service) discover(ctx context.Context, r *http.Request, folder string,
 	if folder == "" {
 		return s.client.Discover(ctx, r, offset)
 	}
-	return s.client.List(ctx, r, folder, offset)
+	return s.client.List(ctx, r, folder, ListOptions{Offset: offset})
 }
 
 // Browse lists share roots (empty folder) or one folder through the caller's
@@ -214,7 +214,7 @@ func (s *Service) Browse(ctx context.Context, c api.Caller, r *http.Request, fol
 	}
 	ctx, cancel := context.WithTimeout(ctx, 20*time.Second)
 	defer cancel()
-	if _, e := s.verifiedUID(ctx, c, r); e != nil {
+	if e := s.verify(ctx, c, r); e != nil {
 		return Page{}, e
 	}
 	return s.discover(ctx, r, folder, offset)
@@ -236,7 +236,7 @@ func (s *Service) ReadFile(ctx context.Context, c api.Caller, r *http.Request, f
 	}
 	ctx, cancel := context.WithTimeout(ctx, 20*time.Second)
 	defer cancel()
-	if _, e := s.verifiedUID(ctx, c, r); e != nil {
+	if e := s.verify(ctx, c, r); e != nil {
 		return nil, e
 	}
 	item, e := s.client.Stat(ctx, r, folder)

package/templates/native-go/backend/internal/filestation/service_test.go

@@ -2,12 +2,14 @@ package filestation
 
 import (
 	"bytes"
+	"context"
 	"dsmapp/internal/api"
 	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
 	"net/http/httptest"
+	"strings"
 	"testing"
 )
 
@@ -21,7 +23,7 @@ func (a testAuth) Authenticate(*http.Request) (api.Identity, error) {
 }
 func invoke(t *testing.T, s *Service, user, method, params string) map[string]any {
 	t.Helper()
-	server, e := api.NewServer(testAuth{user}, s.Routes()...)
+	server, e := sessionTestServer(testAuth{user}, s.Routes()...)
 	if e != nil {
 		t.Fatal(e)
 	}
@@ -38,57 +40,35 @@ func invoke(t *testing.T, s *Service, user, method, params string) map[string]an
 	}
 	return out
 }
-func ioNop(b []byte) io.ReadCloser { return io.NopCloser(bytes.NewReader(b)) }
-func TestInteractiveRoutesIsolationAndFreshACL(t *testing.T) {
-	denied := false
-	writes := 0
-	c := fakeClient(t, func(w http.ResponseWriter, r *http.Request) {
-		r.ParseForm()
-		switch r.Form.Get("method") {
-		case "get":
-			fmt.Fprint(w, `{"success":true,"data":{"username":"alice"}}`)
-		case "getinfo":
-			fmt.Fprint(w, `{"success":true,"data":{"files":[{"path":"/home","name":"home","isdir":true}]}}`)
-		case "list":
-			if denied {
-				fmt.Fprint(w, `{"success":false,"error":{"code":407}}`)
-			} else {
-				fmt.Fprint(w, `{"success":true,"data":{"files":[],"total":0}}`)
-			}
-		default:
-			writes++
-			fmt.Fprint(w, `{"success":true}`)
+
+// SDK file routes use immutable authenticated policies. App test routes
+// explicitly opt in here.
+func sessionTestServer(auth api.Authenticator, routes ...api.Route) (*api.Server, error) {
+	methods := map[string]string{}
+	for _, route := range routes {
+		if !strings.HasPrefix(route.Method(), "nas.") {
+			methods[route.Method()] = "authenticated"
 		}
-	})
-	s := NewService(c, NewGrantRepository(t.TempDir()))
-	s.lookupUID = func(string) (string, error) { return "1000", nil }
-	out := invoke(t, s, "alice", "nas.grants.confirm", `{"folder":"/home","writable":false}`)
-	if out["success"] != true {
-		t.Fatal(out)
-	}
-	id := out["data"].(map[string]any)["grantId"].(string)
-	p := fmt.Sprintf(`{"grantId":%q}`, id)
-	if out = invoke(t, s, "alice", "nas.files.list", p); out["success"] != true {
-		t.Fatal(out)
-	}
-	denied = true
-	if out = invoke(t, s, "alice", "nas.files.list", p); out["error"].(map[string]any)["code"] != "denied" {
-		t.Fatal(out)
-	}
-	if out = invoke(t, s, "bob", "nas.files.list", p); out["success"] != false {
-		t.Fatal(out)
-	}
-	if out = invoke(t, s, "", "nas.files.list", p); out["success"] != false {
-		t.Fatal(out)
 	}
-	if out = invoke(t, s, "alice", "nas.files.create", fmt.Sprintf(`{"grantId":%q,"name":"x"}`, id)); out["success"] != false || writes != 0 {
-		t.Fatal(out)
+	policy, err := json.Marshal(map[string]any{"schema": 1, "default": "administrators", "methods": methods})
+	if err != nil {
+		return nil, err
 	}
-	if out = invoke(t, s, "alice", "nas.grants.revoke", p); out["success"] != true {
-		t.Fatal(out)
-	}
-	if out = invoke(t, s, "alice", "nas.files.list", p); out["success"] != false {
-		t.Fatal(out)
+	return api.NewServerWithPermissions(auth, policy, routes...)
+}
+func ioNop(b []byte) io.ReadCloser { return io.NopCloser(bytes.NewReader(b)) }
+func callerFor(t *testing.T, user string) api.Caller {
+	var got api.Caller
+	server, err := sessionTestServer(testAuth{user}, api.HandleRequest("test.caller", func(_ context.Context, c api.Caller, _ *http.Request, _ json.RawMessage) (any, error) {
+		got = c
+		return nil, nil
+	}))
+	if err != nil {
+		t.Fatal(err)
 	}
-
+	r := sessionRequest()
+	r.Body = ioNop([]byte(`{"method":"test.caller","params":{}}`))
+	r.Header.Set("Content-Type", "application/json")
+	server.ServeHTTP(httptest.NewRecorder(), r)
+	return got
 }

package/templates/native-go/backend/internal/filestation/upload_stream.go

@@ -0,0 +1,76 @@
+package filestation
+
+import (
+	"bytes"
+	"context"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// MaxUploadBytes bounds an interactive upload from a trusted application's
+// reader. This is not a background grant; DSM checks the current session.
+const MaxUploadBytes int64 = 16 << 30
+
+// UploadStream uploads a server-selected reader without buffering file bytes.
+// Never accept an unverified browser filesystem path as the reader's source.
+// No overwrite, retries, parent creation or retained session. A lost response
+// is commit-uncertain, including a timeout after a partially written upload.
+func (c *Client) UploadStream(ctx context.Context, r *http.Request, parent, name string, source io.Reader, size int64) error {
+	if c == nil || r == nil || source == nil || !validPath(parent) || !validName(name) || size < 0 || size > MaxUploadBytes {
+		return fail("invalid-request")
+	}
+	cookies := r.CookiesNamed("id")
+	token := r.Header.Get("X-SYNO-TOKEN")
+	if len(cookies) != 1 || cookies[0].Value == "" || token == "" || len(cookies[0].Value) > 4096 || len(token) > 4096 || strings.ContainsAny(token, "\r\n\x00") {
+		return fail("session_required")
+	}
+	var b bytes.Buffer
+	m := multipart.NewWriter(&b)
+	for _, f := range [][2]string{{"api", "SYNO.FileStation.Upload"}, {"method", "upload"}, {"version", "2"}, {"path", parent}, {"create_parents", "false"}, {"size", strconv.FormatInt(size, 10)}, {"SynoToken", token}} {
+		if e := m.WriteField(f[0], f[1]); e != nil {
+			return fail("invalid-request")
+		}
+	}
+	if _, e := m.CreateFormFile("file", name); e != nil {
+		return fail("invalid-request")
+	}
+	prefixLen := b.Len()
+	if e := m.Close(); e != nil {
+		return fail("invalid-request")
+	}
+	framing := b.Bytes()
+	body := io.MultiReader(bytes.NewReader(framing[:prefixLen]), io.LimitReader(source, size), bytes.NewReader(framing[prefixLen:]))
+	ctx, cancel := context.WithTimeout(ctx, 20*time.Minute)
+	defer cancel()
+	req, e := http.NewRequestWithContext(ctx, http.MethodPost, c.endpoint, body)
+	if e != nil {
+		return fail("invalid-request")
+	}
+	req.ContentLength = int64(len(framing)) + size
+	req.Header.Set("Content-Type", m.FormDataContentType())
+	req.AddCookie(cookies[0])
+	req.Header.Set("X-SYNO-TOKEN", token)
+	client := *c.http
+	client.Timeout = 20 * time.Minute
+	// Upload response headers arrive after DSM receives and commits the file.
+	// Keep the metadata deadline unchanged for other requests on this client.
+	if transport, ok := client.Transport.(*http.Transport); ok {
+		transport = transport.Clone()
+		transport.ResponseHeaderTimeout = 20 * time.Minute
+		client.Transport = transport
+		defer transport.CloseIdleConnections()
+	}
+	resp, e := client.Do(req)
+	if e != nil {
+		return fail("commit-uncertain")
+	}
+	if resp.StatusCode != http.StatusOK {
+		resp.Body.Close()
+		return fail("commit-uncertain")
+	}
+	return mutationOutcome(decode(resp, nil))
+}

package/templates/native-go/backend/internal/filestation/upload_stream_test.go

@@ -0,0 +1,77 @@
+package filestation
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestStreamingUploadWaitsForCommitResponseHeaders(t *testing.T) {
+	c := fakeClient(t, func(w http.ResponseWriter, r *http.Request) {
+		io.Copy(io.Discard, r.Body)
+		time.Sleep(30 * time.Millisecond)
+		fmt.Fprint(w, `{"success":true}`)
+	})
+	transport := c.http.Transport.(*http.Transport).Clone()
+	transport.ResponseHeaderTimeout = time.Millisecond
+	c.http.Transport = transport
+	if e := c.UploadStream(context.Background(), sessionRequest(), "/home", "fixture.bin", strings.NewReader("abc"), 3); e != nil {
+		t.Fatal("metadata header deadline incorrectly limited upload", e)
+	}
+	if transport.ResponseHeaderTimeout != time.Millisecond {
+		t.Fatal("upload mutated the shared metadata transport")
+	}
+}
+
+func TestStreamingUploadHasExactContentLengthAndSession(t *testing.T) {
+	payload := strings.Repeat("bounded-stream", 100000)
+	c := fakeClient(t, func(w http.ResponseWriter, r *http.Request) {
+		if r.ContentLength <= int64(len(payload)) || r.Header.Get("Cookie") != "id=test-session" {
+			t.Error("length/session")
+		}
+		mr, e := r.MultipartReader()
+		if e != nil {
+			t.Fatal(e)
+		}
+		fields := map[string]string{}
+		last := ""
+		for {
+			p, e := mr.NextPart()
+			if e == io.EOF {
+				break
+			}
+			if e != nil {
+				t.Fatal(e)
+			}
+			b, _ := io.ReadAll(p)
+			last = p.FormName()
+			fields[last] = string(b)
+		}
+		if last != "file" || fields["file"] != payload || fields["path"] != "/home" || fields["SynoToken"] != "test-token" || fields["create_parents"] != "false" || fields["overwrite"] != "" {
+			t.Error("unsafe upload")
+		}
+		fmt.Fprint(w, `{"success":true}`)
+	})
+	if e := c.UploadStream(context.Background(), sessionRequest(), "/home", "file.bin", strings.NewReader(payload), int64(len(payload))); e != nil {
+		t.Fatal(e)
+	}
+	for _, size := range []int64{-1, MaxUploadBytes + 1} {
+		if c.UploadStream(context.Background(), sessionRequest(), "/home", "file.bin", strings.NewReader("x"), size) == nil {
+			t.Fatal("unbounded")
+		}
+	}
+	if c.UploadStream(context.Background(), sessionRequest(), "/home", "../bad", strings.NewReader("x"), 1) == nil {
+		t.Fatal("traversal")
+	}
+}
+
+func TestStreamingUploadMalformedReplyRemainsUncertain(t *testing.T) {
+	c := fakeClient(t, func(w http.ResponseWriter, r *http.Request) { io.Copy(io.Discard, r.Body); fmt.Fprint(w, "broken") })
+	if e := c.UploadStream(context.Background(), sessionRequest(), "/home", "file.bin", strings.NewReader("abc"), 3); e == nil || !strings.Contains(e.Error(), "commit-uncertain") {
+		t.Fatal(e)
+	}
+}

package/templates/native-go/backend/internal/filestation/write.go

@@ -1,13 +1,10 @@
 package filestation
 
 import (
-	"bytes"
 	"context"
 	"dsmapp/internal/api"
 	"errors"
-	"mime/multipart"
 	"net/http"
-	"strconv"
 	"strings"
 )
 
@@ -25,43 +22,6 @@ func (c *Client) Create(ctx context.Context, r *http.Request, parent, name strin
 	return mutationOutcome(c.call(ctx, r, v, nil))
 }
 
-// Write creates one bounded file. Omitting overwrite requests an error if the
-// target already exists; false would silently skip on DSM. No retries or rename
-// publish promise: a timeout may have left a partial or completed remote file.
-func (c *Client) Write(ctx context.Context, r *http.Request, parent, name string, data []byte) error {
-	if !validPath(parent) || !validName(name) {
-		return fail("invalid-request")
-	}
-	if len(data) > MaxBytes {
-		return fail("limit-exceeded")
-	}
-	if r == nil {
-		return fail("unavailable")
-	}
-	var b bytes.Buffer
-	m := multipart.NewWriter(&b)
-	for _, f := range [][2]string{{"api", "SYNO.FileStation.Upload"}, {"method", "upload"}, {"version", "2"}, {"path", parent}, {"create_parents", "false"}, {"size", strconv.Itoa(len(data))}, {"SynoToken", r.Header.Get("X-SYNO-TOKEN")}} {
-		if m.WriteField(f[0], f[1]) != nil {
-			return fail("unavailable")
-		}
-	}
-	part, e := m.CreateFormFile("file", name)
-	if e != nil {
-		return fail("invalid-request")
-	}
-	if _, e = part.Write(data); e != nil {
-		return fail("unavailable")
-	}
-	if m.Close() != nil {
-		return fail("unavailable")
-	}
-	resp, e := c.send(ctx, r, &b, m.FormDataContentType())
-	if e != nil {
-		return mutationOutcome(e)
-	}
-	return mutationOutcome(decode(resp, nil))
-}
-
 // An unreadable response cannot establish whether DSM committed the write.
 func mutationOutcome(err error) error {
 	var e *api.Error