basepath

func CookiePath ¶

func CookiePath(ctx context.Context) string

CookiePath is the Path attribute for a cookie filex sets: the base, or "/" at the root. A cookie scoped to the base is not sent to the other applications on the same host.

func From ¶

func From(ctx context.Context) string

From returns the base the request arrived under: "" at the root.

func FromURL ¶

func FromURL(raw string) (string, error)

FromURL returns the normalized path of an absolute URL, "" when it has none.

A trailing slash is forgiven here and not in Normalize: `FILEX_PUBLIC_URL` has always been accepted as `https://example.com/` and trimmed, and the same URL with a path (`https://example.com/filex/`) is the same address. A string that is not an absolute URL has no path to offer and yields "".

func Middleware ¶

func Middleware(base string) func(http.Handler) http.Handler

Middleware serves the router under base. With base "" it returns next itself: the root deployment runs exactly the code it ran before this package existed.

Under a base:

• `<base>/…` has the base taken off the path (and the escaped path) and the base put on the context, then goes on;
• `<base>` itself is a directory, like `/admin`: a 301 to `<base>/`;
• `/healthz` goes on unchanged (see the package comment);
• anything else is a plain 404, before any handler, cookie or auth chain.

⚠ When the escaped path is set (the client percent-encoded something), it has to carry the base LITERALLY as well. The router routes on the escaped path when there is one, so a request whose decoded path starts with the base while its escaped path does not (`/fil%65x/…`, `/filex%2Fapi/…`) would have the two halves disagree about where the prefix ends. Such a request is refused rather than guessed at.

func Normalize ¶

func Normalize(raw string) (string, error)

Normalize validates a configured base path and returns it in canonical form: "" for the root, otherwise "/seg[/seg…]" with no trailing slash.

⚠ Deliberately strict, because the value ends up in every redirect, cookie path and link filex hands out:

• it must start with "/" (a relative base has nothing to be relative to);
• it must NOT end with "/" — `/filex/` and `/filex` would otherwise be two spellings of one base, and a cookie scoped to one does not always match the other;
• no empty, "." or ".." segment — a base that climbs out of itself is a path-confusion hole, not a prefix;
• segments use only the URL's unreserved characters (letters, digits and `- . _ ~`). Anything else would need percent-encoding, and then the escaped path the browser sends and the decoded path the router reads start differently, which is where a prefix check can be talked past.

"" and "/" both mean the root.

func Path ¶

func Path(ctx context.Context, p string) string

Path returns p (an absolute application path such as "/admin/") as the browser has to ask for it: with the base in front.

⚠ For what the BROWSER resolves — a Location header, a link or a form in a page the server renders, the target of a bounce. A relative URL inside a JSON answer (`thumb_url`, a `/z/` ticket) stays relative to the server root: its reader joins it with its own API base, which already carries the prefix and which a proxying embed may have mapped somewhere else entirely.

func Strip ¶

func Strip(base, p string) (string, bool)

Strip removes base from an absolute path the client sent in a HEADER (a WebDAV `Destination`), reporting false when the path is outside the base. A root base returns p unchanged.

func With ¶

func With(ctx context.Context, base string) context.Context

With returns ctx carrying base. The router does this once per request; a test does it to build a request that arrived under a base.