Files
marqdo/plugins/web/internal/tenant/tenant.go
cflmyandCursor 5cf84fe9b7 feat(web): RBAC, tenant scope, and WS room hooks
Add configurable role⊥permission (five tables, gate permissions, register,
/_rbac desk), multi-tenant path/header resolution with JSON tenant_scope,
and route_ws on_message/presence/dynamic room_key — with author surfaces,
demos, and smokes.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-09-17 20:54:02 +08:00

253 lines
5.8 KiB
Go

// Package tenant resolves multi-tenant request context for ext/web.
package tenant
import (
"context"
"fmt"
"net/http"
"strings"
)
type ctxKey int
const requestKey ctxKey = 1
// Config is stored on the app bag under key "tenant".
type Config struct {
Mode string // path | subdomain | header
Param string // path capture / query / header name
Column string // DB column (default tenant_id)
DefaultScope bool // auto-scope all selects/inserts when true
}
// FromBag reads tenant config from an app bag.
func FromBag(appBag map[string]any) Config {
cfg := Config{Column: "tenant_id"}
raw, ok := appBag["tenant"].(map[string]any)
if !ok {
return cfg
}
cfg.Mode = strings.ToLower(strings.TrimSpace(str(raw, "mode", "模式")))
cfg.Param = strings.TrimSpace(str(raw, "param", "参数", "tenant_param"))
if c := str(raw, "column", "列", "tenant_column"); c != "" {
cfg.Column = c
}
if v, ok := raw["default_scope"]; ok {
cfg.DefaultScope = boolish(v)
} else if v, ok := raw["默认作用域"]; ok {
cfg.DefaultScope = boolish(v)
} else if v, ok := raw["scope"]; ok {
cfg.DefaultScope = boolish(v)
}
return cfg
}
// Enabled reports whether tenant resolution is configured.
func (c Config) Enabled() bool {
return c.Mode != ""
}
// Configure merges tenant options onto the app bag.
func Configure(appBag map[string]any, opts map[string]any) (map[string]any, error) {
if opts == nil {
opts = map[string]any{}
}
mode := strings.ToLower(strings.TrimSpace(str(opts, "mode", "模式")))
if mode == "" {
return nil, fmt.Errorf("tenant: mode required (path|subdomain|header)")
}
switch mode {
case "path", "路径", "subdomain", "子域", "header", "头":
default:
return nil, fmt.Errorf("tenant: unknown mode %q", mode)
}
if mode == "路径" {
mode = "path"
}
if mode == "子域" {
mode = "subdomain"
}
if mode == "头" {
mode = "header"
}
param := strings.TrimSpace(str(opts, "param", "参数", "tenant_param"))
if param == "" {
switch mode {
case "path":
param = "t"
case "header":
param = "X-Tenant-Id"
case "subdomain":
param = ""
}
}
col := strings.TrimSpace(str(opts, "column", "列", "tenant_column"))
if col == "" {
col = "tenant_id"
}
entry := map[string]any{
"mode": mode,
"param": param,
"column": col,
}
if v, ok := first(opts, "default_scope", "默认作用域", "scope"); ok {
entry["default_scope"] = boolish(v)
}
out := clone(appBag)
out["tenant"] = entry
return out, nil
}
// Resolve extracts tenant id from the HTTP request.
func Resolve(r *http.Request, cfg Config) string {
if !cfg.Enabled() {
return ""
}
switch cfg.Mode {
case "path":
if cfg.Param != "" {
if v := r.PathValue(cfg.Param); v != "" {
return sanitize(v)
}
if v := r.URL.Query().Get(cfg.Param); v != "" {
return sanitize(v)
}
// /t/{tenant}/… when param is t: take segment after /t/
parts := strings.Split(strings.Trim(r.URL.Path, "/"), "/")
if cfg.Param == "t" && len(parts) >= 2 && parts[0] == "t" {
return sanitize(parts[1])
}
for i, p := range parts {
if p == cfg.Param && i+1 < len(parts) {
return sanitize(parts[i+1])
}
}
}
case "subdomain":
host := r.Host
if h, _, ok := strings.Cut(host, ":"); ok {
host = h
}
labels := strings.Split(host, ".")
if len(labels) >= 3 {
return sanitize(labels[0])
}
case "header":
name := cfg.Param
if name == "" {
name = "X-Tenant-Id"
}
return sanitize(r.Header.Get(name))
}
return ""
}
// WithContext stores tenant id on the request context.
func WithContext(ctx context.Context, id string) context.Context {
return context.WithValue(ctx, requestKey, id)
}
// FromContext reads tenant id (empty if unset).
func FromContext(ctx context.Context) string {
if ctx == nil {
return ""
}
if s, ok := ctx.Value(requestKey).(string); ok {
return s
}
return ""
}
// MergeWhere adds tenant_id equality to a where value (map or list of maps).
func MergeWhere(where any, column, tenantID string) any {
if tenantID == "" || column == "" {
return where
}
clause := map[string]any{"字段": column, "field": column, "操作": "=", "op": "=", "值": tenantID, "value": tenantID}
switch t := where.(type) {
case nil:
return []any{clause}
case []any:
out := make([]any, 0, len(t)+1)
out = append(out, t...)
out = append(out, clause)
return out
case map[string]any:
out := cloneMap(t)
out[column] = tenantID
return out
default:
return []any{where, clause}
}
}
// StampRow sets tenant column on an insert/update row map if missing.
func StampRow(row map[string]any, column, tenantID string) map[string]any {
if row == nil || tenantID == "" || column == "" {
return row
}
if _, ok := row[column]; ok {
return row
}
out := cloneMap(row)
out[column] = tenantID
return out
}
func sanitize(s string) string {
s = strings.TrimSpace(strings.ToLower(s))
var b strings.Builder
for _, r := range s {
if (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') || r == '-' || r == '_' {
b.WriteRune(r)
}
}
return b.String()
}
func str(m map[string]any, keys ...string) string {
for _, k := range keys {
if v, ok := m[k]; ok && v != nil {
if s, ok := v.(string); ok {
return s
}
return fmt.Sprint(v)
}
}
return ""
}
func first(m map[string]any, keys ...string) (any, bool) {
for _, k := range keys {
if v, ok := m[k]; ok && v != nil {
return v, true
}
}
return nil, false
}
func boolish(v any) bool {
switch t := v.(type) {
case bool:
return t
case string:
switch strings.TrimSpace(t) {
case "true", "True", "1", "yes", "on", "真":
return true
}
case float64:
return t != 0
}
return false
}
func clone(m map[string]any) map[string]any {
out := make(map[string]any, len(m))
for k, v := range m {
out[k] = v
}
return out
}
func cloneMap(m map[string]any) map[string]any { return clone(m) }