@x47base/pocketbase-addon 0.1.0

package/settings/settings.go

@@ -0,0 +1,155 @@
+package settings
+
+import (
+	"database/sql"
+	_ "embed"
+	"encoding/json"
+	jsonv2 "encoding/json/v2"
+	"errors"
+	"fmt"
+	"os"
+	"regexp"
+	"strings"
+
+	"github.com/pocketbase/pocketbase/apis"
+	"github.com/pocketbase/pocketbase/core"
+	"github.com/pocketbase/pocketbase/tools/types"
+	"github.com/spink-dev/pocketbase-extension/backups"
+)
+
+//go:embed openapi.json
+var apiContract []byte
+
+const key = "spink_extension_v1"
+
+type Template struct {
+	Subject string `json:"subject"`
+	Body    string `json:"body"`
+}
+type Config struct {
+	Revision     uint64                                    `json:"revision"`
+	Backups      backups.Config                            `json:"backups"`
+	EmailLocales map[string]map[string]map[string]Template `json:"emailLocales"`
+}
+
+var localePattern = regexp.MustCompile(`^[a-z]{2,8}(?:-[a-z0-9]{1,8})*$`)
+var ErrConflict = errors.New("extension settings changed; reload before saving")
+
+func Load(app core.App) (Config, error) {
+	c := Config{Revision: 1, EmailLocales: map[string]map[string]map[string]Template{}}
+	p := new(core.Param)
+	if err := app.ModelQuery(p).Model(key, p); err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			return c, nil
+		}
+		return c, err
+	}
+	err := json.Unmarshal(p.Value, &c)
+	return c, err
+}
+func Save(app core.App, c Config) error {
+	rawConfig, _ := json.Marshal(c)
+	if len(rawConfig) > 1<<20 {
+		return errors.New("extension configuration exceeds 1 MiB")
+	}
+	if err := c.Backups.Validate(); err != nil {
+		return err
+	}
+	if len(c.EmailLocales) > 100 {
+		return errors.New("too many localized collections")
+	}
+	for _, kinds := range c.EmailLocales {
+		if len(kinds) > 5 {
+			return errors.New("too many mail template types")
+		}
+		for kind, locales := range kinds {
+			switch kind {
+			case "otp", "verification", "passwordReset", "emailChange", "authAlert":
+			default:
+				return errors.New("invalid mail template type")
+			}
+			if len(locales) > 32 {
+				return errors.New("too many email locales")
+			}
+			for locale, t := range locales {
+				if !localePattern.MatchString(locale) || len(locale) > 35 || strings.ToLower(locale) != locale || strings.ContainsAny(locale, " /\\") {
+					return errors.New("invalid locale")
+				}
+				if strings.TrimSpace(t.Subject) == "" || strings.TrimSpace(t.Body) == "" || len(t.Subject) > 4096 || len(t.Body) > 262144 {
+					return errors.New("invalid localized template size")
+				}
+			}
+		}
+	}
+	return app.RunInTransaction(func(tx core.App) error {
+		old, err := Load(tx)
+		if err != nil {
+			return err
+		}
+		if c.Revision != old.Revision {
+			return ErrConflict
+		}
+		c.Revision++
+		p := new(core.Param)
+		err = tx.ModelQuery(p).Model(key, p)
+		if err != nil && !errors.Is(err, sql.ErrNoRows) {
+			return err
+		}
+		p.Id = key
+		raw, err := json.Marshal(c)
+		if err != nil {
+			return err
+		}
+		p.Value = types.JSONRaw(raw)
+		return tx.Save(p)
+	})
+}
+func Register(app core.App) {
+	// Applied before initial Settings validation; persisted settings never trigger this create hook.
+	app.OnModelValidate("_params").BindFunc(func(e *core.ModelEvent) error {
+		s, ok := e.Model.(*core.Settings)
+		if !ok || !s.IsNew() {
+			return e.Next()
+		}
+		raw := os.Getenv("PB_SETTINGS_JSON")
+		if raw == "" {
+			return e.Next()
+		}
+		if len(raw) > 1<<20 || !strings.HasPrefix(strings.TrimSpace(raw), "{") {
+			return errors.New("PB_SETTINGS_JSON must be an object of at most 1 MiB")
+		}
+		if err := jsonv2.Unmarshal([]byte(raw), s, jsonv2.RejectUnknownMembers(true)); err != nil {
+			return fmt.Errorf("invalid PB_SETTINGS_JSON: %w", err)
+		}
+		return e.Next()
+	})
+	app.OnServe().BindFunc(func(e *core.ServeEvent) error {
+		e.Router.GET("/api/spink/openapi.json", func(r *core.RequestEvent) error { return r.Blob(200, "application/json", apiContract) })
+		g := e.Router.Group("/api/spink/settings").Bind(apis.RequireSuperuserAuth())
+		g.GET("", func(r *core.RequestEvent) error {
+			c, err := Load(r.App)
+			if err != nil {
+				return err
+			}
+			return r.JSON(200, map[string]any{"config": c, "backupKeyConfigured": c.Backups.KeyConfigured()})
+		})
+		g.PUT("", func(r *core.RequestEvent) error {
+			var c Config
+			if err := r.BindBody(&c); err != nil {
+				return r.BadRequestError("Invalid settings", err)
+			}
+			if err := Save(r.App, c); err != nil {
+				if errors.Is(err, ErrConflict) {
+					return r.Error(409, err.Error(), nil)
+				}
+				return r.BadRequestError("Invalid extension settings", err)
+			}
+			c, err := Load(r.App)
+			if err != nil {
+				return err
+			}
+			return r.JSON(200, c)
+		})
+		return e.Next()
+	})
+}

package/settings/settings_test.go

@@ -0,0 +1,31 @@
+package settings
+
+import (
+	"errors"
+	"github.com/pocketbase/pocketbase/tests"
+	"testing"
+)
+
+func TestSettingsPersistenceAndRevision(t *testing.T) {
+	a, err := tests.NewTestApp()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer a.Cleanup()
+	c, err := Load(a)
+	if err != nil {
+		t.Fatal(err)
+	}
+	old := c
+	c.EmailLocales = map[string]map[string]map[string]Template{"users": {"otp": {"fr": {Subject: "Bonjour", Body: "Votre code: {OTP}"}}}}
+	if err = Save(a, c); err != nil {
+		t.Fatal(err)
+	}
+	saved, err := Load(a)
+	if err != nil || saved.Revision != 2 || saved.EmailLocales["users"]["otp"]["fr"].Subject != "Bonjour" {
+		t.Fatalf("persistence: %+v %v", saved, err)
+	}
+	if !errors.Is(Save(a, old), ErrConflict) {
+		t.Fatal("accepted stale settings")
+	}
+}

package/watcher/watcher.go

@@ -0,0 +1,192 @@
+package watcher
+
+import (
+	"fmt"
+	"github.com/pocketbase/pocketbase/core"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/fatih/color"
+	"github.com/fsnotify/fsnotify"
+	"github.com/pocketbase/pocketbase/tools/hook"
+	"github.com/pocketbase/pocketbase/tools/routine"
+	"github.com/pocketbase/pocketbase/tools/security"
+)
+
+const systemHookIdNotifyWatcher = "__pbNotifyWatcherSystemHook__"
+
+func Register(app core.App) {
+	var notifyWatcher *fsnotify.Watcher
+
+	instanceId := "@" + security.PseudorandomString(10)
+
+	localNotifyDirPath := filepath.Join(app.DataDir(), core.LocalNotifyDirName)
+	settingsFile := filepath.Join(localNotifyDirPath, "settings"+instanceId)
+	collectionsFile := filepath.Join(localNotifyDirPath, "collections"+instanceId)
+
+	// init
+	app.OnBootstrap().Bind(&hook.Handler[*core.BootstrapEvent]{
+		Id: systemHookIdNotifyWatcher,
+		Func: func(e *core.BootstrapEvent) error {
+			err := e.Next()
+			if err != nil {
+				return err
+			}
+
+			if notifyWatcher != nil {
+				_ = notifyWatcher.Close()
+			}
+
+			notifyWatcher, err = createNotifyDirWatcher(e.App, instanceId, localNotifyDirPath)
+			if err != nil {
+				e.App.Logger().Warn("Notify dir watcher failure.", "error", err)
+			}
+
+			return nil
+		},
+		Priority: -998,
+	})
+
+	// cleanup
+	app.OnTerminate().Bind(&hook.Handler[*core.TerminateEvent]{
+		Id: systemHookIdNotifyWatcher,
+		Func: func(e *core.TerminateEvent) error {
+			if notifyWatcher != nil {
+				_ = notifyWatcher.Close()
+			}
+			_ = os.Remove(settingsFile)
+			_ = os.Remove(collectionsFile)
+
+			return e.Next()
+		},
+		Priority: -998,
+	})
+
+	// ---------------------------------------------------------------
+
+	settingsNotify := func(e *core.ModelEvent) error {
+		err := e.Next()
+		if err != nil || e.Model.PK() != "settings" {
+			return err
+		}
+
+		if notifyWatcher != nil {
+			if err := os.WriteFile(settingsFile, []byte(time.Now().Format(time.RFC3339Nano)), 0644); err != nil {
+				e.App.Logger().Warn("Failed to write watcher file", "error", err, "file", settingsFile)
+			}
+		}
+
+		return nil
+	}
+	app.OnModelAfterCreateSuccess("_params").Bind(&hook.Handler[*core.ModelEvent]{
+		Id:       systemHookIdNotifyWatcher,
+		Func:     settingsNotify,
+		Priority: 999,
+	})
+	app.OnModelAfterUpdateSuccess("_params").Bind(&hook.Handler[*core.ModelEvent]{
+		Id:       systemHookIdNotifyWatcher,
+		Func:     settingsNotify,
+		Priority: 999,
+	})
+
+	// ---------------------------------------------------------------
+
+	collectionsNotify := func(e *core.CollectionEvent) error {
+		if err := e.Next(); err != nil {
+			return err
+		}
+
+		if notifyWatcher != nil {
+			if err := os.WriteFile(collectionsFile, []byte(time.Now().Format(time.RFC3339Nano)), 0644); err != nil {
+				e.App.Logger().Warn("Failed to write watcher file", "error", err, "file", collectionsFile)
+			}
+		}
+
+		return nil
+	}
+	app.OnCollectionAfterCreateSuccess().Bind(&hook.Handler[*core.CollectionEvent]{
+		Id:       systemHookIdNotifyWatcher,
+		Func:     collectionsNotify,
+		Priority: 999,
+	})
+	app.OnCollectionAfterUpdateSuccess().Bind(&hook.Handler[*core.CollectionEvent]{
+		Id:       systemHookIdNotifyWatcher,
+		Func:     collectionsNotify,
+		Priority: 999,
+	})
+	app.OnCollectionAfterDeleteSuccess().Bind(&hook.Handler[*core.CollectionEvent]{
+		Id:       systemHookIdNotifyWatcher,
+		Func:     collectionsNotify,
+		Priority: 999,
+	})
+}
+
+func createNotifyDirWatcher(app core.App, instanceId string, localNotifyDirPath string) (*fsnotify.Watcher, error) {
+	// create the notify dir (if not already)
+	err := os.MkdirAll(localNotifyDirPath, os.ModePerm)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create a notify dir: %w", err)
+	}
+
+	watcher, err := fsnotify.NewWatcher()
+	if err != nil {
+		return nil, fmt.Errorf("failed to init notify dir watcher: %w", err)
+	}
+
+	err = watcher.Add(localNotifyDirPath)
+	if err != nil {
+		_ = watcher.Close()
+		return nil, fmt.Errorf("unable to watch notify dir: %w", err)
+	}
+
+	routine.FireAndForget(func() {
+		timer := time.NewTimer(time.Hour)
+		timer.Stop()
+		defer timer.Stop()
+		var pendingSettings, pendingCollections bool
+		for {
+			select {
+			case event, ok := <-watcher.Events:
+				if !ok {
+					return
+				}
+				if strings.HasSuffix(event.Name, instanceId) || event.Has(fsnotify.Remove) || !app.IsBootstrapped() {
+					continue
+				}
+				filename := filepath.Base(event.Name)
+				settings := strings.HasPrefix(filename, "settings@")
+				collections := strings.HasPrefix(filename, "collections@")
+				if !settings && !collections {
+					continue
+				}
+				pendingSettings = pendingSettings || settings
+				pendingCollections = pendingCollections || collections
+				timer.Reset(50 * time.Millisecond)
+			case <-timer.C:
+				if pendingSettings {
+					pendingSettings = false
+					if err := app.ReloadSettings(); err != nil {
+						app.Logger().Warn("Failed to reload app settings after notify", "error", err)
+					}
+				}
+				if pendingCollections {
+					pendingCollections = false
+					if err := app.ReloadCachedCollections(); err != nil {
+						app.Logger().Warn("Failed to reload cached collections after notify", "error", err)
+					}
+				}
+			case err, ok := <-watcher.Errors:
+				if !ok {
+					return
+				}
+				if app.IsDev() && err != nil {
+					color.Red("Notify dir watch error:\n%v", err)
+				}
+			}
+		}
+	})
+
+	return watcher, err
+}

package/watcher/watcher_test.go

@@ -0,0 +1,200 @@
+package watcher_test
+
+import (
+	"context"
+	"database/sql"
+	_ "github.com/pocketbase/pocketbase/migrations"
+	"github.com/spink-dev/pocketbase-extension/watcher"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/pocketbase/dbx"
+	"github.com/pocketbase/pocketbase/core"
+	"github.com/pocketbase/pocketbase/tools/store"
+	"golang.org/x/sync/semaphore"
+)
+
+func TestNotifyWatcher_SettingsUpdate(t *testing.T) {
+	t.Parallel()
+
+	testEvents := store.New[core.App, int](nil)
+
+	tmpDir, err := os.MkdirTemp("", "pb_notify_test*")
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { os.RemoveAll(tmpDir) })
+
+	app1 := core.NewBaseApp(core.BaseAppConfig{
+		DataDir: tmpDir,
+	})
+	t.Cleanup(func() { app1.OnTerminate().Trigger(&core.TerminateEvent{App: app1}); app1.ResetBootstrapState() })
+	watcher.Register(app1)
+	if err := app1.Bootstrap(); err != nil {
+		t.Fatal(err)
+	}
+
+	app2 := core.NewBaseApp(core.BaseAppConfig{
+		DataDir: tmpDir,
+	})
+	t.Cleanup(func() { app2.OnTerminate().Trigger(&core.TerminateEvent{App: app2}); app2.ResetBootstrapState() })
+	watcher.Register(app2)
+	if err := app2.Bootstrap(); err != nil {
+		t.Fatal(err)
+	}
+
+	timeout := time.After(3 * time.Second)
+	done := make(chan struct{})
+
+	app1.OnSettingsReload().BindFunc(func(e *core.SettingsReloadEvent) error {
+		testEvents.SetFunc(app1, func(old int) int {
+			return old + 1
+		})
+		return e.Next()
+	})
+
+	app2.OnSettingsReload().BindFunc(func(e *core.SettingsReloadEvent) error {
+		err := e.Next()
+		testEvents.SetFunc(app2, func(old int) int { return old + 1 })
+		done <- struct{}{}
+		return err
+	})
+
+	// updating app1 settings should trigger a reload in app2
+	app1.Settings().SuperuserIPs = []string{"127.0.0.1"}
+	if err := app1.Save(app1.Settings()); err != nil {
+		t.Fatal(err)
+	}
+
+	// wait for the event
+	select {
+	case <-timeout:
+		t.Fatal("app2 reload event timeout")
+	case <-done:
+		// ready
+	}
+
+	if app1Total := testEvents.Get(app1); app1Total != 1 {
+		t.Fatalf("Expected 1 app1 event, got %d", app1Total)
+	}
+
+	if app2Total := testEvents.Get(app2); app2Total != 1 {
+		t.Fatalf("Expected 1 app2 event, got %d", app2Total)
+	}
+
+	snapshot, err := app2.Settings().Clone()
+	if err != nil {
+		t.Fatal(err)
+	}
+	app2SuperuserIPs := snapshot.SuperuserIPs
+	if len(app2SuperuserIPs) != 1 || app2SuperuserIPs[0] != "127.0.0.1" {
+		t.Fatalf("Expected exactly 127.0.0.1 superuser IP in app2 settings event, got %v", app2SuperuserIPs)
+	}
+}
+
+func TestNotifyWatcher_CollectionsUpdate(t *testing.T) {
+	t.Parallel()
+
+	tmpDir, err := os.MkdirTemp("", "pb_notify_test*")
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { os.RemoveAll(tmpDir) })
+
+	app1 := core.NewBaseApp(core.BaseAppConfig{
+		DataDir: tmpDir,
+	})
+	t.Cleanup(func() { app1.OnTerminate().Trigger(&core.TerminateEvent{App: app1}); app1.ResetBootstrapState() })
+	watcher.Register(app1)
+	if err := app1.Bootstrap(); err != nil {
+		t.Fatal(err)
+	}
+
+	app2 := core.NewBaseApp(core.BaseAppConfig{
+		DataDir: tmpDir,
+	})
+	t.Cleanup(func() { app2.OnTerminate().Trigger(&core.TerminateEvent{App: app2}); app2.ResetBootstrapState() })
+	watcher.Register(app2)
+	if err := app2.Bootstrap(); err != nil {
+		t.Fatal(err)
+	}
+
+	testQueries := store.New[string, []string](nil)
+	app2.ConcurrentDB().(*dbx.DB).QueryLogFunc = func(ctx context.Context, t time.Duration, sql string, rows *sql.Rows, err error) {
+		testQueries.SetFunc("concurrent", func(old []string) []string {
+			return append(old, sql)
+		})
+	}
+	app2.ConcurrentDB().(*dbx.DB).ExecLogFunc = func(ctx context.Context, t time.Duration, sql string, result sql.Result, err error) {
+		testQueries.SetFunc("concurrent", func(old []string) []string {
+			return append(old, sql)
+		})
+	}
+	app2.NonconcurrentDB().(*dbx.DB).QueryLogFunc = func(ctx context.Context, t time.Duration, sql string, rows *sql.Rows, err error) {
+		testQueries.SetFunc("nonconcurrent", func(old []string) []string {
+			return append(old, sql)
+		})
+	}
+	app2.NonconcurrentDB().(*dbx.DB).ExecLogFunc = func(ctx context.Context, t time.Duration, sql string, result sql.Result, err error) {
+		testQueries.SetFunc("nonconcurrent", func(old []string) []string {
+			return append(old, sql)
+		})
+	}
+
+	ctx, cancelCtx := context.WithTimeout(context.Background(), 1*time.Second)
+	defer cancelCtx()
+
+	sem := semaphore.NewWeighted(1)
+	sem.Acquire(ctx, 1)
+
+	// currently there is no hook for the collections cache reload so we pool instead
+	done := make(chan bool, 1)
+	ticker := time.NewTicker(100 * time.Millisecond)
+	go func() {
+		for {
+			select {
+			case <-ticker.C:
+				if len(testQueries.Get("concurrent")) == 1 {
+					sem.Release(1)
+					return
+				}
+			case <-done:
+				return
+			}
+		}
+	}()
+
+	// create/update/delete app1 collections should trigger a reload in app2
+	dummyCollection := core.NewBaseCollection("test")
+	if err := app1.Save(dummyCollection); err != nil {
+		t.Fatal(err)
+	}
+	dummyCollection.Fields.Add(&core.TextField{Name: "test"})
+	if err := app1.Save(dummyCollection); err != nil {
+		t.Fatal(err)
+	}
+	if err := app1.Delete(dummyCollection); err != nil {
+		t.Fatal(err)
+	}
+
+	// block until released or timeouted
+	sem.Acquire(ctx, 1)
+	ticker.Stop()
+	done <- true
+
+	nonconcurrentQueries := testQueries.Get("nonconcurrent")
+	concurrentQueries := testQueries.Get("concurrent")
+
+	if len(nonconcurrentQueries) != 0 {
+		t.Fatalf("Expected 0 concurrent queries, got %d (%v)", len(nonconcurrentQueries), nonconcurrentQueries)
+	}
+	if len(concurrentQueries) != 1 {
+		t.Fatalf("Expected 1 concurrent query, got %d (%v)", len(concurrentQueries), concurrentQueries)
+	}
+
+	expectedQuery := "SELECT {{_collections}}.* FROM `_collections` ORDER BY `rowid` ASC"
+	if concurrentQueries[0] != expectedQuery {
+		t.Fatalf("Expected query\n%s\ngot\n%s", expectedQuery, concurrentQueries[0])
+	}
+}

package/web/static.go

@@ -0,0 +1,99 @@
+package web
+
+import (
+	"errors"
+	"github.com/pocketbase/pocketbase/apis"
+	"github.com/pocketbase/pocketbase/core"
+	"github.com/pocketbase/pocketbase/tools/router"
+	"io/fs"
+	"net/http"
+	"path/filepath"
+	"strings"
+)
+
+type StaticOptions struct {
+	Fallback string
+}
+
+func StaticWithOptions(fsys fs.FS, options StaticOptions) func(*core.RequestEvent) error {
+	if options.Fallback != "" && (!fs.ValidPath(options.Fallback) || strings.Contains(options.Fallback, "\\")) {
+		panic("StaticWithOptions: fallback must be a relative filesystem path")
+	}
+	return staticHandler(fsys, options.Fallback, false)
+}
+
+func staticHandler(fsys fs.FS, fallback string, legacy bool) func(*core.RequestEvent) error {
+	if fsys == nil {
+		panic("Static: the provided fs.FS argument is nil")
+	}
+
+	return func(e *core.RequestEvent) error {
+		// disable the activity logger to avoid flooding with messages
+		//
+		// note: errors are still logged
+		if e.Get("skipSuccessActivityLog") == nil {
+			e.Set("skipSuccessActivityLog", true)
+		}
+
+		filename := e.Request.PathValue(apis.StaticWildcardParam)
+		filename = filepath.ToSlash(filepath.Clean(strings.TrimPrefix(filename, "/")))
+
+		// eagerly check for directory traversal
+		//
+		// note: this is just out of an abundance of caution because the fs.FS implementation could be non-std,
+		// but usually shouldn't be necessary since os.DirFS.Open is expected to fail if the filename starts with dots
+		if len(filename) > 2 && filename[0] == '.' && filename[1] == '.' && (filename[2] == '/' || filename[2] == '\\') {
+			if fallback != "" && filename != fallback {
+				return e.FileFS(fsys, fallback)
+			}
+			return router.ErrFileNotFound
+		}
+
+		fi, err := fs.Stat(fsys, filename)
+		if err != nil {
+			if fallback != "" && filename != fallback && (legacy || errors.Is(err, fs.ErrNotExist)) {
+				return e.FileFS(fsys, fallback)
+			}
+			if !legacy && !errors.Is(err, fs.ErrNotExist) {
+				return err
+			}
+			return router.ErrFileNotFound
+		}
+
+		if fi.IsDir() {
+			// redirect to a canonical dir url, aka. with trailing slash
+			if !strings.HasSuffix(e.Request.URL.Path, "/") {
+				return e.Redirect(http.StatusMovedPermanently, safeRedirectPath(e.Request.URL.Path+"/"))
+			}
+		} else {
+			urlPath := e.Request.URL.Path
+			if strings.HasSuffix(urlPath, "/") {
+				// redirect to a non-trailing slash file route
+				urlPath = strings.TrimRight(urlPath, "/")
+				if len(urlPath) > 0 {
+					return e.Redirect(http.StatusMovedPermanently, safeRedirectPath(urlPath))
+				}
+			} else if stripped, ok := strings.CutSuffix(urlPath, router.IndexPage); ok {
+				// redirect without the index.html
+				return e.Redirect(http.StatusMovedPermanently, safeRedirectPath(stripped))
+			}
+		}
+
+		fileErr := e.FileFS(fsys, filename)
+
+		if fileErr != nil && fallback != "" && filename != fallback && errors.Is(fileErr, router.ErrFileNotFound) {
+			return e.FileFS(fsys, fallback)
+		}
+
+		return fileErr
+	}
+}
+
+// safeRedirectPath normalizes the path string by replacing all beginning slashes
+// (`\\`, `//`, `\/`) with a single forward slash to prevent open redirect attacks
+func safeRedirectPath(path string) string {
+	if len(path) > 1 && (path[0] == '\\' || path[0] == '/') && (path[1] == '\\' || path[1] == '/') {
+		path = "/" + strings.TrimLeft(path, `/\`)
+	}
+	return path
+}