Compare commits

..
7 Commits
Author SHA1 Message Date
cflmyandCursor fb30cd3db3 release: ext pack 1.0.5 — request context and list binds
Co-authored-by: Cursor <cursoragent@cursor.com>
2026-09-18 10:24:34 +08:00
cflmyandCursor 584cb9ac9d feat(web): request-context field sources and page list binds
Replace domain comment hacks with generic session/route/now stamps,
server-only form fields, compose_list for detail+child lists, and a live gold.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-09-18 10:17:39 +08:00
cflmy 428ee141e1 fix(ppa): keep vendor checksums and reuse published orig on debian bumps
dh_clean was stripping Cargo.toml.orig and breaking Launchpad offline
builds; debian-only uploads now reuse the PPA orig with debuild -sd.
2026-09-18 09:02:53 +08:00
cflmyandCursor ec9718466d release: ext pack 1.0.4 — RBAC, tenant, WS hooks, SPA, collab
Co-authored-by: Cursor <cursoragent@cursor.com>
2026-09-17 21:10:50 +08:00
cflmyandCursor c5bb08022a feat(web): collaborative notepad MVP over WS rooms
Add LWW text sync demo (DOC\\t protocol + presence) on route_ws rooms,
with design note and bag smoke.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-09-17 21:00:10 +08:00
cflmyandCursor b710745e88 feat(web): native SPA helpers, memory store, and demo
Add bridge scope=memory, lib/browser store_set/spa_goto, web-spa-app
list/detail/edit client routes demo, and helper smoke.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-09-17 20:58:21 +08:00
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
55 changed files with 4107 additions and 163 deletions

No files matched your search

+40
View File
@@ -8,6 +8,46 @@
### Changed
## Ext pack v1.0.5 — 2026-09-18
### Highlights
**ext/web 请求上下文与表单来源(CLI 仍为 v1.0.3)**:字段 `来源`/`source`(session / route / now)、server-only 盖戳、页面 `列表装配`/`compose_list`;禁止按业务表特判。安装:
```bash
marqdo ext add web # CDN latest → 1.0.5
```
### Added
- **Request context**:表单提交携带 `_mq_params` / `_mq_return`;`ApplySources` 从 session/route/now 写入。
- **字段来源列**:`client`(默认)/ `session.username` / `route.NAME` / `now`;非 client 不渲染且覆盖客户端伪造。
- **列表装配**:`compose_list` / `列表装配`(副绑定 + 条件/排序/插槽),详情页可同页渲染子列表。
- 设计文:[ext-web-request-context.md](doc/design/ext-web-request-context.md);金样 `ext_web_form_source_live`。
### Changed
- 扩展包 SemVer **1.0.5**(`ext/VERSION`);与 CLI **v1.0.3** 可独立安装。
- 移除评论表名特判(`enrichCommentSubmit`)。
## Ext pack v1.0.4 — 2026-09-17
### Highlights
**ext/web 能力面扩展(CLI 仍为 v1.0.3)**:可配置 RBAC、租户作用域、WS `on_message`/presence、原生 SPA 内存路由、协同记事本 MVP。安装:
```bash
marqdo ext add web # CDN latest → 1.0.4
```
### Added
- **RBAC**:五表(`web_permissions` / `web_roles` / `web_role_permissions` / `web_users` / `web_user_roles`);`app.enable_rbac`、`app.gate permissions=`、`rbac.can`、注册页、`/_rbac/*` 管理 API/desk。
- **Tenant**:`app.tenant`(path/header/subdomain)+ `tenant_scope` 自动过滤/盖戳。
- **WebSocket G-WS2**:`route_ws` 支持 `on_message` 钩子、动态 room、`presence` 通道。
- **Native SPA**:内存 `store_set` / `spa_goto` 与全页 WASM SPA 样站。
- **Collab MVP**:LWW 文档协议(`DOC\t`)双端协同记事本样站。
### Changed
- 扩展包 SemVer **1.0.4**(`ext/VERSION`);与 CLI **v1.0.3** 可独立安装。
## v1.0.3 — 2026-09-17
### Highlights
+15
View File
@@ -921,8 +921,23 @@ function runIntervalEffect(exports, spec, onError) {
intervalHandles.set(id, handle);
}
const memoryKV = new Map();
function storageStore(scope) {
if (scope === "cookie") return null;
if (scope === "memory" || scope === "mem" || scope === "内存") {
return {
getItem(key) {
return memoryKV.has(key) ? memoryKV.get(key) : null;
},
setItem(key, value) {
memoryKV.set(key, String(value));
},
removeItem(key) {
memoryKV.delete(key);
},
};
}
if (typeof localStorage === "undefined") return null;
return scope === "session" ? sessionStorage : localStorage;
}
+7
View File
@@ -1,3 +1,10 @@
marqdo (1.0.3-1ppa2) noble; urgency=medium
* Fix Launchpad build: dh_clean -Xvendor/ so cargo vendor checksums keep
Cargo.toml.orig (debian-only; reuse published 1.0.3.orig.tar.xz).
-- cflmy <pingan@cflmy.cn> Thu, 17 Sep 2026 21:28:00 +0800
marqdo (1.0.3-1ppa1) noble; urgency=medium
* Marqdo 1.0.3: PPA + ext CDN; unbound GFM tables; bundled Rust for noble.
+5
View File
@@ -46,6 +46,11 @@ override_dh_auto_install:
install -m 0755 $(CURDIR)/target/release/marqdo \
$(CURDIR)/debian/marqdo/usr/bin/marqdo
# dh_clean deletes *.orig by default; cargo vendor checksums require
# vendor/**/Cargo.toml.orig. Exclude the vendored tree from that purge.
override_dh_clean:
dh_clean -Xvendor/
override_dh_auto_clean:
dh_auto_clean
rm -rf debian/cargo_home
+19
View File
@@ -0,0 +1,19 @@
# Collaborative document MVP
| | |
|---|---|
| 状态 | **Accepted · MVP (LWW)** |
| 日期 | 2026-09-17 |
## Approach
Not a full CRDT. Peers sync plain text over `route_ws mode=room` with:
- Client → server: `DOC\\t<body>`
- Server fan-out (existing G-WS1/2)
- Apply remote if body ≠ local; `applying` flag suppresses echo
- Presence JSON on `room.presence` (`presence=True`)
## Demo
`examples/web-collab-doc/` — open two browsers on the same room.
+80
View File
@@ -0,0 +1,80 @@
# `ext/web` 可配置 RBAC(角色 ⊥ 权限)
| | |
|---|---|
| 验收 | qdqc:注册登录、评论、desk 内建角色/赋权;`tests/ext/web-rbac-*-smoke.mq.md` |
| 状态 | **Accepted · 已落地核心**(HTTP register + `/_rbac/*` + gate permissions;样站 qdqc 已接线) |
---
## 0. 一句话
权限是原子能力(`resource:action`);角色是权限包;用户通过 `user_roles` 获得角色。门禁与业务都问 `can(user, permission)`。管理员可在后台新建角色、勾选权限、赋给用户——**禁止**只靠写死的 `role=admin|user` 字符串作为唯一模型(兼容期仍可读旧 `roles=` gate)。
---
## 1. 表结构(SQLite / Postgres 同构)
| 表 | 列 |
|----|-----|
| `web_permissions` | `code` PK, `resource`, `action`, `description` |
| `web_roles` | `id` PK, `name` UNIQUE, `is_system` INT, `tenant_id` TEXT NULL |
| `web_role_permissions` | `role_id`, `permission_code` PK(role_id, permission_code) |
| `web_user_roles` | `user_id`, `role_id`, `tenant_id` TEXT NULL, PK(user_id, role_id, tenant_id) |
| `web_users` | `id` PK, `username` UNIQUE, `password_hash`, `created_at` |
命名带 `web_` 前缀,避免与业务表冲突。站点也可映射自定义表名(后期);首版固定。
---
## 2. 权限码约定
形如 `comments:create`、`desk:access`、`roles:manage`。内置种子见 `DefaultCatalog`。`*` 或角色名 `superadmin` / 兼容 `admin`:登录时展开为目录全集。
---
## 3. 作者 API
```markdown
**`应用` = > `应用`.权限 确保结构=真 目录=`权限目录`**
**`应用` = > `应用`.门禁 路径="/desk" 权限="desk:access" 匹配="prefix" 拒绝="redirect"**
**`应用` = > `应用`.鉴权 用户表=`管理员` 注册=真 注册路径="/register" …**
```
| 方法 | ABI | 说明 |
|------|-----|------|
| `app.rbac` / `权限` | `web_app_rbac` | ensure schema + optional seed catalog table |
| `app.gate` | `web_app_gate` | 新增 `permissions`/`权限`(CSV);与 `roles` 可并存:有 permissions 时按权限判定 |
| `rbac.can` | `web_rbac_can` | `{ok, allowed}` |
| `rbac.assign_role` | `web_rbac_assign_role` | 用户←角色 |
| `rbac.set_role_permissions` | `web_rbac_set_role_permissions` | 角色←权限列表 |
防提权:`set_role_permissions` / `assign_role` 在 HTTP 管理面检查操作者 `roles:manage` 且不能授予自身没有的 permission。
---
## 4. 运行时
1. `listen`:若 `auth.rbac=true` 或调用过 `app.rbac`,对 `db` URL `EnsureSchema` + 种子。
2. 登录成功:解析角色 → DB `user_roles` ∪ GFM 角色展开 → session `permissions`(CSV)+ 兼容 `role`。
3. `withRBAC`:gate 含 `permissions` 则 `PermissionAllowed`;否则旧 `RoleAllowed`。
4. 注册:`POST /register` 写入 `web_users`,默认赋 `member` 角色。
---
## 5. qdqc 映射
| 产品 | 权限码 |
|------|--------|
| 发评论 | `comments:create` |
| 删任意评论 | `comments:delete` |
| 进 desk | `desk:access` |
| 管角色 | `roles:manage` |
首个 GFM `admin` 用户登录后视为 `superadmin`(全权限);DB 迁移后绑定 `superadmin` 角色。
---
## 6. 非目标(本切片)
对象级 ACL 全图、ABAC;租户列先可空,多租户波次再启用。
+91
View File
@@ -0,0 +1,91 @@
# ext/web:请求上下文与表单字段来源
| | |
|---|---|
| 状态 | **Accepted** |
| 日期 | 2026-09-18 |
| 相关 | [ext-web.md](ext-web.md) §5.5 · 对照 Django `request.user` / URL kwargs |
| 动机 | 禁止扩展库按业务表名(如 `comments`)特判填字段;身份与路由键属于请求上下文 |
---
## 0. 原则
1. **扩展库提供机制,站点表达领域** — 不得出现 `if table == "comments"`。
2. **身份只从 session 来,且服务端盖戳** — 客户端提交的 `author` 等不可信。
3. **资源键从路由参数来** — 页面已在 `/post/{slug}` 时,表单继承该页 `params`,不解析 Referer 猜 slug。
4. **非 `client` 来源的字段默认不渲染** — 服务端在校验前写入;若 POST 带同名键,一律覆盖丢弃。
---
## 1. 请求上下文(Request)
每次处理 HTTP 请求时,框架逻辑上持有:
| 键 | 含义 |
|----|------|
| `user` / `username` | 登录名;访客为空 |
| `params` | 动态路由捕获(如 `{slug}`) |
| `path` | 请求路径 |
| `method` | GET / POST / … |
| `query` | URL 查询(可选) |
与 Django 对应:`request.user`、`request.resolver_match.kwargs`、`request.path`。
页面渲染时已有 `page.params`(`injectParams`)。表单提交时通过隐藏字段 `_mq_params`(JSON)与 `_mq_return`(回跳路径)把**渲染该表单时的页上下文**带回 POST,避免依赖 Referer。
---
## 2. 字段表「来源」列
字段表增加可选列 `来源` / `source`(缺省 = `client`):
```markdown
| 字段 | 标签 | 类型 | 必填 | 默认 | 来源 |
|------|------|------|------|------|------|
| body | 写下你的想法 | textarea | true | | client |
| author | | | true | | session.username |
| post_slug | | | true | | route.slug |
| created_at | | | false | | now |
```
| 来源值 | 含义 | 渲染 |
|--------|------|------|
| `client` / 空 | 用户填写 | 正常控件 |
| `session.username` / `session.user` / `user` | 当前登录用户名 | 不渲染 |
| `route.NAME` / `param.NAME` / `params.NAME` | `params[NAME]` | 不渲染 |
| `now` / `utc.now` / `server.now` | UTC `YYYY-MM-DD HH:MM:SS` | 不渲染 |
`类型=hidden` 仍可显式使用;与 `来源≠client` 叠加时仍不依赖客户端值(服务端覆盖)。
---
## 3. 提交管线
```
ParseForm → 去掉来源≠client 的 POST 键
→ 按字段来源从 Request 写入
→ validate → insert/update
→ 回跳:优先 _mq_return(同站路径),否则 form.redirect
```
伪造 `author` / `post_slug` 无效。
---
## 4. 页面列表装配(副绑定)
详情页可附加与主主体**不同查询条件**的列表绑定(如评论):
```markdown
**post = > post.列表装配 主体=`评论卡片` 条件=`评论条件` 排序="-created_at"**
```
条件值同样支持 `{slug}`。渲染在主文章/卡片区之后,无需为子资源单独写 JSON API + 前端过滤。
---
## 5. 非目标
- 不在扩展库内实现「评论」领域类型。
- 不把 Referer 解析当作正式 params 来源(仅兼容期可作 `_mq_params` 缺失时的弱回退,金样不依赖)。
+24
View File
@@ -0,0 +1,24 @@
# Native SPA(Marqdo WASM 全页客户端)
| | |
|---|---|
| 状态 | **Accepted · MVP** |
| 日期 | 2026-09-17 |
| 相关 | [browser-marqdo-wasm.md](browser-marqdo-wasm.md) · route D/E |
## 约定
| 表 | 列 | 用途 |
|----|-----|------|
| 客户端路由 | `路径` / `面板` / `标题` | 文档化视图;运行时用 `path` + `set_attr(hidden)` 切换 |
| 客户端状态 | `browser.store_set` / `store_get` `scope=memory` | 页内状态(列表 JSON、当前 id) |
作者零业务 JS:`web.client_embed` + `static/client.mq.md` + `lib/browser`。
## Bridge
`storage` effect 支持 `scope=memory`(进程内 `Map`),与 `local` / `session` / `cookie` 并列。
## Demo
`examples/web-spa-app/` — 列表 → 详情 → 编辑,全客户端路由。
+23
View File
@@ -0,0 +1,23 @@
# ext/web multi-tenant (path / subdomain / header)
| | |
|---|---|
| 状态 | **Accepted · MVP** |
| 日期 | 2026-09-17 |
| 相关 | [ext-web-rbac.md](ext-web-rbac.md) · full-ambition plan |
## Author API
```markdown
**应用 = > `应用`.tenant mode="path" param="t" column="tenant_id" default_scope=False**
```
JSON route table may set `tenant_scope` / `租户作用域` = true so `GET /api/items?t=acme` only returns rows with `tenant_id=acme`.
## Runtime
1. `withTenant` resolves id into request context.
2. Scoped JSON selects `AND tenant_id=?`; missing tenant → 400.
3. `default_scope=True` also stamps form POST bodies.
Demo: `examples/web-tenant-saas/`.
+7 -3
View File
@@ -3,8 +3,8 @@
| | |
|---|---|
| 状态 | **Accepted · W0–W7 + P3 + W8(站点图标/Head/图片装配)完结**(SQLite/Postgres 作者面:页面装配 / db CRUD+`where` / form / 嵌入主区 / `app.route` / 路由 `/_part` / admin UI / RBAC / 上传相册 / SEO·RSS·sitemap / **favicon·头资源·图片装配**;Postgres 等见 §9) |
| 日期 | 2026-08-11(W8:2026-08-29) |
| 相关 | [markdown-mapping.md](markdown-mapping.md) · [module-namespace.md](module-namespace.md) · [objects.md](objects.md) · [ext-abi.md](ext-abi.md) · [ext-cli.md](ext-cli.md) · [stdlib-i18n.md](stdlib-i18n.md) · [web-assets-and-images.md](web-assets-and-images.md) |
| 日期 | 2026-08-11(W8:2026-08-29;请求上下文:2026-09-18) |
| 相关 | [markdown-mapping.md](markdown-mapping.md) · [module-namespace.md](module-namespace.md) · [objects.md](objects.md) · [ext-abi.md](ext-abi.md) · [ext-cli.md](ext-cli.md) · [stdlib-i18n.md](stdlib-i18n.md) · [web-assets-and-images.md](web-assets-and-images.md) · **[ext-web-request-context.md](ext-web-request-context.md)** |
| 安装(目标) | `marqdo ext add web`(中英:`web` / `网页`) |
| 本文目的 | 锁定**作者面**与**类 API**;指导实现 |
@@ -247,6 +247,7 @@ import db:db/index.mq.md
|------|------|
| compose_components / 组件装配 | 解析组件·样式路径 → 填 nav/sidebar/footer → CSS → 登记 part |
| compose_main / 主体装配 | 解析库字段与样式路径 → 填 main → 登记 part(如 id=`index`) |
| compose_list / 列表装配 | 副绑定(独立 query/order);可选 target 注入引言元素;见 [ext-web-request-context.md](ext-web-request-context.md) |
**槽位推断:** 由组件导出名决定(`nav`→顶栏,`side`→侧栏,`foot`→底栏;其余→main)。
@@ -423,6 +424,7 @@ import db:db/index.mq.md
| `类型` | 控件/值类型:`text` `textarea` `number` `email` `url` `checkbox` `select` … |
| `必填` | 是否必填 |
| `默认` | 可选默认值 |
| `来源` / `source` | 可选;见 [ext-web-request-context.md](ext-web-request-context.md):`client`(默认)/ `session.username` / `route.NAME` / `now`;非 client 不渲染且服务端盖戳 |
#### 5.5.2 校验表(作者面)
@@ -580,7 +582,9 @@ submit → action=insert → db.insert;action=update → db.update
## 9. 非本波次(可记入路线图)
- Postgres / Redis / S3 驱动细节(SQLite 已落地);
- 复杂权限与多租户;
- ~~复杂权限与多租户~~ → **可配置 RBAC** 见 [ext-web-rbac.md](ext-web-rbac.md);**多租户** 见 [ext-web-tenant.md](ext-web-tenant.md)(path/subdomain/header + `tenant_scope`);
- ~~重客户端 SPA~~ → **Native SPA** 见 [ext-web-spa.md](ext-web-spa.md)(WASM + 路由表 + `store_set` memory);
- ~~实时协同编辑~~ → **Collab MVP** 见 [ext-web-collab.md](ext-web-collab.md)(WS room LWW 文本 + presence);
- 子页路由糖的更多约定(`# 应用.route` 已够用)。
---
+2
View File
@@ -74,6 +74,8 @@ Watch: https://launchpad.net/~cflmy/+archive/ubuntu/marqdo/+builds
| Symptom | Fix |
|---------|-----|
| `lock file version 4 requires -Znext-lockfile-bump` | Rebuild with current `ppa-build-source.sh` (bundles Rust); bump `1ppaN` |
| `failed to calculate checksum of: …/vendor/…/Cargo.toml.orig` | `dh_clean` purged `*.orig`; fixed via `dh_clean -Xvendor/` (+ strip `.orig` only when **creating a new** orig); bump `1ppaN` with **`-sd`** |
| `orig.tar.xz already exists … different contents` | Never rewrite an uploaded upstream `.orig`; reuse PPA file (`ppa-build-source.sh` downloads it) and `debuild -S -sd` |
| Same version rejected by Launchpad | Bump `debian/changelog` (`1ppa2`, …) |
| Wrong series | Enable series on PPA; rebuild with that series name |
+12
View File
@@ -0,0 +1,12 @@
# web-collab-doc
Two-browser collaborative notepad over WebSocket room (last-write-wins text).
```bash
marqdo wasm build -o examples/web-collab-doc/static
cd examples/web-collab-doc
marqdo run index.mq.md
# open http://127.0.0.1:18094 twice
```
Design: [ext-web-collab.md](../../doc/design/ext-web-collab.md).
+24
View File
@@ -0,0 +1,24 @@
---
title: web-collab-doc
description: Two-browser collaborative plain-text editor over WS room (LWW snapshot sync)
import web:ext/web/web.mq.md
---
# main
Collaborative notepad: open the page in two browsers; edits fan out via
`/live/{room}` WebSocket (mode=room + presence). Build WASM first:
```
marqdo wasm build -o examples/web-collab-doc/static
```
**`embed` = > web.client_embed bridge="/static/marqdo-bridge.js" wasm="/static/marqdo_wasm.wasm" source="/static/client.mq.md" boot=True**
**`intro` = "<p class='lede'>Room <code>demo</code> · open twice to co-edit.</p><p id='presence'>presence: —</p><textarea id='doc' rows='16' cols='72' placeholder='Type together…'></textarea><pre id='log'></pre>" + embed**
**page = > web.page title="Collab doc" intro=intro layout="bare"**
**app = > web.app page=page host="127.0.0.1" port=18094**
**app = > app.static dir="static" mount="/static"**
**app = > `app`.route_ws path="/live/{id}" mode="room" room_key="doc.{id}" presence=True**
> `app`.listen
@@ -0,0 +1,85 @@
---
title: collab client
description: LWW text sync over WS room + presence (DOC\\t protocol)
import browser:lib/browser.mq.md
import table:lib/table.mq.md
import text:lib/text.mq.md
---
# main
**`ws_id` = "doc"**
**`applying` = False**
**`doc` = ""**
`wire` =
| @ | 选择器 | 事件 | 调用 | 值选择器 |
|---|--------|------|------|----------|
| 1 | "#doc" | input | on_edit | "#doc" |
`open` =
| op | id | url | then_open | then_message | then_error | then_close |
|----|----|-----|-----------|--------------|------------|------------|
| open | `ws_id` | "ws://127.0.0.1:18094/live/demo" | on_open | on_msg | on_err | on_close |
**`w` = > table.put in=None at="wire" value=wire**
**`ws` = > browser.ws spec=open**
**`boot` = > browser.merge a=w b=ws**
**`ready` = > browser.set_text sel="#log" text="connecting…"**
*> browser.merge a=boot b=ready*
## on_open
+ `ok`=True
*> browser.set_text sel="#log" text="ws open · room demo"*
## on_err
+ `error`=""
**`msg` = "ws error: " + error**
*> browser.set_text sel="#log" text=msg*
## on_close
*> browser.set_text sel="#log" text="ws closed"*
## on_edit
+ `value`=""
1. `applying`
**`applying` = False**
****
2. *
**`doc` = value**
**`payload` = "DOC\t" + value**
`send` =
| op | id | data |
|----|----|------|
| send | `ws_id` | `payload` |
*> browser.ws spec=send*
## on_msg
+ `data`=""
1. `data` != ""
**`is_pres` = > text.starts_with text=data prefix="{"**
1. `is_pres`
**`msg` = "presence: " + data**
*> browser.set_text sel="#presence" text=msg*
2. *
**`is_doc` = > text.starts_with text=data prefix="DOC\t"**
1. `is_doc`
**`remote` = > text.replace text=data old="DOC\t" new="" count=1**
1. `remote` != `doc`
**`doc` = remote**
**`applying` = True**
*> browser.set_value sel="#doc" value=remote*
2. *
****
2. *
****
2. *
****
+14
View File
@@ -0,0 +1,14 @@
# web-spa-app
Marqdo **native SPA**: list → detail → edit with client routes + `scope=memory` store. Zero author JS.
## Run
```bash
marqdo wasm build -o examples/web-spa-app/static
cd examples/web-spa-app
marqdo run index.mq.md
# http://127.0.0.1:18093
```
Design: [ext-web-spa.md](../../doc/design/ext-web-spa.md).
+23
View File
@@ -0,0 +1,23 @@
---
title: web-spa-app
description: Native Marqdo SPA — list/detail/edit via WASM client routes + memory store
import web:ext/web/web.mq.md
---
# main
Full-page client app (zero author JS). Build assets first:
```
marqdo wasm build -o examples/web-spa-app/static
```
**`embed` = > web.client_embed bridge="/static/marqdo-bridge.js" wasm="/static/marqdo_wasm.wasm" source="/static/client.mq.md" boot=True**
**`intro` = "<nav class='spa-nav'><button type='button' id='nav-list'>Items</button> <button type='button' id='nav-new'>New</button></nav><p id='title' class='spa-title'>Items</p><section id='view-list'><ul id='items'></ul><p class='hint'>Click an item for detail.</p></section><section id='view-detail' hidden><p id='detail-body'></p><p><button type='button' id='btn-edit'>Edit</button> <button type='button' id='btn-back'>Back</button></p></section><section id='view-edit' hidden><label>Title <input id='edit-title' /></label><p><button type='button' id='btn-save'>Save</button> <button type='button' id='btn-cancel'>Cancel</button></p></section><pre id='log'></pre>" + embed**
**page = > web.page title="Marqdo SPA" intro=intro layout="bare"**
**app = > web.app page=page host="127.0.0.1" port=18093**
**app = > app.static dir="static" mount="/static"**
**app = > app.redirect from="/item" to="/" permanent=False**
> `app`.listen
+174
View File
@@ -0,0 +1,174 @@
---
title: spa client
description: routes table + memory store; list / detail / edit
import browser:lib/browser.mq.md
import table:lib/table.mq.md
import text:lib/text.mq.md
---
# main
Routes (documentation + titles). Runtime switches panels by `path`.
`routes` =
| @ | 路径 | 面板 | 标题 |
|---|------|------|------|
| 1 | / | #view-list | Items |
| 2 | /item | #view-detail | Detail |
| 3 | /edit | #view-edit | Edit |
**`path` = "/"**
**`cur_id` = ""**
**`items` = "Alpha\nBeta"**
`wire` =
| @ | 选择器 | 事件 | 调用 | 委托 | 值选择器 |
|---|--------|------|------|------|----------|
| 1 | "#nav-list" | click | go_list | | |
| 2 | "#nav-new" | click | go_new | | |
| 3 | "#items" | click | open_item | "li[data-id]" | |
| 4 | "#btn-edit" | click | go_edit | | |
| 5 | "#btn-back" | click | go_list | | |
| 6 | "#btn-save" | click | save_item | | "#edit-title" |
| 7 | "#btn-cancel" | click | go_list | | |
| 8 | "window" | popstate | on_pop | | |
`seed` =
| op | key | value | scope |
|----|-----|-------|-------|
| set | spa-items | `items` | memory |
**`w` = > table.put in=None at="wire" value=wire**
**`s` = > browser.storage spec=seed**
**`boot` = > browser.merge a=w b=s**
**`ready` = > browser.set_text sel="#log" text="spa ready — click Items"**
*> browser.merge a=boot b=ready*
## on_pop
+ `path`=""
1. `path` != ""
**`path` = path**
2. *
****
*> spa_render*
## go_list
**`path` = "/"**
**`cur_id` = ""**
*> spa_render*
## go_new
**`path` = "/edit"**
**`cur_id` = ""**
*> spa_render*
## go_edit
**`path` = "/edit"**
*> spa_render*
## open_item
+ `data_id`=""
1. `data_id` != ""
**`cur_id` = data_id**
**`path` = "/item"**
*> spa_render*
2. *
****
## save_item
+ `value`=""
1. `value` != ""
1. `cur_id` != ""
**`parts` = > text.str_split s=items sep="\n"**
**`next` = ""**
- [item](parts)
1. `item` != ""
1. `item` == `cur_id`
1. `next` == ""
**`next` = value**
2. *
**`next` = next + "\n" + value**
2. *
1. `next` == ""
**`next` = item**
2. *
**`next` = next + "\n" + item**
**`items` = next**
**`cur_id` = value**
2. *
1. `items` == ""
**`items` = value**
2. *
**`items` = items + "\n" + value**
**`cur_id` = value**
**`path` = "/item"**
*> spa_render*
2. *
*> browser.set_text sel="#log" text="title required"*
## spa_render
*> spa_paint*
## spa_paint
**`hide` = > table.put in=None at="hidden" value=""**
**`show` = > table.put in=None at="hidden" value=False**
1. `path` == "/item"
`attrs` =
| #view-detail | #view-list | #view-edit |
|--------------|------------|------------|
| `show` | `hide` | `hide` |
**`title` = "Detail"**
**`body` = cur_id**
2. *
1. `path` == "/edit"
`attrs` =
| #view-edit | #view-list | #view-detail |
|------------|------------|--------------|
| `show` | `hide` | `hide` |
**`title` = "Edit"**
**`body` = cur_id**
2. *
`attrs` =
| #view-list | #view-detail | #view-edit |
|------------|--------------|------------|
| `show` | `hide` | `hide` |
**`title` = "Items"**
**`body` = ""**
**`parts` = > text.str_split s=items sep="\n"**
**`html` = ""**
- [item](parts)
1. `item` != ""
**`html` = html + "<li data-id=\"" + item + "\">" + item + "</li>"**
`persist` =
| op | key | value | scope |
|----|-----|-------|-------|
| set | spa-items | `items` | memory |
**`t` = > browser.set_text sel="#title" text=title**
**`a` = > browser.wrap key="set_attr" value=attrs**
**`ret` = > browser.merge a=t b=a**
**`list` = > browser.set_html sel="#items" html=html**
**`ret` = > browser.merge a=ret b=list**
**`d` = > browser.set_text sel="#detail-body" text=body**
**`ret` = > browser.merge a=ret b=d**
1. `path` == "/edit"
**`v` = > browser.set_value sel="#edit-title" value=cur_id**
**`ret` = > browser.merge a=ret b=v**
2. *
****
**`nav` = > browser.spa_goto url=path**
**`ret` = > browser.merge a=ret b=nav**
**`log` = > browser.set_text sel="#log" text=path**
**`ret` = > browser.merge a=ret b=log**
**`sav` = > browser.storage spec=persist**
*> browser.merge a=ret b=sav*
+33
View File
@@ -0,0 +1,33 @@
---
title: web-tenant-saas demo
description: Dual-tenant isolation via ?t= query + tenant_scope JSON API.
import web:ext/web/web.mq.md
---
# main
`items_schema` =
| name | type | nullable |
|------|------|----------|
| id | integer | false |
| title | text | false |
| tenant_id | text | false |
`api` =
| path | method | table | order | limit | tenant_scope |
|------|--------|-------|-------|-------|--------------|
| api/items | GET | items | id | 50 | true |
**db = > web.db url="sqlite:data/tenant-saas.db"**
> `db`.init name=items fields=`items_schema`
> `db`.exec sql="DELETE FROM items"
> `db`.exec sql="INSERT INTO items(title, tenant_id) VALUES('Acme note','acme')"
> `db`.exec sql="INSERT INTO items(title, tenant_id) VALUES('Beta note','beta')"
**page = > web.page title="Tenant SaaS" intro="<p>Try <a href='/api/items?t=acme'>/api/items?t=acme</a> vs <a href='/api/items?t=beta'>/api/items?t=beta</a>.</p>"**
**app = > web.app page=`page` db=`db` host="127.0.0.1" port=18092 admin=False**
**app = > `app`.tenant mode="path" param="t" default_scope=False**
**app = > `app`.configure json=`api`**
> `app`.listen
+12
View File
@@ -0,0 +1,12 @@
---
title: web-ws-room demo
description: Dynamic room WS with presence (G-WS1/2 bag). Open / and connect via bridge or wscat.
import web:ext/web/web.mq.md
---
# main
**page = > web.page title="WS room" intro="<p class='lede'>Chat room <code>lobby</code> via <code>/chat/lobby</code>. Presence joins <code>chat.room.lobby.presence</code>.</p><pre id='log'></pre>"**
**app = > web.app page=`page` host="127.0.0.1" port=18091 admin=False**
**app = > `app`.route_ws path="/chat/{id}" mode="room" room_key="chat.room.{id}" presence=True**
> `app`.listen
+1 -1
View File
@@ -1 +1 @@
1.0.3
1.0.5
+84 -6
View File
@@ -242,6 +242,17 @@ Assemble main from a bind table (`|属性|值|样式|` or `|front|back|css|`).
*> web_compose_main page=`self` main=`main`*
## compose_list
+ `main`
+ `query`=None
+ `order`=""
+ `target`=""
Secondary list bind (e.g. comments on a detail page). Same bind shape as compose_main.
Optional query supports route param placeholders; optional target injects into an intro element id.
*> web_compose_list page=`self` main=`main` query=`query` order=`order` target=`target`*
## compose_intro
+ `intro`
@@ -733,10 +744,13 @@ Serve `/`, routed pages, `/_part/{id}` (home) and `{path}/_part/{id}` (routes),
+ `path`
+ `echo`=True
+ `mode`=None
+ `room_key`=None
+ `on_message`=None
+ `presence`=False
Register a WebSocket endpoint at `path` (e.g. `/live`). `mode` is `echo` (default), `broadcast` (fan-out text to all sockets on this path), or `drain`. Legacy `echo=False` maps to `drain`. Connect from a client with `web.ws.connect`.
Register a WebSocket endpoint at `path` (e.g. `/live` or `/chat/{id}`). `mode` is `echo` (default), `broadcast` (fan-out text to all sockets on this path), `room` (named room via `room_key`, supports `{id}` from the path), or `drain`. Legacy `echo=False` maps to `drain`. `on_message` is an optional `lib.member` hook (G-WS2): called before fan-out with `message`/`room`/`user`; return `{skip:true}` to drop or `{message:…}` to rewrite. `presence=True` also joins `room.presence` and emits join/leave JSON. Connect from a client with `web.ws.connect`.
*> web_app_route_ws app=`self` path=`path` echo=`echo` mode=`mode`*
*> web_app_route_ws app=`self` path=`path` echo=`echo` mode=`mode` room_key=`room_key` on_message=`on_message` presence=`presence`*
## auth
+ `users`
@@ -745,21 +759,42 @@ Register a WebSocket endpoint at `path` (e.g. `/live`). `mode` is `echo` (defaul
+ `login_redirect`=None
+ `logout_redirect`=None
+ `login_path`=None
+ `register`=False
+ `register_path`=/register
+ `default_role`="member"
Keep the app's `admin=True`, and gate `{admin_prefix}` (segment-boundary prefix) behind a login page (default `/admin`). Unauthenticated requests redirect to `login_path` (default `{admin_prefix}/login`, auto-excluded). Does not match `/admin-publish`-style siblings.
Keep the app's `admin=True`, and gate `{admin_prefix}` (segment-boundary prefix) behind a login page (default `/admin`). Unauthenticated requests redirect to `login_path` (default `{admin_prefix}/login`, auto-excluded). Does not match `/admin-publish`-style siblings. With `register=True` and `enable_rbac`, exposes `register_path` (writes `web_users` + default role).
*> web_app_auth app=`self` users=`users` session_ttl=`session_ttl` admin_prefix=`admin_prefix` login_redirect=`login_redirect` logout_redirect=`logout_redirect` login_path=`login_path`*
*> web_app_auth app=`self` users=`users` session_ttl=`session_ttl` admin_prefix=`admin_prefix` login_redirect=`login_redirect` logout_redirect=`logout_redirect` login_path=`login_path` register=`register` register_path=`register_path` default_role=`default_role`*
## gate
+ `path`
+ `roles`=admin
+ `permissions`=""
+ `match`=prefix
+ `on_deny`=forbid
+ `exclude`=None
Require one of `roles` (CSV) for `path`. `match=prefix` uses segment boundaries; `exact` is equality. Trailing `*` on `path` means prefix. `on_deny=redirect` sends visitors to `login_path` (with `?next=`); `forbid` returns 403. `exclude` is CSV or list of open paths.
Require access for `path`. Prefer `permissions` (CSV of `resource:action` codes such as `desk:access`); when non-empty, authorization uses the session permission set. Otherwise require one of `roles` (legacy). `match=prefix` uses segment boundaries; `exact` is equality. Trailing `*` on `path` means prefix. `on_deny=redirect` sends visitors to `login_path` (with `?next=`); `forbid` returns 403. `exclude` is CSV or list of open paths.
*> web_app_gate app=`self` path=`path` roles=`roles` match=`match` on_deny=`on_deny` exclude=`exclude`*
*> web_app_gate app=`self` path=`path` roles=`roles` permissions=`permissions` match=`match` on_deny=`on_deny` exclude=`exclude`*
## enable_rbac
+ `catalog`=None
Enable database-backed RBAC (role ⊥ permission). On listen, ensures `web_permissions` / `web_roles` / `web_role_permissions` / `web_users` / `web_user_roles` and seeds system roles `superadmin` and `member`. See `doc/design/ext-web-rbac.md`. Management UI: `GET /_rbac/desk` (needs `roles:manage`).
*> web_app_rbac app=`self` catalog=`catalog`*
## tenant
+ `mode`
+ `param`=None
+ `column`=tenant_id
+ `default_scope`=False
Enable multi-tenant resolution: `mode` is `path` (query/`/t/{id}/…`), `subdomain`, or `header`. `param` is the path/query key or header name. When `default_scope=True`, JSON routes and form inserts auto-filter/stamp `column` (default `tenant_id`). Per-route override: JSON table column `tenant_scope` / `租户作用域`.
*> web_app_tenant app=`self` mode=`mode` param=`param` column=`column` default_scope=`default_scope`*
## gallery
+ `path`=/gallery
@@ -843,6 +878,49 @@ Mount `GET path` to stream an object. Path must capture `key` (use `{*key}` for
*> web_app_download app=`self` path=`path` storage=`storage` disposition=`disposition`*
# rbac
Offline helpers for role ⊥ permission. Prefer `app.enable_rbac` + gates for HTTP; use these for scripts/tests.
## can
+ `permissions`
+ `needed`
Return `{ok, allowed}` — whether held permission CSV includes any of `needed` (CSV). Held `*` allows all.
> ensure_plugin
*> web_rbac_can permissions=`permissions` needed=`needed`*
## assign_role
+ `url`
+ `username`
+ `role`
Bind `username` (in `web_users`) to role name.
> ensure_plugin
*> web_rbac_assign_role url=`url` username=`username` role=`role`*
## create_role
+ `url`
+ `name`
Create a non-system role; returns `{ok, id, name}`.
> ensure_plugin
*> web_rbac_create_role url=`url` name=`name`*
## set_role_permissions
+ `url`
+ `role`
+ `permissions`
+ `grantable`=""
Replace permissions on a non-system role (CSV). `grantable` restricts grants (anti-escalation); empty = full catalog.
> ensure_plugin
*> web_rbac_set_role_permissions url=`url` role=`role` permissions=`permissions` grantable=`grantable`*
# auth
+ `users`
+ `session_ttl`=3600
+84 -6
View File
@@ -227,6 +227,17 @@ import table:lib/table.mq.md
*> web_compose_main page=`self` main=`主体`*
## 列表装配
+ `主体`
+ `条件`=None
+ `排序`=""
+ `插槽`=""
详情页副绑定(如评论列表)。绑定表形同 `主体装配`;`条件` 支持 `{参数}`;
可选 `插槽`(元素 id)把列表注入引言 HTML(同表单插槽)。
*> web_compose_list page=`self` main=`主体` query=`条件` order=`排序` target=`插槽`*
## 引言装配
+ `引言`
@@ -699,10 +710,13 @@ SEO / OpenGraph 元数据表(`|键|值|`)。如 `title`、`description`、`c
+ `路径`
+ `回显`=真
+ `模式`=None
+ `房间`=None
+ `消息钩子`=None
+ `在场`=假
在 `路径`(如 `/live`)注册 WebSocket 端点。`模式` 为 `echo`(默认)、`broadcast`(同路径全体广播)或 `drain`。旧参数 `回显=假` 等价于 `drain`。客户端用 `网页.实时` 的 `连接` 接入。
在 `路径`(如 `/live` 或 `/chat/{id}`)注册 WebSocket。`模式` 为 `echo`(默认)、`broadcast`、`room`(需 `房间` 键,可含 `{id}`)或 `drain`。旧参数 `回显=假` 等价于 `drain`。`消息钩子` 为可选 `库.成员`(G-WS2):广播前调用,入参含 `message`/`room`/`user`;返回 `{skip:真}` 丢弃或 `{message:…}` 改写。`在场=真` 时另进 `房间.presence` 并推送 join/leave。客户端用 `网页.实时` 的 `连接` 接入。
*> web_app_route_ws app=`self` path=`路径` echo=`回显` mode=`模式`*
*> web_app_route_ws app=`self` path=`路径` echo=`回显` mode=`模式` room_key=`房间` on_message=`消息钩子` presence=`在场`*
## 鉴权
+ `用户表`
@@ -711,21 +725,42 @@ SEO / OpenGraph 元数据表(`|键|值|`)。如 `title`、`description`、`c
+ `登录回跳`=None
+ `登出回跳`=None
+ `登录路径`=None
+ `注册`=假
+ `注册路径`=/register
+ `默认角色`="member"
在保持 `后台=真` 的同时,为 `{后台前缀}` 加段边界前缀门禁(默认 `/admin`)。未登录 重定向 到 `登录路径`(默认 `{前缀}/login`,自动排除)。不会匹配 `/admin-publish` 这类旁系路径。
在保持 `后台=真` 的同时,为 `{后台前缀}` 加段边界前缀门禁(默认 `/admin`)。未登录 重定向 到 `登录路径`(默认 `{前缀}/login`,自动排除)。不会匹配 `/admin-publish` 这类旁系路径。`注册=真` 且已 `启用权限` 时开放 `注册路径`(写入 `web_users` 并赋默认角色)。
*> web_app_auth app=`self` users=`用户表` session_ttl=`会话时长` admin_prefix=`后台前缀` login_redirect=`登录回跳` logout_redirect=`登出回跳` login_path=`登录路径`*
*> web_app_auth app=`self` users=`用户表` session_ttl=`会话时长` admin_prefix=`后台前缀` login_redirect=`登录回跳` logout_redirect=`登出回跳` login_path=`登录路径` register=`注册` register_path=`注册路径` default_role=`默认角色`*
## 门禁
+ `路径`
+ `角色`=admin
+ `权限`=""
+ `匹配`=prefix
+ `拒绝`=forbid
+ `排除`=None
要求会话角色落在 `角色`(CSV)之一。`匹配=prefix` 为段边界前缀;`exact` 为精确路径。路径末尾 `*` 亦表示前缀。`拒绝=redirect` 时访客跳转登录页(带 `?next=`);`forbid` 返回 403。`排除` 为 CSV/列表(如登录页)。
为 `路径` 要求访问权。优先使用 `权限`(CSV,如 `desk:access`);非空时按会话权限集判定。否则要求会话角色落在 `角色`(CSV)之一。`匹配=prefix` 为段边界前缀;`exact` 为精确路径。路径末尾 `*` 亦表示前缀。`拒绝=redirect` 时访客跳转登录页(带 `?next=`);`forbid` 返回 403。`排除` 为 CSV/列表(如登录页)。
*> web_app_gate app=`self` path=`路径` roles=`角色` match=`匹配` on_deny=`拒绝` exclude=`排除`*
*> web_app_gate app=`self` path=`路径` roles=`角色` permissions=`权限` match=`匹配` on_deny=`拒绝` exclude=`排除`*
## 启用权限
+ `目录`=None
启用库表 RBAC(角色 ⊥ 权限)。listen 时确保五表并种子 `superadmin` / `member`。见 `doc/design/ext-web-rbac.md`。管理台:`GET /_rbac/desk`(需 `roles:manage`)。
*> web_app_rbac app=`self` catalog=`目录`*
## 租户
+ `模式`
+ `参数`=None
+ `列`=tenant_id
+ `默认作用域`=假
启用多租户解析:`模式` 为 `path`(查询参数或 `/t/{id}/…`)、`subdomain` 或 `header`。`参数` 为路径/查询键或请求头名。`默认作用域=真` 时 JSON 路由与表单插入自动按 `列`(默认 `tenant_id`)过滤/盖戳。单路由可用表列 `租户作用域` 覆盖。
*> web_app_tenant app=`self` mode=`模式` param=`参数` column=`列` default_scope=`默认作用域`*
## 相册
+ `路径`=/gallery
@@ -809,6 +844,49 @@ SEO / OpenGraph 元数据表(`|键|值|`)。如 `title`、`description`、`c
*> web_app_download app=`self` path=`路径` storage=`存储` disposition=`处置`*
# 权限
角色 ⊥ 权限的离线助手。HTTP 侧优先 `应用.启用权限` + 门禁;脚本/测试可用本类。
## 可否
+ `权限`
+ `需要`
返回 `{ok, allowed}`:持有权限 CSV 是否包含 `需要`(CSV)中任一码。持有 `*` 则全允许。
> 确保插件
*> web_rbac_can permissions=`权限` needed=`需要`*
## 赋角色
+ `数据库`
+ `用户名`
+ `角色`
将 `用户名`(须已在 `web_users`)绑定到角色名。
> 确保插件
*> web_rbac_assign_role url=`数据库` username=`用户名` role=`角色`*
## 建角色
+ `数据库`
+ `名称`
新建非系统角色;返回 `{ok, id, name}`。
> 确保插件
*> web_rbac_create_role url=`数据库` name=`名称`*
## 设角色权限
+ `数据库`
+ `角色`
+ `权限`
+ `可授`=""
覆盖非系统角色的权限(CSV)。`可授` 限制可授予码(防提权);空则允许整份目录。
> 确保插件
*> web_rbac_set_role_permissions url=`数据库` role=`角色` permissions=`权限` grantable=`可授`*
# 鉴权
+ `用户表`
+ `会话时长`=3600
+44
View File
@@ -154,6 +154,50 @@ focus.
*> table.put in=None at="navigate" value=spec*
## store_set
+ `key`
+ `value`
+ `scope`="memory"
In-memory (or local/session) key write for SPA client state. Prefer `scope=memory` for tab-local app state.
`spec` =
| op | key | value | scope |
|----|-----|-------|-------|
| set | `key` | `value` | `scope` |
*> table.put in=None at="storage" value=spec*
## store_get
+ `key`
+ `then`
+ `scope`="memory"
Read a key then call `then` with `{ok, value, found, key, scope}`.
`spec` =
| op | key | then | scope |
|----|-----|------|-------|
| get | `key` | `then` | `scope` |
*> table.put in=None at="storage" value=spec*
## spa_goto
+ `url`
+ `replace`=False
SPA navigation: `history.pushState` / `replaceState` via bridge `navigate` effect.
`spec` =
| url | replace |
|-----|---------|
| `url` | `replace` |
*> table.put in=None at="navigate" value=spec*
## storage
+ `spec`
+44
View File
@@ -153,6 +153,50 @@ import table:lib/table.mq.md
*> table.put in=None at="navigate" value=spec*
## 存设
+ `键`
+ `值`
+ `作用域`="memory"
SPA 客户端状态写入。优先 `作用域=memory`(页内内存)。
`spec` =
| op | key | value | scope |
|----|-----|-------|-------|
| set | `键` | `值` | `作用域` |
*> table.put in=None at="storage" value=spec*
## 存取
+ `键`
+ `然后`
+ `作用域`="memory"
读取键并回调 `然后`,参数含 `{ok, value, found, key, scope}`。
`spec` =
| op | key | then | scope |
|----|-----|------|-------|
| get | `键` | `然后` | `作用域` |
*> table.put in=None at="storage" value=spec*
## 页跳
+ `url`
+ `替换`=False
SPA 导航(bridge `navigate`)。
`spec` =
| url | replace |
|-----|---------|
| `url` | `替换` |
*> table.put in=None at="navigate" value=spec*
## 存储
+ `规格`
+152
View File
@@ -17,6 +17,7 @@ import (
"github.com/marqdo/marqdo/plugins/web/internal/httpx"
"github.com/marqdo/marqdo/plugins/web/internal/middleware"
"github.com/marqdo/marqdo/plugins/web/internal/password"
"github.com/marqdo/marqdo/plugins/web/internal/rbac"
"github.com/marqdo/marqdo/plugins/web/internal/session"
)
@@ -493,3 +494,154 @@ func web_app_gate(argsJSON *C.char, outJSON **C.char, errMsg **C.char) C.int {
out, err := app.Gate(asPageMap(args["app"]), path, args)
return replyJSON(outJSON, errMsg, out, err)
}
//export web_app_rbac
func web_app_rbac(argsJSON *C.char, outJSON **C.char, errMsg **C.char) C.int {
args, err := parseArgs(argsJSON)
if err != nil {
return replyJSON(outJSON, errMsg, nil, err)
}
out, err := app.Rbac(asPageMap(args["app"]), args)
return replyJSON(outJSON, errMsg, out, err)
}
//export web_app_tenant
func web_app_tenant(argsJSON *C.char, outJSON **C.char, errMsg **C.char) C.int {
args, err := parseArgs(argsJSON)
if err != nil {
return replyJSON(outJSON, errMsg, nil, err)
}
out, err := app.Tenant(asPageMap(args["app"]), args)
return replyJSON(outJSON, errMsg, out, err)
}
//export web_rbac_can
func web_rbac_can(argsJSON *C.char, outJSON **C.char, errMsg **C.char) C.int {
args, err := parseArgs(argsJSON)
if err != nil {
return replyJSON(outJSON, errMsg, nil, err)
}
heldRaw, _ := argStrReq(args, "permissions", "权限", "held")
neededRaw, _ := argStrReq(args, "needed", "需要")
if neededRaw == "" {
neededRaw, _ = argStrReq(args, "permission", "权限码")
}
ok := rbac.HasAny(rbac.ParseCSV(heldRaw), rbac.ParseCSV(neededRaw))
return replyJSON(outJSON, errMsg, map[string]any{"ok": true, "allowed": ok}, nil)
}
//export web_rbac_ensure
func web_rbac_ensure(argsJSON *C.char, outJSON **C.char, errMsg **C.char) C.int {
args, err := parseArgs(argsJSON)
if err != nil {
return replyJSON(outJSON, errMsg, nil, err)
}
url, err := dbURLOf(args)
if err != nil {
return replyJSON(outJSON, errMsg, nil, err)
}
if err := rbac.EnsureSchema(url); err != nil {
return replyJSON(outJSON, errMsg, nil, err)
}
return replyJSON(outJSON, errMsg, map[string]any{"ok": true}, nil)
}
//export web_rbac_assign_role
func web_rbac_assign_role(argsJSON *C.char, outJSON **C.char, errMsg **C.char) C.int {
args, err := parseArgs(argsJSON)
if err != nil {
return replyJSON(outJSON, errMsg, nil, err)
}
url, err := dbURLOf(args)
if err != nil {
return replyJSON(outJSON, errMsg, nil, err)
}
user, err := argStrReq(args, "username", "用户名", "user")
if err != nil {
return replyJSON(outJSON, errMsg, nil, err)
}
role, err := argStrReq(args, "role", "角色")
if err != nil {
return replyJSON(outJSON, errMsg, nil, err)
}
err = rbac.AssignRole(url, user, role)
if err != nil {
return replyJSON(outJSON, errMsg, nil, err)
}
return replyJSON(outJSON, errMsg, map[string]any{"ok": true}, nil)
}
//export web_rbac_create_role
func web_rbac_create_role(argsJSON *C.char, outJSON **C.char, errMsg **C.char) C.int {
args, err := parseArgs(argsJSON)
if err != nil {
return replyJSON(outJSON, errMsg, nil, err)
}
url, err := dbURLOf(args)
if err != nil {
return replyJSON(outJSON, errMsg, nil, err)
}
name, err := argStrReq(args, "name", "名称")
if err != nil {
return replyJSON(outJSON, errMsg, nil, err)
}
id, err := rbac.CreateRole(url, name)
if err != nil {
return replyJSON(outJSON, errMsg, nil, err)
}
return replyJSON(outJSON, errMsg, map[string]any{"ok": true, "id": id, "name": name}, nil)
}
//export web_rbac_set_role_permissions
func web_rbac_set_role_permissions(argsJSON *C.char, outJSON **C.char, errMsg **C.char) C.int {
args, err := parseArgs(argsJSON)
if err != nil {
return replyJSON(outJSON, errMsg, nil, err)
}
url, err := dbURLOf(args)
if err != nil {
return replyJSON(outJSON, errMsg, nil, err)
}
roleName, _ := argStrReq(args, "role", "角色")
permsRaw, _ := argStrReq(args, "permissions", "权限")
grantRaw, _ := argStrReq(args, "grantable", "可授")
err = rbac.SetRolePermissionsByName(url, roleName, rbac.ParseCSV(permsRaw), rbac.ParseCSV(grantRaw))
if err != nil {
return replyJSON(outJSON, errMsg, nil, err)
}
return replyJSON(outJSON, errMsg, map[string]any{"ok": true}, nil)
}
//export web_rbac_list_roles
func web_rbac_list_roles(argsJSON *C.char, outJSON **C.char, errMsg **C.char) C.int {
args, err := parseArgs(argsJSON)
if err != nil {
return replyJSON(outJSON, errMsg, nil, err)
}
url, err := dbURLOf(args)
if err != nil {
return replyJSON(outJSON, errMsg, nil, err)
}
roles, err := rbac.ListRoles(url)
if err != nil {
return replyJSON(outJSON, errMsg, nil, err)
}
return replyJSON(outJSON, errMsg, map[string]any{"ok": true, "roles": roles}, nil)
}
//export web_rbac_list_permissions
func web_rbac_list_permissions(argsJSON *C.char, outJSON **C.char, errMsg **C.char) C.int {
args, err := parseArgs(argsJSON)
if err != nil {
return replyJSON(outJSON, errMsg, nil, err)
}
url, err := dbURLOf(args)
if err != nil {
return replyJSON(outJSON, errMsg, nil, err)
}
perms, err := rbac.ListPermissions(url)
if err != nil {
return replyJSON(outJSON, errMsg, nil, err)
}
return replyJSON(outJSON, errMsg, map[string]any{"ok": true, "permissions": perms}, nil)
}
+57 -5
View File
@@ -7,6 +7,7 @@ import (
"github.com/marqdo/marqdo/plugins/web/internal/assets"
"github.com/marqdo/marqdo/plugins/web/internal/session"
"github.com/marqdo/marqdo/plugins/web/internal/tenant"
)
// New builds an app bag matching Rust web_app_new defaults used by zh-smoke.
@@ -194,10 +195,25 @@ func Auth(appBag map[string]any, users any, opts map[string]any) (map[string]any
loginPath = prefix + "/login"
}
out["login_path"] = loginPath
out["auth"] = map[string]any{
"users": users,
"session_ttl": float64(sessionTTL),
authBag, _ := out["auth"].(map[string]any)
if authBag == nil {
authBag = map[string]any{}
} else {
authBag = clone(authBag)
}
authBag["users"] = users
authBag["session_ttl"] = float64(sessionTTL)
if v, ok := first(opts, "register", "注册"); ok {
authBag["register"] = boolish(v)
}
if v := firstStr(opts, "register_path", "注册路径"); v != "" {
authBag["register_path"] = v
out["register_path"] = v
}
if v := firstStr(opts, "default_role", "默认角色"); v != "" {
authBag["default_role"] = v
}
out["auth"] = authBag
gates := gatesOf(out)
if !hasAdminGate(gates, prefix) {
gates = append(gates, map[string]any{
@@ -214,8 +230,15 @@ func Auth(appBag map[string]any, users any, opts map[string]any) (map[string]any
return out, nil
}
// Tenant configures multi-tenant resolution on the app bag (path|subdomain|header).
func Tenant(appBag map[string]any, opts map[string]any) (map[string]any, error) {
return tenant.Configure(appBag, opts)
}
// Gate appends an RBAC gate (Rust web_app_gate).
// opts: roles/角色, match/匹配, on_deny/拒绝, exclude/排除.
// opts: roles/角色, permissions/权限, match/匹配, on_deny/拒绝, exclude/排除.
// When permissions is non-empty, the HTTP middleware authorizes by permission codes;
// otherwise it falls back to roles (legacy).
func Gate(appBag map[string]any, path string, opts map[string]any) (map[string]any, error) {
if opts == nil {
opts = map[string]any{}
@@ -225,7 +248,8 @@ func Gate(appBag map[string]any, path string, opts map[string]any) (map[string]a
return nil, fmt.Errorf("missing `path`")
}
rolesRaw := firstStr(opts, "roles", "角色")
if rolesRaw == "" {
permsRaw := firstStr(opts, "permissions", "权限")
if rolesRaw == "" && permsRaw == "" {
rolesRaw = "admin"
}
roles := session.ParseRolesCSV(rolesRaw)
@@ -233,6 +257,11 @@ func Gate(appBag map[string]any, path string, opts map[string]any) (map[string]a
for i, r := range roles {
roleAny[i] = r
}
perms := session.ParseRolesCSV(permsRaw)
permAny := make([]any, len(perms))
for i, p := range perms {
permAny[i] = p
}
matchMode := firstStr(opts, "match", "匹配")
if matchMode == "" {
matchMode = "prefix"
@@ -247,6 +276,9 @@ func Gate(appBag map[string]any, path string, opts map[string]any) (map[string]a
"match": matchMode,
"on_deny": onDeny,
}
if len(permAny) > 0 {
entry["permissions"] = permAny
}
if v, ok := first(opts, "exclude", "排除"); ok && v != nil {
entry["exclude"] = v
}
@@ -257,6 +289,26 @@ func Gate(appBag map[string]any, path string, opts map[string]any) (map[string]a
return out, nil
}
// Rbac enables DB-backed RBAC on the app (ensure schema at listen).
// opts may include catalog table (unused beyond flag for now).
func Rbac(appBag map[string]any, opts map[string]any) (map[string]any, error) {
out := clone(appBag)
authBag, _ := out["auth"].(map[string]any)
if authBag == nil {
authBag = map[string]any{}
} else {
authBag = clone(authBag)
}
authBag["rbac"] = true
if opts != nil {
if v, ok := first(opts, "catalog", "目录"); ok && v != nil {
authBag["permission_catalog"] = v
}
}
out["auth"] = authBag
return out, nil
}
// NormalizeAdminPrefix cleans and validates admin_prefix.
func NormalizeAdminPrefix(raw string) (string, error) {
path, err := cleanMountPath(raw)
+15 -2
View File
@@ -86,7 +86,7 @@ func cellStr(v any) string {
}
// Login validates credentials and creates a session.
// Success: {"ok":true,"session_id":…,"username":…,"role":…}
// Success: {"ok":true,"session_id":…,"username":…,"role":…,"permissions":…}
// Failure: {"ok":false}
func Login(username, pass string, users any, sessionTTL uint64) map[string]any {
u, role, ok := CheckCredentials(users, username, pass)
@@ -104,6 +104,14 @@ func Login(username, pass string, users any, sessionTTL uint64) map[string]any {
}
}
// AttachPermissions writes permission codes onto an existing login session.
func AttachPermissions(sessionID string, codes []string) {
if sessionID == "" {
return
}
session.SetPermissions(sessionID, codes)
}
// Check returns session auth state (web_auth_check).
func Check(sessionID string) map[string]any {
v, ok := session.GetValue(sessionID, "username")
@@ -120,7 +128,12 @@ func Check(sessionID string) map[string]any {
role = s
}
}
return map[string]any{"ok": true, "username": u, "role": role}
perms := session.PermissionsFromSession(sessionID)
out := map[string]any{"ok": true, "username": u, "role": role}
if len(perms) > 0 {
out["permissions"] = perms
}
return out
}
// Logout destroys the session (web_auth_logout).
+49 -7
View File
@@ -152,14 +152,10 @@ func ComposeComponents(page any, layout any, callLib CallLib) (any, error) {
return obj, nil
}
// ComposeMain merges a main bind table into a page bag.
func ComposeMain(page any, mainTable any, callLib CallLib) (any, error) {
obj := asObject(page)
func resolveBinds(mainTable any, callLib CallLib) (binds []any, css string, err error) {
raw := table.AsBind(mainTable)
arr, _ := raw.([]any)
binds := make([]any, 0, len(arr))
css := strField(obj, "styles_css")
binds = make([]any, 0, len(arr))
for _, b := range arr {
bm, ok := b.(map[string]any)
if !ok {
@@ -191,7 +187,7 @@ func ComposeMain(page any, mainTable any, callLib CallLib) (any, error) {
case table.SitePathLibMember:
st, err := callLib(sp.Lib + "." + sp.Member)
if err != nil {
return nil, err
return nil, "", err
}
css += table.AsCSSNamed(sp.Member, st)
cssName = sp.Member
@@ -207,6 +203,17 @@ func ComposeMain(page any, mainTable any, callLib CallLib) (any, error) {
"css": cssName,
})
}
return binds, css, nil
}
// ComposeMain merges a main bind table into a page bag.
func ComposeMain(page any, mainTable any, callLib CallLib) (any, error) {
obj := asObject(page)
binds, cssExtra, err := resolveBinds(mainTable, callLib)
if err != nil {
return nil, err
}
css := strField(obj, "styles_css") + cssExtra
if t, ok := table.BindTableName(binds); ok {
obj["table"] = t
@@ -234,6 +241,41 @@ func ComposeMain(page any, mainTable any, callLib CallLib) (any, error) {
return obj, nil
}
// ComposeList appends a secondary bind (detail + child list), with optional
// query/order/target (inject into intro element id, same as form_target).
func ComposeList(page any, mainTable any, query any, order, target string, callLib CallLib) (any, error) {
obj := asObject(page)
binds, cssExtra, err := resolveBinds(mainTable, callLib)
if err != nil {
return nil, err
}
if cssExtra != "" {
prev := strField(obj, "styles_css")
if prev != "" {
obj["styles_css"] = prev + cssExtra
} else {
obj["styles_css"] = cssExtra
}
}
entry := map[string]any{"main": binds}
if query != nil {
entry["query"] = query
}
if strings.TrimSpace(order) != "" {
entry["order"] = strings.TrimSpace(order)
}
if t := strings.TrimSpace(target); t != "" {
entry["target"] = t
}
lists := []any{}
if existing, ok := obj["lists"].([]any); ok {
lists = append(lists, existing...)
}
lists = append(lists, entry)
obj["lists"] = lists
return obj, nil
}
// ComposeForm embeds a form into the page main slot.
func ComposeForm(page any, form any, formID string, formTarget *string) (any, error) {
id := strings.TrimSpace(formID)
@@ -0,0 +1,30 @@
package compose
import "testing"
func TestComposeListAppends(t *testing.T) {
page := map[string]any{"title": "p"}
main := []any{
map[string]any{"front": "title", "back": "comments.author", "css": ""},
map[string]any{"front": "body", "back": "comments.body", "css": ""},
}
q := []any{map[string]any{"field": "post_slug", "op": "=", "value": "{slug}"}}
out, err := ComposeList(page, main, q, "-created_at", "#comment-list", func(string) (any, error) {
return nil, nil
})
if err != nil {
t.Fatal(err)
}
m := out.(map[string]any)
lists, ok := m["lists"].([]any)
if !ok || len(lists) != 1 {
t.Fatalf("lists=%v", m["lists"])
}
entry := lists[0].(map[string]any)
if entry["order"] != "-created_at" || entry["target"] != "#comment-list" {
t.Fatalf("entry=%v", entry)
}
if entry["query"] == nil {
t.Fatal("missing query")
}
}
+6
View File
@@ -78,6 +78,12 @@ func open(url string) (*sql.DB, error) {
return db, nil
}
// OpenSQL returns a pooled *sql.DB for sqlite: (and existing) URLs.
// Used by packages that need raw SQL beyond CRUD helpers (e.g. rbac).
func OpenSQL(url string) (*sql.DB, error) {
return open(url)
}
// ResetPool closes pooled connections and open transactions (tests).
func ResetPool() {
resetTxns()
+44
View File
@@ -2,6 +2,7 @@
package form
import (
"encoding/json"
"fmt"
"strconv"
"strings"
@@ -17,6 +18,7 @@ var (
typeKeys = []string{"类型", "type"}
reqKeys = []string{"必填", "required"}
defKeys = []string{"默认", "default"}
sourceKeys = []string{"来源", "source"}
ruleFieldKeys = []string{"字段", "field", "name"}
ruleKeys = []string{"规则", "rule"}
msgKeys = []string{"消息", "message", "msg"}
@@ -177,12 +179,19 @@ func asFormFields(fields any) []any {
if v, ok := pick(m, defKeys); ok {
def = cellStr(v)
}
source := "client"
if v, ok := pick(m, sourceKeys); ok {
if s := strings.TrimSpace(cellStr(v)); s != "" {
source = s
}
}
item := map[string]any{
"name": name,
"label": label,
"type": ty,
"required": required,
"default": def,
"source": normalizeSource(source),
}
if v, ok := m["pk"]; ok {
item["pk"] = boolish(v)
@@ -211,6 +220,10 @@ func asFormFields(fields any) []any {
if v, ok := pick(t, defKeys); ok {
defs = asStrList(v)
}
sources := []string{}
if v, ok := pick(t, sourceKeys); ok {
sources = asStrList(v)
}
var out []any
for i, nameRaw := range names {
name := table.NormalizeRef(nameRaw)
@@ -233,12 +246,17 @@ func asFormFields(fields any) []any {
if i < len(defs) {
def = defs[i]
}
source := "client"
if i < len(sources) && strings.TrimSpace(sources[i]) != "" {
source = sources[i]
}
out = append(out, map[string]any{
"name": name,
"label": label,
"type": ty,
"required": required,
"default": def,
"source": normalizeSource(source),
})
}
return out
@@ -614,6 +632,11 @@ func strOf(m map[string]any, key, def string) string {
// RenderBody emits form markup only (no document shell).
func RenderBody(formBag map[string]any, formID string, data, errors any, csrf string) string {
return RenderBodyCtx(formBag, formID, data, errors, csrf, nil)
}
// RenderBodyCtx is RenderBody plus request-context hidden fields for POST.
func RenderBodyCtx(formBag map[string]any, formID string, data, errors any, csrf string, ctx *RequestContext) string {
fields := fieldSlice(formBag)
dataM := map[string]any{}
if data != nil {
@@ -680,6 +703,20 @@ func RenderBody(formBag map[string]any, formID string, data, errors any, csrf st
if action == "update" && rowID != "" {
fmt.Fprintf(&body, `<input type="hidden" name="id" value="%s"/>`, esc(rowID))
}
if ctx != nil {
if len(ctx.Params) > 0 {
if b, err := json.Marshal(ctx.Params); err == nil {
fmt.Fprintf(&body, `<input type="hidden" name="_mq_params" value="%s"/>`, esc(string(b)))
}
}
ret := strings.TrimSpace(ctx.ReturnPath)
if ret == "" {
ret = strings.TrimSpace(ctx.Path)
}
if ret != "" && strings.HasPrefix(ret, "/") && !strings.HasPrefix(ret, "//") {
fmt.Fprintf(&body, `<input type="hidden" name="_mq_return" value="%s"/>`, esc(ret))
}
}
for _, f := range fields {
fm, ok := f.(map[string]any)
if !ok {
@@ -689,6 +726,9 @@ func RenderBody(formBag map[string]any, formID string, data, errors any, csrf st
if name == "" {
continue
}
if !IsClientSource(strOf(fm, "source", "client")) {
continue
}
label := strOf(fm, "label", name)
ty := strOf(fm, "type", "text")
required, _ := fm["required"].(bool)
@@ -712,6 +752,10 @@ func RenderBody(formBag map[string]any, formID string, data, errors any, csrf st
if required {
reqAttr = " required"
}
if ty == "hidden" {
fmt.Fprintf(&body, `<input type="hidden" name="%s" value="%s"/>`, esc(name), esc(value))
continue
}
body.WriteString("<label>")
body.WriteString(esc(label))
if ty == "textarea" {
+115
View File
@@ -0,0 +1,115 @@
package form
import (
"encoding/json"
"strings"
"time"
)
func normalizeSource(raw string) string {
s := strings.TrimSpace(raw)
if s == "" {
return "client"
}
switch strings.ToLower(s) {
case "client", "用户", "input", "form":
return "client"
case "user", "username", "session.user", "session.username", "用户名":
return "session.username"
case "now", "utc.now", "server.now", "时间", "utc":
return "now"
default:
return s
}
}
// IsClientSource reports whether the field is filled by the browser.
func IsClientSource(source string) bool {
return normalizeSource(source) == "client"
}
// RequestContext carries session user and route params for form source stamping
// (design: ext-web-request-context.md). Domain-agnostic — no table-name branches.
type RequestContext struct {
Username string
Params map[string]any
ReturnPath string
Path string
Method string
}
// ApplySources strips client-supplied values for non-client fields, then stamps
// from ctx. Always overwrites server-owned keys.
func ApplySources(formBag map[string]any, data map[string]any, ctx *RequestContext) {
if data == nil {
return
}
if ctx == nil {
ctx = &RequestContext{}
}
for _, f := range fieldSlice(formBag) {
fm, ok := f.(map[string]any)
if !ok {
continue
}
name, _ := fm["name"].(string)
if name == "" {
continue
}
src := normalizeSource(strOf(fm, "source", "client"))
if src == "client" {
continue
}
delete(data, name)
if v, ok := resolveSource(src, ctx); ok {
data[name] = v
}
}
}
func resolveSource(src string, ctx *RequestContext) (any, bool) {
src = normalizeSource(src)
switch src {
case "client":
return nil, false
case "session.username":
if ctx.Username == "" {
return nil, false
}
return ctx.Username, true
case "now":
return time.Now().UTC().Format("2006-01-02 15:04:05"), true
}
lower := strings.ToLower(src)
for _, prefix := range []string{"route.", "param.", "params."} {
if strings.HasPrefix(lower, prefix) {
key := src[len(prefix):]
if key == "" || ctx.Params == nil {
return nil, false
}
if v, ok := ctx.Params[key]; ok {
return v, true
}
for k, v := range ctx.Params {
if strings.EqualFold(k, key) {
return v, true
}
}
return nil, false
}
}
return nil, false
}
// ParseMQParams decodes the hidden `_mq_params` JSON posted with forms.
func ParseMQParams(raw string) map[string]any {
raw = strings.TrimSpace(raw)
if raw == "" {
return nil
}
var out map[string]any
if err := json.Unmarshal([]byte(raw), &out); err != nil {
return nil
}
return out
}
+66
View File
@@ -0,0 +1,66 @@
package form
import "testing"
func TestApplySourcesOverwritesClient(t *testing.T) {
frm := SetFields(New("comments", "insert", "c"), []any{
map[string]any{"字段": "body", "标签": "body", "类型": "textarea", "必填": true, "来源": "client"},
map[string]any{"字段": "author", "标签": "a", "类型": "text", "必填": true, "来源": "session.username"},
map[string]any{"字段": "post_slug", "标签": "s", "类型": "text", "必填": true, "来源": "route.slug"},
map[string]any{"字段": "created_at", "标签": "t", "类型": "text", "来源": "now"},
})
data := map[string]any{
"body": "hi",
"author": "forged",
"post_slug": "evil",
}
ApplySources(frm, data, &RequestContext{
Username: "alice",
Params: map[string]any{"slug": "hello"},
})
if data["author"] != "alice" {
t.Fatalf("author=%v", data["author"])
}
if data["post_slug"] != "hello" {
t.Fatalf("slug=%v", data["post_slug"])
}
if data["body"] != "hi" {
t.Fatalf("body=%v", data["body"])
}
if data["created_at"] == nil || data["created_at"] == "" {
t.Fatalf("created_at missing")
}
}
func TestRenderSkipsServerSources(t *testing.T) {
frm := SetFields(New("comments", "insert", "c"), []any{
map[string]any{"字段": "body", "标签": "Body", "类型": "textarea", "必填": true},
map[string]any{"字段": "author", "标签": "Author", "类型": "text", "来源": "session.username"},
})
html := RenderBodyCtx(frm, "c", nil, nil, "", &RequestContext{
Username: "alice",
Params: map[string]any{"slug": "x"},
ReturnPath: "/post/x",
})
if stringsContains(html, `name="author"`) {
t.Fatalf("author field should not render: %s", html)
}
if !stringsContains(html, `name="body"`) {
t.Fatalf("body missing")
}
if !stringsContains(html, `_mq_params`) || !stringsContains(html, `_mq_return`) {
t.Fatalf("missing mq context fields: %s", html)
}
}
func stringsContains(s, sub string) bool {
return len(s) >= len(sub) && (s == sub || len(sub) == 0 ||
(func() bool {
for i := 0; i+len(sub) <= len(s); i++ {
if s[i:i+len(sub)] == sub {
return true
}
}
return false
})())
}
+465 -35
View File
@@ -1,15 +1,19 @@
package httpx
import (
"encoding/json"
"fmt"
"io"
"net"
"net/http"
"strconv"
"strings"
"github.com/marqdo/marqdo/plugins/web/internal/app"
"github.com/marqdo/marqdo/plugins/web/internal/auth"
"github.com/marqdo/marqdo/plugins/web/internal/password"
"github.com/marqdo/marqdo/plugins/web/internal/ratelimit"
"github.com/marqdo/marqdo/plugins/web/internal/rbac"
"github.com/marqdo/marqdo/plugins/web/internal/session"
)
@@ -28,23 +32,28 @@ const (
)
type gate struct {
path string
roles []string
matchMode gateMatch
onDeny onDeny
exclude []string
path string
roles []string
permissions []string
matchMode gateMatch
onDeny onDeny
exclude []string
}
type authConfig struct {
users any
sessionTTL uint64
cookieSecure bool
admin bool
adminPrefix string
loginPath string
loginRedirect string
logoutRedirect string
gates []gate
users any
sessionTTL uint64
cookieSecure bool
admin bool
adminPrefix string
loginPath string
loginRedirect string
logoutRedirect string
gates []gate
rbac bool
register bool
registerPath string
defaultRole string
}
func authConfigOf(appBag map[string]any) authConfig {
@@ -68,6 +77,7 @@ func authConfigOf(appBag map[string]any) authConfig {
if v, ok := appBag["cookie_secure"].(bool); ok {
cfg.cookieSecure = v
}
cfg.registerPath = strOpt(appBag, "register_path", "")
if authBag, ok := appBag["auth"].(map[string]any); ok {
cfg.users = authBag["users"]
if n, ok := asUint64(authBag["session_ttl"]); ok && n > 0 {
@@ -75,6 +85,18 @@ func authConfigOf(appBag map[string]any) authConfig {
} else if n, ok := asUint64(authBag["ttl"]); ok && n > 0 {
cfg.sessionTTL = n
}
cfg.rbac = boolish(authBag["rbac"])
cfg.register = boolish(authBag["register"])
if p := strOpt(authBag, "register_path", ""); p != "" {
cfg.registerPath = p
}
cfg.defaultRole = strOpt(authBag, "default_role", "")
if cfg.defaultRole == "" {
cfg.defaultRole = "member"
}
}
if cfg.registerPath == "" {
cfg.registerPath = "/register"
}
cfg.gates = parseGates(appBag["gates"])
return cfg
@@ -106,7 +128,11 @@ func parseGates(v any) []gate {
if roles == nil {
roles = parseGateRoles(m["角色"])
}
if len(roles) == 0 {
perms := parseGateRoles(m["permissions"])
if perms == nil {
perms = parseGateRoles(m["权限"])
}
if len(roles) == 0 && len(perms) == 0 {
roles = []string{"admin"}
}
matchS := strings.ToLower(strings.TrimSpace(strOpt(m, "match", "")))
@@ -136,11 +162,12 @@ func parseGates(v any) []gate {
on = onDenyForbid
}
out = append(out, gate{
path: path,
roles: roles,
matchMode: matchMode,
onDeny: on,
exclude: parseExclude(m["exclude"], m["排除"]),
path: path,
roles: roles,
permissions: perms,
matchMode: matchMode,
onDeny: on,
exclude: parseExclude(m["exclude"], m["排除"]),
})
}
return out
@@ -245,7 +272,17 @@ func withRBAC(next http.Handler, gates []gate, loginPath string) http.Handler {
break
}
role := session.RoleFromCookie(cookie)
if !session.RoleAllowed(role, g.roles) {
allowed := false
if len(g.permissions) > 0 {
held := session.PermissionsFromCookie(cookie)
if len(held) == 0 && role != "visitor" {
held = expandLegacyRole(role)
}
allowed = session.PermissionAllowed(held, g.permissions)
} else {
allowed = session.RoleAllowed(role, g.roles)
}
if !allowed {
if role == "visitor" && g.onDeny == onDenyRedirect {
nextQ := urlEncodePath(path)
dest := loginPath
@@ -268,6 +305,22 @@ func withRBAC(next http.Handler, gates []gate, loginPath string) http.Handler {
})
}
func expandLegacyRole(role string) []string {
switch strings.ToLower(strings.TrimSpace(role)) {
case "superadmin", "admin":
return []string{
"comments:create", "comments:delete", "comments:delete_own",
"desk:access", "roles:manage", "posts:edit", "users:manage",
}
case "member", "user":
return []string{"comments:create", "comments:delete_own"}
case "editor", "author":
return []string{"comments:create", "comments:delete_own", "posts:edit", "desk:access"}
default:
return nil
}
}
func urlEncodePath(path string) string {
var out strings.Builder
for _, b := range []byte(path) {
@@ -302,21 +355,50 @@ func withNavAuth(page map[string]any, cookieHeader string) {
}
}
func (st *state) hasPageRoute(path string) bool {
if path == "" || st.routes == nil {
return false
}
_, ok := st.routes[path]
return ok
}
func (st *state) mountAuthRoutes(mux *http.ServeMux) {
if st.auth.users == nil {
if st.auth.users == nil && !(st.auth.rbac && st.auth.register) {
return
}
lp := st.auth.loginPath
mux.HandleFunc("GET "+lp, st.handleLoginGet)
mux.HandleFunc("POST "+lp, st.handleLoginPost)
altLogin := strings.TrimRight(st.auth.adminPrefix, "/") + "/login"
if altLogin != lp {
mux.HandleFunc("GET "+altLogin, st.handleLoginGet)
mux.HandleFunc("POST "+altLogin, st.handleLoginPost)
if st.auth.users != nil || st.auth.rbac {
lp := st.auth.loginPath
// Site pages may own GET /login (or /desk/login); always keep POST for auth.
if !st.hasPageRoute(lp) {
mux.HandleFunc("GET "+lp, st.handleLoginGet)
}
mux.HandleFunc("POST "+lp, st.handleLoginPost)
altLogin := strings.TrimRight(st.auth.adminPrefix, "/") + "/login"
if altLogin != lp {
if !st.hasPageRoute(altLogin) {
mux.HandleFunc("GET "+altLogin, st.handleLoginGet)
}
mux.HandleFunc("POST "+altLogin, st.handleLoginPost)
}
logoutPath := strings.TrimRight(st.auth.adminPrefix, "/") + "/logout"
mux.HandleFunc("GET "+logoutPath, st.handleLogout)
}
if st.auth.register && st.auth.rbac {
rp := st.auth.registerPath
if !st.hasPageRoute(rp) {
mux.HandleFunc("GET "+rp, st.handleRegisterGet)
}
mux.HandleFunc("POST "+rp, st.handleRegisterPost)
}
if st.auth.rbac && st.dbURL != "" {
mux.HandleFunc("GET /_rbac/roles", st.handleRbacListRoles)
mux.HandleFunc("GET /_rbac/permissions", st.handleRbacListPermissions)
mux.HandleFunc("POST /_rbac/roles", st.handleRbacCreateRole)
mux.HandleFunc("POST /_rbac/roles/{id}/permissions", st.handleRbacSetRolePerms)
mux.HandleFunc("POST /_rbac/assign", st.handleRbacAssign)
mux.HandleFunc("GET /_rbac/desk", st.handleRbacDesk)
}
// Logout is part of session auth, not only built-in admin=True chrome.
logoutPath := strings.TrimRight(st.auth.adminPrefix, "/") + "/logout"
mux.HandleFunc("GET "+logoutPath, st.handleLogout)
if st.auth.admin {
adminHome := strings.TrimRight(st.auth.adminPrefix, "/")
if adminHome == "" {
@@ -327,7 +409,7 @@ func (st *state) mountAuthRoutes(mux *http.ServeMux) {
}
func (st *state) handleLoginGet(w http.ResponseWriter, r *http.Request) {
if st.auth.users == nil {
if st.auth.users == nil && !st.auth.rbac {
http.Redirect(w, r, st.auth.loginRedirect, http.StatusSeeOther)
return
}
@@ -344,7 +426,7 @@ func (st *state) handleLoginGet(w http.ResponseWriter, r *http.Request) {
}
func (st *state) handleLoginPost(w http.ResponseWriter, r *http.Request) {
if st.auth.users == nil {
if st.auth.users == nil && !st.auth.rbac {
http.Redirect(w, r, st.auth.loginRedirect, http.StatusSeeOther)
return
}
@@ -374,7 +456,7 @@ func (st *state) handleLoginPost(w http.ResponseWriter, r *http.Request) {
_, _ = io.WriteString(w, loginPageHTML(st.auth.loginPath, &msg, csrf, r.FormValue("next")))
return
}
res := auth.Login(username, password, st.auth.users, st.auth.sessionTTL)
res := st.tryLogin(username, password)
if ok, _ := res["ok"].(bool); !ok {
ratelimit.RecordFailure(ip, username)
errMsg := "Invalid username or password."
@@ -385,11 +467,58 @@ func (st *state) handleLoginPost(w http.ResponseWriter, r *http.Request) {
}
ratelimit.ClearSuccess(ip, username)
sessID, _ := res["session_id"].(string)
role, _ := res["role"].(string)
st.attachLoginPermissions(sessID, username, role)
dest := loginDest(r, st.auth.loginRedirect)
held := session.PermissionsFromSession(sessID)
if strings.HasPrefix(dest, "/desk") && !session.PermissionAllowed(held, []string{"desk:access"}) {
dest = "/"
}
w.Header().Add("Set-Cookie", session.IssueCookie(sessID))
http.Redirect(w, r, dest, http.StatusSeeOther)
}
// tryLogin: GFM users first, then web_users when RBAC is on.
func (st *state) tryLogin(username, password string) map[string]any {
if st.auth.users != nil {
res := auth.Login(username, password, st.auth.users, st.auth.sessionTTL)
if ok, _ := res["ok"].(bool); ok {
u, _ := res["username"].(string)
role, _ := res["role"].(string)
st.seedGFMUserIntoRBAC(u, password, role)
return res
}
}
if st.auth.rbac && st.dbURL != "" {
role, ok, err := rbac.Authenticate(st.dbURL, username, password, passwordVerify)
if err == nil && ok {
id := session.NewID(st.auth.sessionTTL)
session.SetValue(id, "username", username)
session.SetValue(id, "role", role)
return map[string]any{
"ok": true, "session_id": id, "username": username, "role": role,
}
}
}
return map[string]any{"ok": false}
}
func (st *state) attachLoginPermissions(sessID, username, role string) {
var perms []string
if st.dbURL != "" && st.auth.rbac {
if dbPerms, err := rbac.PermissionsForUser(st.dbURL, username); err == nil && len(dbPerms) > 0 {
perms = dbPerms
}
}
if len(perms) == 0 {
perms = rbac.ExpandRole(role)
}
if len(perms) == 0 {
perms = expandLegacyRole(role)
}
auth.AttachPermissions(sessID, perms)
}
func (st *state) handleLogout(w http.ResponseWriter, r *http.Request) {
if sid, ok := session.IDFromCookie(r.Header.Get("Cookie")); ok {
auth.Logout(sid)
@@ -469,6 +598,307 @@ a.back:hover { color:#f5e6c8; }
</body></html>`, errHTML, esc(loginAction), csrfField, nextField)
}
func passwordVerify(pass, encoded string) bool {
return password.Verify(pass, encoded)
}
func (st *state) seedGFMUserIntoRBAC(username, plaintext, role string) {
if !st.auth.rbac || st.dbURL == "" || username == "" {
return
}
exists, err := rbac.UserExists(st.dbURL, username)
if err != nil || exists {
return
}
hash, err := password.Hash(plaintext)
if err != nil {
return
}
target := "member"
switch strings.ToLower(role) {
case "admin", "superadmin":
target = "superadmin"
case "editor", "author":
// custom roles may not exist yet; fall back to member + ExpandRole at session
target = "member"
}
_ = rbac.EnsureUserWithRole(st.dbURL, username, hash, target)
}
func (st *state) handleRegisterGet(w http.ResponseWriter, r *http.Request) {
_, csrf, setCookie := resolveSession(r)
html := registerPageHTML(st.auth.registerPath, nil, csrf)
w.Header().Set("Content-Type", "text/html; charset=utf-8")
appendSetCookie(w, setCookie)
_, _ = io.WriteString(w, html)
}
func (st *state) handleRegisterPost(w http.ResponseWriter, r *http.Request) {
if err := r.ParseForm(); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
sid, csrf, setCookie := resolveSession(r)
csrfToken := r.FormValue("_csrf")
if csrfToken != "" {
if !session.ValidateCSRF(sid, csrfToken) {
msg := "Invalid CSRF token."
w.Header().Set("Content-Type", "text/html; charset=utf-8")
appendSetCookie(w, setCookie)
_, _ = io.WriteString(w, registerPageHTML(st.auth.registerPath, &msg, csrf))
return
}
}
username := strings.TrimSpace(r.FormValue("username"))
pass := r.FormValue("password")
if len(username) < 2 || len(pass) < 4 {
msg := "Username (≥2) and password (≥4) required."
w.Header().Set("Content-Type", "text/html; charset=utf-8")
appendSetCookie(w, setCookie)
_, _ = io.WriteString(w, registerPageHTML(st.auth.registerPath, &msg, csrf))
return
}
hash, err := password.Hash(pass)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
if err := rbac.RegisterUser(st.dbURL, username, hash, st.auth.defaultRole); err != nil {
msg := err.Error()
w.Header().Set("Content-Type", "text/html; charset=utf-8")
appendSetCookie(w, setCookie)
_, _ = io.WriteString(w, registerPageHTML(st.auth.registerPath, &msg, csrf))
return
}
res := st.tryLogin(username, pass)
if ok, _ := res["ok"].(bool); ok {
sessID, _ := res["session_id"].(string)
role, _ := res["role"].(string)
st.attachLoginPermissions(sessID, username, role)
w.Header().Add("Set-Cookie", session.IssueCookie(sessID))
dest := st.auth.loginRedirect
held := session.PermissionsFromSession(sessID)
if !session.PermissionAllowed(held, []string{"desk:access"}) {
dest = "/"
}
http.Redirect(w, r, dest, http.StatusSeeOther)
return
}
http.Redirect(w, r, st.auth.loginPath, http.StatusSeeOther)
}
func registerPageHTML(action string, errMsg *string, csrf string) string {
errHTML := ""
if errMsg != nil && *errMsg != "" {
errHTML = fmt.Sprintf("<p class=\"flash err\">%s</p>", esc(*errMsg))
}
csrfField := ""
if csrf != "" {
csrfField = fmt.Sprintf("<input type=\"hidden\" name=\"_csrf\" value=\"%s\"/>", esc(csrf))
}
return fmt.Sprintf(`<!DOCTYPE html>
<html lang="en"><head>
<meta charset="utf-8"/>
<meta name="viewport" content="width=device-width, initial-scale=1"/>
<title>Register</title>
<style>
:root { --ink:#0a0809; --paper:#f5e6c8; --gold:#d4af37; --err:#b91c1c; }
* { box-sizing:border-box; }
body { margin:0; min-height:100vh; display:grid; place-items:center; color:var(--paper); font-family:"Noto Sans SC","IBM Plex Sans",system-ui,sans-serif;
background: radial-gradient(ellipse 90%% 55%% at 50%% -15%%, rgba(107,30,58,.5), transparent 58%%), linear-gradient(180deg,#0a0809,#120c10 45%%,#0a0809); }
.login { background:rgba(0,0,0,.45); border:1px solid rgba(212,175,55,.28); border-radius:12px; padding:2rem 2.25rem; width:min(92vw,22rem); }
.login h1 { margin:0 0 .25rem; font-size:1.55rem; color:var(--gold); }
.login .sub { color:rgba(245,230,200,.72); margin:0 0 1.25rem; font-size:.9rem; }
.login form { display:grid; gap:.9rem; }
.login label { display:grid; gap:.25rem; font-size:.85rem; }
.login input { padding:.6rem .75rem; border:1px solid rgba(212,175,55,.35); border-radius:8px; font:inherit; color:var(--paper); background:rgba(10,8,9,.7); }
.login button { background:linear-gradient(135deg,#f5e6c8,var(--gold)); color:var(--ink); border:0; padding:.65rem 1rem; border-radius:999px; cursor:pointer; font:inherit; font-weight:600; }
.flash.err { background:rgba(185,28,28,.15); color:#fecaca; border:1px solid rgba(185,28,28,.45); padding:.6rem .8rem; border-radius:8px; margin:0 0 .9rem; font-size:.9rem; }
a.back { color:var(--gold); text-decoration:none; font-size:.85rem; }
</style>
</head>
<body>
<div class="login">
<h1>Create account</h1>
<p class="sub">New members get the default role (comments).</p>
%s
<form method="post" action="%s">
%s
<label>Username<input name="username" autocomplete="username" required autofocus/></label>
<label>Password<input name="password" type="password" autocomplete="new-password" required/></label>
<button type="submit">Register</button>
</form>
<p style="margin:1.1rem 0 0"><a class="back" href="/login">← Sign in</a></p>
</div>
</body></html>`, errHTML, esc(action), csrfField)
}
func (st *state) requireRolesManage(w http.ResponseWriter, r *http.Request) bool {
held := session.PermissionsFromCookie(r.Header.Get("Cookie"))
if !session.PermissionAllowed(held, []string{"roles:manage"}) {
http.Error(w, "forbidden", http.StatusForbidden)
return false
}
return true
}
func (st *state) writeJSON(w http.ResponseWriter, status int, v any) {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.WriteHeader(status)
_ = json.NewEncoder(w).Encode(v)
}
func (st *state) handleRbacListRoles(w http.ResponseWriter, r *http.Request) {
if !st.requireRolesManage(w, r) {
return
}
roles, err := rbac.ListRoles(st.dbURL)
if err != nil {
st.writeJSON(w, http.StatusInternalServerError, map[string]any{"ok": false, "error": err.Error()})
return
}
st.writeJSON(w, http.StatusOK, map[string]any{"ok": true, "roles": roles})
}
func (st *state) handleRbacListPermissions(w http.ResponseWriter, r *http.Request) {
if !st.requireRolesManage(w, r) {
return
}
perms, err := rbac.ListPermissions(st.dbURL)
if err != nil {
st.writeJSON(w, http.StatusInternalServerError, map[string]any{"ok": false, "error": err.Error()})
return
}
st.writeJSON(w, http.StatusOK, map[string]any{"ok": true, "permissions": perms})
}
func (st *state) handleRbacCreateRole(w http.ResponseWriter, r *http.Request) {
if !st.requireRolesManage(w, r) {
return
}
var body struct {
Name string `json:"name"`
}
if err := json.NewDecoder(r.Body).Decode(&body); err != nil || strings.TrimSpace(body.Name) == "" {
st.writeJSON(w, http.StatusBadRequest, map[string]any{"ok": false, "error": "name required"})
return
}
id, err := rbac.CreateRole(st.dbURL, strings.TrimSpace(body.Name))
if err != nil {
st.writeJSON(w, http.StatusBadRequest, map[string]any{"ok": false, "error": err.Error()})
return
}
st.writeJSON(w, http.StatusOK, map[string]any{"ok": true, "id": id, "name": body.Name})
}
func (st *state) handleRbacSetRolePerms(w http.ResponseWriter, r *http.Request) {
if !st.requireRolesManage(w, r) {
return
}
idStr := r.PathValue("id")
roleID, err := strconv.ParseInt(idStr, 10, 64)
if err != nil {
st.writeJSON(w, http.StatusBadRequest, map[string]any{"ok": false, "error": "bad id"})
return
}
var body struct {
Permissions []string `json:"permissions"`
}
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
st.writeJSON(w, http.StatusBadRequest, map[string]any{"ok": false, "error": "bad json"})
return
}
grantable := session.PermissionsFromCookie(r.Header.Get("Cookie"))
if err := rbac.SetRolePermissions(st.dbURL, roleID, body.Permissions, grantable); err != nil {
st.writeJSON(w, http.StatusBadRequest, map[string]any{"ok": false, "error": err.Error()})
return
}
st.writeJSON(w, http.StatusOK, map[string]any{"ok": true})
}
func (st *state) handleRbacAssign(w http.ResponseWriter, r *http.Request) {
if !st.requireRolesManage(w, r) {
return
}
var body struct {
Username string `json:"username"`
Role string `json:"role"`
}
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
st.writeJSON(w, http.StatusBadRequest, map[string]any{"ok": false, "error": "bad json"})
return
}
if err := rbac.AssignRole(st.dbURL, body.Username, body.Role); err != nil {
st.writeJSON(w, http.StatusBadRequest, map[string]any{"ok": false, "error": err.Error()})
return
}
st.writeJSON(w, http.StatusOK, map[string]any{"ok": true})
}
func (st *state) handleRbacDesk(w http.ResponseWriter, r *http.Request) {
if !st.requireRolesManage(w, r) {
return
}
roles, _ := rbac.ListRoles(st.dbURL)
perms, _ := rbac.ListPermissions(st.dbURL)
var roleOpts, permChecks strings.Builder
for _, role := range roles {
name, _ := role["name"].(string)
id := role["id"]
sys, _ := role["is_system"].(bool)
tag := ""
if sys {
tag = " (system)"
}
fmt.Fprintf(&roleOpts, `<option value="%v">%s%s</option>`, id, esc(name), tag)
}
for _, p := range perms {
code, _ := p["code"].(string)
desc, _ := p["description"].(string)
fmt.Fprintf(&permChecks, `<label style="display:block;margin:.25rem 0"><input type="checkbox" name="perm" value="%s"/> %s — %s</label>`,
esc(code), esc(code), esc(desc))
}
html := fmt.Sprintf(`<!DOCTYPE html>
<html lang="zh"><head><meta charset="utf-8"/><meta name="viewport" content="width=device-width, initial-scale=1"/>
<title>Roles · RBAC</title>
<style>
body{font-family:"Noto Sans SC",system-ui,sans-serif;max-width:42rem;margin:2rem auto;padding:0 1rem;line-height:1.5}
h1{font-size:1.4rem} section{margin:1.5rem 0;padding:1rem;border:1px solid #ddd;border-radius:8px}
button{padding:.5rem 1rem;cursor:pointer} input,select{padding:.4rem;margin:.25rem 0;width:100%%;max-width:20rem}
#msg{min-height:1.2rem;color:#b91c1c}
</style></head><body>
<h1>角色与权限</h1>
<p>需 <code>roles:manage</code>。系统角色权限不可在此改写;可新建角色并勾选权限,或给用户赋角色。</p>
<p id="msg"></p>
<section>
<h2>新建角色</h2>
<input id="new-role" placeholder="角色名"/><button type="button" id="btn-create">创建</button>
</section>
<section>
<h2>设置角色权限</h2>
<select id="role-sel">%s</select>
<div>%s</div>
<button type="button" id="btn-set">保存权限</button>
</section>
<section>
<h2>赋角色给用户</h2>
<input id="assign-user" placeholder="用户名"/>
<input id="assign-role" placeholder="角色名(如 member)"/>
<button type="button" id="btn-assign">赋权</button>
</section>
<p><a href="/desk">← 后台</a></p>
<script>
const msg=document.getElementById('msg');
async function j(url,opt){const r=await fetch(url,Object.assign({credentials:'same-origin',headers:{'Content-Type':'application/json'}},opt||{}));const d=await r.json();if(!d.ok)throw new Error(d.error||r.status);return d;}
document.getElementById('btn-create').onclick=async()=>{try{const name=document.getElementById('new-role').value.trim();await j('/_rbac/roles',{method:'POST',body:JSON.stringify({name})});msg.textContent='已创建 '+name;location.reload();}catch(e){msg.textContent=e.message;}};
document.getElementById('btn-set').onclick=async()=>{try{const id=document.getElementById('role-sel').value;const permissions=[...document.querySelectorAll('input[name=perm]:checked')].map(x=>x.value);await j('/_rbac/roles/'+id+'/permissions',{method:'POST',body:JSON.stringify({permissions})});msg.textContent='权限已保存';}catch(e){msg.textContent=e.message;}};
document.getElementById('btn-assign').onclick=async()=>{try{const username=document.getElementById('assign-user').value.trim();const role=document.getElementById('assign-role').value.trim();await j('/_rbac/assign',{method:'POST',body:JSON.stringify({username,role})});msg.textContent='已赋 '+role+' → '+username;}catch(e){msg.textContent=e.message;}};
</script>
</body></html>`, roleOpts.String(), permChecks.String())
w.Header().Set("Content-Type", "text/html; charset=utf-8")
_, _ = io.WriteString(w, html)
}
func clientIP(r *http.Request) string {
if xff := r.Header.Get("X-Forwarded-For"); xff != "" {
if i := strings.Index(xff, ","); i >= 0 {
+99 -4
View File
@@ -9,6 +9,7 @@ import (
"io"
"net"
"net/http"
"net/url"
"os"
"os/signal"
"path/filepath"
@@ -22,9 +23,11 @@ import (
"github.com/marqdo/marqdo/plugins/web/internal/form"
"github.com/marqdo/marqdo/plugins/web/internal/middleware"
"github.com/marqdo/marqdo/plugins/web/internal/ratelimit"
"github.com/marqdo/marqdo/plugins/web/internal/rbac"
"github.com/marqdo/marqdo/plugins/web/internal/render"
"github.com/marqdo/marqdo/plugins/web/internal/session"
"github.com/marqdo/marqdo/plugins/web/internal/sitemap"
"github.com/marqdo/marqdo/plugins/web/internal/tenant"
)
// NewHandler builds the HTTP handler for an app bag (no listen).
@@ -35,6 +38,11 @@ func NewHandler(appBag map[string]any, entryDir string) (http.Handler, error) {
}
authCfg := authConfigOf(appBag)
dbURL := dbURLOf(appBag)
if authCfg.rbac && dbURL != "" {
if err := rbac.EnsureSchema(dbURL); err != nil {
return nil, fmt.Errorf("rbac ensure: %w", err)
}
}
session.Configure(session.Config{
DBURL: dbURL,
TTLSec: authCfg.sessionTTL,
@@ -99,6 +107,7 @@ func NewHandler(appBag map[string]any, entryDir string) (http.Handler, error) {
proxyRoutes: routeMapOf(appBag, "proxy_routes"),
invokeRoutes: routeMapOf(appBag, "invoke_routes"),
auth: authCfg,
tenant: tenant.FromBag(appBag),
}
mux := http.NewServeMux()
@@ -132,7 +141,7 @@ func NewHandler(appBag map[string]any, entryDir string) (http.Handler, error) {
route := jr
pattern := route.Method + " " + route.Path
mux.HandleFunc(pattern, func(w http.ResponseWriter, r *http.Request) {
st.handleJSON(w, route)
st.handleJSON(w, r, route)
})
}
@@ -217,6 +226,7 @@ func NewHandler(appBag map[string]any, entryDir string) (http.Handler, error) {
handler := withMiddleware(mux, mw)
handler = withRBAC(handler, authCfg.gates, authCfg.loginPath)
handler = withTenant(handler, st.tenant)
return handler, nil
}
@@ -280,6 +290,7 @@ type state struct {
proxyRoutes map[string]any
invokeRoutes map[string]any
auth authConfig
tenant tenant.Config
}
func (st *state) handleHome(w http.ResponseWriter, r *http.Request) {
@@ -432,6 +443,16 @@ func (st *state) handleFormPost(w http.ResponseWriter, r *http.Request) {
data[k] = vs[0]
}
}
if st.tenant.Enabled() && st.tenant.DefaultScope {
if tid := tenant.FromContext(r.Context()); tid != "" {
data = tenant.StampRow(data, st.tenant.Column, tid)
}
}
ctx := st.requestContext(r, data)
delete(data, "_mq_params")
delete(data, "_mq_return")
delete(data, "_csrf")
form.ApplySources(frm, data, ctx)
res, err := form.Submit(frm, data, st.dbURL)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
@@ -439,20 +460,83 @@ func (st *state) handleFormPost(w http.ResponseWriter, r *http.Request) {
}
if ok, _ := res["ok"].(bool); ok {
redir := strOpt(res, "redirect", "/")
if ctx.ReturnPath != "" {
redir = ctx.ReturnPath
}
http.Redirect(w, r, redir, http.StatusSeeOther)
return
}
html := form.Render(frm, id, data, res["errors"], "")
html := form.RenderBodyCtx(frm, id, data, res["errors"], "", ctx)
w.Header().Set("Content-Type", "text/html; charset=utf-8")
_, _ = io.WriteString(w, html)
}
func (st *state) handleJSON(w http.ResponseWriter, route middleware.JSONRouteMount) {
func (st *state) requestContext(r *http.Request, data map[string]any) *form.RequestContext {
ctx := &form.RequestContext{
Username: session.UsernameFromCookie(r.Header.Get("Cookie")),
Path: r.URL.Path,
Method: r.Method,
}
if data != nil {
if p := form.ParseMQParams(fmt.Sprint(data["_mq_params"])); len(p) > 0 {
ctx.Params = p
}
if ret, ok := data["_mq_return"].(string); ok {
if back := sameHostPath(ret, r.Host); back != "" {
ctx.ReturnPath = back
} else if strings.HasPrefix(ret, "/") && !strings.HasPrefix(ret, "//") {
ctx.ReturnPath = ret
}
}
}
if ctx.ReturnPath == "" {
if back := sameHostPath(r.Referer(), r.Host); back != "" {
ctx.ReturnPath = back
}
}
return ctx
}
func sameHostPath(raw, host string) string {
raw = strings.TrimSpace(raw)
if raw == "" {
return ""
}
u, err := url.Parse(raw)
if err != nil || u == nil {
return ""
}
if u.Host != "" && host != "" && !strings.EqualFold(u.Host, host) {
return ""
}
path := u.Path
if path == "" {
path = "/"
}
if u.RawQuery != "" {
path += "?" + u.RawQuery
}
if !strings.HasPrefix(path, "/") || strings.HasPrefix(path, "//") {
return ""
}
return path
}
func (st *state) handleJSON(w http.ResponseWriter, r *http.Request, route middleware.JSONRouteMount) {
if st.dbURL == "" {
writeJSON(w, http.StatusInternalServerError, map[string]any{"error": "no database"})
return
}
opts := db.SelectOpts{Where: route.Where, Order: route.Order}
where := route.Where
if (route.TenantScope || st.tenant.DefaultScope) && st.tenant.Enabled() {
tid := tenant.FromContext(r.Context())
if tid == "" {
writeJSON(w, http.StatusBadRequest, map[string]any{"error": "tenant required"})
return
}
where = tenant.MergeWhere(where, st.tenant.Column, tid)
}
opts := db.SelectOpts{Where: where, Order: route.Order}
out, err := db.Select(st.dbURL, route.Table, route.Limit, opts)
if err != nil {
writeJSON(w, http.StatusInternalServerError, map[string]any{"error": err.Error()})
@@ -461,6 +545,17 @@ func (st *state) handleJSON(w http.ResponseWriter, route middleware.JSONRouteMou
writeJSON(w, http.StatusOK, out)
}
func withTenant(next http.Handler, cfg tenant.Config) http.Handler {
if !cfg.Enabled() {
return next
}
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
id := tenant.Resolve(r, cfg)
ctx := tenant.WithContext(r.Context(), id)
next.ServeHTTP(w, r.WithContext(ctx))
})
}
func withMiddleware(next http.Handler, mw middleware.Config) http.Handler {
h := next
if mw.BodyLimit != nil && *mw.BodyLimit > 0 {
+130 -4
View File
@@ -1,9 +1,14 @@
package httpx
import (
"encoding/json"
"fmt"
"net/http"
"strings"
"github.com/gorilla/websocket"
"github.com/marqdo/marqdo/plugins/web/internal/plugin"
"github.com/marqdo/marqdo/plugins/web/internal/session"
"github.com/marqdo/marqdo/plugins/web/internal/ws"
)
@@ -13,14 +18,44 @@ var wsUpgrader = websocket.Upgrader{
func (st *state) mountWSRoutes(mux *http.ServeMux) {
for _, path := range sortedKeys(st.wsRoutes) {
spec := ws.ParseRouteSpec(st.wsRoutes[path]) // mode + optional room_key
spec := ws.ParseRouteSpec(st.wsRoutes[path]) // mode + optional room_key / on_message
routePath := path
mux.HandleFunc("GET "+routePath, func(w http.ResponseWriter, r *http.Request) {
pattern := routePath
if strings.Contains(routePath, "{") {
pattern = goMuxPattern(routePath)
}
mux.HandleFunc("GET "+pattern, func(w http.ResponseWriter, r *http.Request) {
st.handleWS(w, r, routePath, spec)
})
}
}
func pathValuesOf(r *http.Request, routePath string) map[string]string {
out := map[string]string{}
// Collect {name} tokens from the route template.
rest := routePath
for {
i := strings.Index(rest, "{")
if i < 0 {
break
}
rest = rest[i+1:]
j := strings.Index(rest, "}")
if j < 0 {
break
}
name := rest[:j]
name = strings.TrimPrefix(name, "*")
if name != "" {
if v := r.PathValue(name); v != "" {
out[name] = v
}
}
rest = rest[j+1:]
}
return out
}
func (st *state) handleWS(w http.ResponseWriter, r *http.Request, path string, spec ws.RouteSpec) {
conn, err := wsUpgrader.Upgrade(w, r, nil)
if err != nil {
@@ -28,6 +63,7 @@ func (st *state) handleWS(w http.ResponseWriter, r *http.Request, path string, s
}
defer conn.Close()
vals := pathValuesOf(r, path)
switch spec.Mode {
case ws.ModeEcho:
for {
@@ -53,11 +89,26 @@ func (st *state) handleWS(w http.ResponseWriter, r *http.Request, path string, s
case ws.ModeBroadcast, ws.ModeRoom:
room := path
if spec.RoomKey != "" {
room = spec.RoomKey
room = ws.ExpandTemplate(spec.RoomKey, vals)
} else if len(vals) > 0 {
room = ws.ExpandTemplate(path, vals)
}
user := session.UsernameFromCookie(r.Header.Get("Cookie"))
if user == "" {
user = "anon"
}
ch := ws.JoinRoom(room)
defer ws.LeaveRoom(room, ch)
presenceRoom := room + ".presence"
var presenceCh chan string
if spec.Presence {
presenceCh = ws.JoinRoom(presenceRoom)
defer ws.LeaveRoom(presenceRoom, presenceCh)
ws.PublishRoom(presenceRoom, presenceJSON("join", user, room))
defer ws.PublishRoom(presenceRoom, presenceJSON("leave", user, room))
}
done := make(chan struct{})
go func() {
defer close(done)
@@ -67,7 +118,25 @@ func (st *state) handleWS(w http.ResponseWriter, r *http.Request, path string, s
return
}
if mt == websocket.TextMessage {
ws.PublishRoom(room, string(data))
text := string(data)
if spec.OnMessage != "" {
out, err := plugin.CallLibPath(spec.OnMessage, map[string]any{
"message": text,
"room": room,
"path": path,
"user": user,
})
if err != nil {
_ = conn.WriteMessage(websocket.TextMessage, []byte(`{"error":`+jsonQuote(err.Error())+`}`))
continue
}
skip, rewritten := interpretOnMessage(out, text)
if skip {
continue
}
text = rewritten
}
ws.PublishRoom(room, text)
} else if mt == websocket.CloseMessage {
return
}
@@ -85,9 +154,66 @@ func (st *state) handleWS(w http.ResponseWriter, r *http.Request, path string, s
if err := conn.WriteMessage(websocket.TextMessage, []byte(text)); err != nil {
return
}
case text, ok := <-presenceOrNil(presenceCh):
if presenceCh == nil {
continue
}
if !ok {
return
}
if err := conn.WriteMessage(websocket.TextMessage, []byte(text)); err != nil {
return
}
}
}
default:
return
}
}
func presenceOrNil(ch chan string) <-chan string {
if ch == nil {
return nil
}
return ch
}
func presenceJSON(event, user, room string) string {
b, _ := json.Marshal(map[string]any{
"type": "presence",
"event": event,
"user": user,
"room": room,
})
return string(b)
}
func jsonQuote(s string) string {
b, _ := json.Marshal(s)
return string(b)
}
func interpretOnMessage(out any, original string) (skip bool, text string) {
text = original
m, ok := out.(map[string]any)
if !ok {
if s, ok := out.(string); ok && s != "" {
return false, s
}
return false, original
}
if v, ok := m["skip"]; ok && boolish(v) {
return true, ""
}
if v, ok := m["drop"]; ok && boolish(v) {
return true, ""
}
if v, ok := m["message"]; ok {
text = fmt.Sprint(v)
} else if v, ok := m["消息"]; ok {
text = fmt.Sprint(v)
} else if v, ok := m["text"]; ok {
text = fmt.Sprint(v)
}
return false, text
}
+16 -7
View File
@@ -34,12 +34,13 @@ type CORSConfig struct {
// JSONRouteMount is one JSON API route with leading-slash path.
type JSONRouteMount struct {
Path string
Method string
Table string
Where any
Order string
Limit int64
Path string
Method string
Table string
Where any
Order string
Limit int64
TenantScope bool
}
// Configure merges configure tables into app.middleware (Rust web_app_middleware).
@@ -178,6 +179,11 @@ func parseJSONRoute(path string, spec any) (JSONRouteMount, bool) {
if w, ok := m["where"]; ok && w != nil {
r.Where = w
}
if v, ok := m["tenant_scope"]; ok {
r.TenantScope = boolish(v)
} else if v, ok := m["租户作用域"]; ok {
r.TenantScope = boolish(v)
}
return r, true
}
@@ -255,7 +261,7 @@ func SecurityFromTable(tableV any) map[string]any {
return out
}
// JSONRoutesFromTable normalizes `|路径|方法|表|条件|排序|上限|` into json_routes.
// JSONRoutesFromTable normalizes `|路径|方法|表|条件|排序|上限|租户作用域|` into json_routes.
func JSONRoutesFromTable(tableV any) map[string]any {
rows, _ := table.AsRows(tableV).([]any)
out := map[string]any{}
@@ -291,6 +297,9 @@ func JSONRoutesFromTable(tableV any) map[string]any {
if order != "" {
spec["order"] = order
}
if scope := col(m, "租户作用域", "tenant_scope", "TenantScope"); scope != "" {
spec["tenant_scope"] = boolish(scope)
}
out[path] = spec
}
return out
+510
View File
@@ -0,0 +1,510 @@
// Package rbac implements configurable role ⊥ permission for ext/web.
package rbac
import (
"database/sql"
"fmt"
"strings"
"github.com/marqdo/marqdo/plugins/web/internal/db"
)
// Perm is one catalog entry.
type Perm struct {
Code string
Resource string
Action string
Description string
}
// DefaultCatalog is seeded when EnsureSchema runs.
func DefaultCatalog() []Perm {
return []Perm{
{"comments:create", "comments", "create", "Create a comment"},
{"comments:delete", "comments", "delete", "Delete any comment"},
{"comments:delete_own", "comments", "delete_own", "Delete own comment"},
{"desk:access", "desk", "access", "Access writing desk / admin chrome"},
{"roles:manage", "roles", "manage", "Create roles and assign permissions"},
{"posts:edit", "posts", "edit", "Create or edit posts"},
{"users:manage", "users", "manage", "Manage user accounts"},
}
}
// AllCodes returns every default permission code.
func AllCodes() []string {
cat := DefaultCatalog()
out := make([]string, len(cat))
for i, p := range cat {
out[i] = p.Code
}
return out
}
// ExpandRole maps legacy/system role names to permission codes when DB grants are empty.
func ExpandRole(role string) []string {
switch strings.ToLower(strings.TrimSpace(role)) {
case "superadmin", "admin":
return AllCodes()
case "member", "user":
return []string{"comments:create", "comments:delete_own"}
case "editor", "author":
return []string{"comments:create", "comments:delete_own", "posts:edit", "desk:access"}
default:
return nil
}
}
// ParseCSV splits a CSV of permission or role tokens.
func ParseCSV(s string) []string {
var out []string
for _, part := range strings.Split(s, ",") {
part = strings.ToLower(strings.TrimSpace(part))
if part != "" {
out = append(out, part)
}
}
return out
}
// HasAny reports whether held contains any of needed (case-insensitive).
// Empty needed → false. Held containing "*" → true.
func HasAny(held, needed []string) bool {
if len(needed) == 0 {
return false
}
set := map[string]struct{}{}
for _, h := range held {
h = strings.ToLower(strings.TrimSpace(h))
if h == "*" {
return true
}
if h != "" {
set[h] = struct{}{}
}
}
for _, n := range needed {
n = strings.ToLower(strings.TrimSpace(n))
if _, ok := set[n]; ok {
return true
}
}
return false
}
// MergeUnique concatenates permission lists.
func MergeUnique(lists ...[]string) []string {
seen := map[string]struct{}{}
var out []string
for _, list := range lists {
for _, p := range list {
p = strings.ToLower(strings.TrimSpace(p))
if p == "" {
continue
}
if _, ok := seen[p]; ok {
continue
}
seen[p] = struct{}{}
out = append(out, p)
}
}
return out
}
const schemaSQL = `
CREATE TABLE IF NOT EXISTS web_permissions (
code TEXT PRIMARY KEY,
resource TEXT NOT NULL,
action TEXT NOT NULL,
description TEXT
);
CREATE TABLE IF NOT EXISTS web_roles (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL UNIQUE,
is_system INTEGER NOT NULL DEFAULT 0,
tenant_id TEXT
);
CREATE TABLE IF NOT EXISTS web_role_permissions (
role_id INTEGER NOT NULL,
permission_code TEXT NOT NULL,
PRIMARY KEY (role_id, permission_code),
FOREIGN KEY (role_id) REFERENCES web_roles(id) ON DELETE CASCADE,
FOREIGN KEY (permission_code) REFERENCES web_permissions(code) ON DELETE CASCADE
);
CREATE TABLE IF NOT EXISTS web_users (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT NOT NULL UNIQUE,
password_hash TEXT NOT NULL,
created_at TEXT
);
CREATE TABLE IF NOT EXISTS web_user_roles (
user_id INTEGER NOT NULL,
role_id INTEGER NOT NULL,
tenant_id TEXT NOT NULL DEFAULT '',
PRIMARY KEY (user_id, role_id, tenant_id),
FOREIGN KEY (user_id) REFERENCES web_users(id) ON DELETE CASCADE,
FOREIGN KEY (role_id) REFERENCES web_roles(id) ON DELETE CASCADE
);
`
// EnsureSchema creates RBAC tables and seeds default catalog + system roles.
func EnsureSchema(dbURL string) error {
if strings.TrimSpace(dbURL) == "" {
return fmt.Errorf("rbac: empty db url")
}
sqlDB, err := openDB(dbURL)
if err != nil {
return err
}
if _, err := sqlDB.Exec(schemaSQL); err != nil {
return err
}
for _, p := range DefaultCatalog() {
_, _ = sqlDB.Exec(
`INSERT OR IGNORE INTO web_permissions(code, resource, action, description) VALUES(?,?,?,?)`,
p.Code, p.Resource, p.Action, p.Description,
)
}
if err := ensureSystemRole(sqlDB, "superadmin", true, AllCodes()); err != nil {
return err
}
if err := ensureSystemRole(sqlDB, "member", true, []string{"comments:create", "comments:delete_own"}); err != nil {
return err
}
return nil
}
func ensureSystemRole(sqlDB *sql.DB, name string, isSystem bool, perms []string) error {
var id int64
err := sqlDB.QueryRow(`SELECT id FROM web_roles WHERE name = ?`, name).Scan(&id)
if err == sql.ErrNoRows {
sys := 0
if isSystem {
sys = 1
}
res, err := sqlDB.Exec(`INSERT INTO web_roles(name, is_system) VALUES(?,?)`, name, sys)
if err != nil {
return err
}
id, err = res.LastInsertId()
if err != nil {
return err
}
} else if err != nil {
return err
}
for _, code := range perms {
_, _ = sqlDB.Exec(
`INSERT OR IGNORE INTO web_role_permissions(role_id, permission_code) VALUES(?,?)`,
id, code,
)
}
return nil
}
// PermissionsForUser returns permission codes granted via user_roles for username.
func PermissionsForUser(dbURL, username string) ([]string, error) {
sqlDB, err := openDB(dbURL)
if err != nil {
return nil, err
}
rows, err := sqlDB.Query(`
SELECT DISTINCT rp.permission_code
FROM web_users u
JOIN web_user_roles ur ON ur.user_id = u.id
JOIN web_role_permissions rp ON rp.role_id = ur.role_id
WHERE u.username = ?`, username)
if err != nil {
return nil, err
}
defer rows.Close()
var out []string
for rows.Next() {
var code string
if err := rows.Scan(&code); err != nil {
return nil, err
}
out = append(out, strings.ToLower(code))
}
return out, rows.Err()
}
// AssignRole binds username to role name (creates user row link only; user must exist in web_users).
func AssignRole(dbURL, username, roleName string) error {
sqlDB, err := openDB(dbURL)
if err != nil {
return err
}
var uid, rid int64
if err := sqlDB.QueryRow(`SELECT id FROM web_users WHERE username = ?`, username).Scan(&uid); err != nil {
return fmt.Errorf("rbac assign: user %q: %w", username, err)
}
if err := sqlDB.QueryRow(`SELECT id FROM web_roles WHERE name = ?`, roleName).Scan(&rid); err != nil {
return fmt.Errorf("rbac assign: role %q: %w", roleName, err)
}
_, err = sqlDB.Exec(
`INSERT OR IGNORE INTO web_user_roles(user_id, role_id, tenant_id) VALUES(?,?,?)`,
uid, rid, "",
)
return err
}
// CreateRole inserts a non-system role; returns role id.
func CreateRole(dbURL, name string) (int64, error) {
if err := EnsureSchema(dbURL); err != nil {
return 0, err
}
sqlDB, err := openDB(dbURL)
if err != nil {
return 0, err
}
res, err := sqlDB.Exec(`INSERT INTO web_roles(name, is_system) VALUES(?,0)`, name)
if err != nil {
return 0, err
}
return res.LastInsertId()
}
// SetRolePermissions replaces role's permissions. grantable restricts what can be set (anti-escalation);
// empty grantable means allow all catalog codes.
func SetRolePermissions(dbURL string, roleID int64, codes, grantable []string) error {
sqlDB, err := openDB(dbURL)
if err != nil {
return err
}
var isSystem int
if err := sqlDB.QueryRow(`SELECT is_system FROM web_roles WHERE id = ?`, roleID).Scan(&isSystem); err != nil {
return err
}
if isSystem == 1 {
return fmt.Errorf("rbac: cannot rewrite system role permissions via set")
}
allow := map[string]struct{}{}
if len(grantable) == 0 {
for _, c := range AllCodes() {
allow[c] = struct{}{}
}
} else {
for _, c := range grantable {
allow[strings.ToLower(c)] = struct{}{}
}
}
tx, err := sqlDB.Begin()
if err != nil {
return err
}
defer func() { _ = tx.Rollback() }()
if _, err := tx.Exec(`DELETE FROM web_role_permissions WHERE role_id = ?`, roleID); err != nil {
return err
}
for _, code := range codes {
code = strings.ToLower(strings.TrimSpace(code))
if code == "" {
continue
}
if _, ok := allow[code]; !ok {
return fmt.Errorf("rbac: cannot grant permission %q (not held by actor)", code)
}
if _, err := tx.Exec(
`INSERT INTO web_role_permissions(role_id, permission_code) VALUES(?,?)`,
roleID, code,
); err != nil {
return err
}
}
return tx.Commit()
}
// CreateUser inserts a web_users row with hashed password; returns user id.
func CreateUser(dbURL, username, passwordHash string) (int64, error) {
username = strings.TrimSpace(username)
if username == "" || passwordHash == "" {
return 0, fmt.Errorf("rbac: username and password_hash required")
}
sqlDB, err := openDB(dbURL)
if err != nil {
return 0, err
}
res, err := sqlDB.Exec(
`INSERT INTO web_users(username, password_hash, created_at) VALUES(?,?,datetime('now'))`,
username, passwordHash,
)
if err != nil {
return 0, err
}
return res.LastInsertId()
}
// UserExists reports whether username is in web_users.
func UserExists(dbURL, username string) (bool, error) {
sqlDB, err := openDB(dbURL)
if err != nil {
return false, err
}
var id int64
err = sqlDB.QueryRow(`SELECT id FROM web_users WHERE username = ?`, username).Scan(&id)
if err == sql.ErrNoRows {
return false, nil
}
if err != nil {
return false, err
}
return true, nil
}
// Authenticate checks username/password against web_users; returns primary role name.
func Authenticate(dbURL, username, pass string, verify func(password, encoded string) bool) (role string, ok bool, err error) {
sqlDB, err := openDB(dbURL)
if err != nil {
return "", false, err
}
var hash string
var uid int64
err = sqlDB.QueryRow(`SELECT id, password_hash FROM web_users WHERE username = ?`, username).Scan(&uid, &hash)
if err == sql.ErrNoRows {
return "", false, nil
}
if err != nil {
return "", false, err
}
if verify == nil || !verify(pass, hash) {
return "", false, nil
}
var roleName string
err = sqlDB.QueryRow(`
SELECT r.name FROM web_user_roles ur
JOIN web_roles r ON r.id = ur.role_id
WHERE ur.user_id = ?
ORDER BY r.is_system DESC, r.name
LIMIT 1`, uid).Scan(&roleName)
if err == sql.ErrNoRows {
return "member", true, nil
}
if err != nil {
return "", false, err
}
return strings.ToLower(roleName), true, nil
}
// RegisterUser creates web_users + assigns defaultRole (default member).
func RegisterUser(dbURL, username, passwordHash, defaultRole string) error {
if defaultRole == "" {
defaultRole = "member"
}
exists, err := UserExists(dbURL, username)
if err != nil {
return err
}
if exists {
return fmt.Errorf("rbac: username already taken")
}
if _, err := CreateUser(dbURL, username, passwordHash); err != nil {
return err
}
return AssignRole(dbURL, username, defaultRole)
}
// EnsureUserWithRole creates user if missing (hash may be empty → skip create) and assigns role.
func EnsureUserWithRole(dbURL, username, passwordHash, roleName string) error {
exists, err := UserExists(dbURL, username)
if err != nil {
return err
}
if !exists {
if passwordHash == "" {
return fmt.Errorf("rbac: cannot create user %q without hash", username)
}
if _, err := CreateUser(dbURL, username, passwordHash); err != nil {
return err
}
}
return AssignRole(dbURL, username, roleName)
}
// ListRoles returns [{id,name,is_system}, …].
func ListRoles(dbURL string) ([]map[string]any, error) {
sqlDB, err := openDB(dbURL)
if err != nil {
return nil, err
}
rows, err := sqlDB.Query(`SELECT id, name, is_system FROM web_roles ORDER BY name`)
if err != nil {
return nil, err
}
defer rows.Close()
var out []map[string]any
for rows.Next() {
var id int64
var name string
var sys int
if err := rows.Scan(&id, &name, &sys); err != nil {
return nil, err
}
out = append(out, map[string]any{"id": id, "name": name, "is_system": sys == 1})
}
return out, rows.Err()
}
// ListPermissions returns catalog rows.
func ListPermissions(dbURL string) ([]map[string]any, error) {
sqlDB, err := openDB(dbURL)
if err != nil {
return nil, err
}
rows, err := sqlDB.Query(`SELECT code, resource, action, description FROM web_permissions ORDER BY code`)
if err != nil {
return nil, err
}
defer rows.Close()
var out []map[string]any
for rows.Next() {
var code, resource, action, desc string
if err := rows.Scan(&code, &resource, &action, &desc); err != nil {
return nil, err
}
out = append(out, map[string]any{
"code": code, "resource": resource, "action": action, "description": desc,
})
}
return out, rows.Err()
}
// RolePermissionCodes returns permission codes for a role id.
func RolePermissionCodes(dbURL string, roleID int64) ([]string, error) {
sqlDB, err := openDB(dbURL)
if err != nil {
return nil, err
}
rows, err := sqlDB.Query(`SELECT permission_code FROM web_role_permissions WHERE role_id = ? ORDER BY permission_code`, roleID)
if err != nil {
return nil, err
}
defer rows.Close()
var out []string
for rows.Next() {
var code string
if err := rows.Scan(&code); err != nil {
return nil, err
}
out = append(out, code)
}
return out, rows.Err()
}
// SetRolePermissionsByName looks up role by name then SetRolePermissions.
func SetRolePermissionsByName(dbURL, roleName string, codes, grantable []string) error {
sqlDB, err := openDB(dbURL)
if err != nil {
return err
}
var id int64
if err := sqlDB.QueryRow(`SELECT id FROM web_roles WHERE name = ?`, roleName).Scan(&id); err != nil {
return fmt.Errorf("rbac role %q: %w", roleName, err)
}
return SetRolePermissions(dbURL, id, codes, grantable)
}
func openDB(dbURL string) (*sql.DB, error) {
// Reuse db package pool via a no-op select path: open through Ensure-compatible helper.
return db.OpenSQL(dbURL)
}
+58
View File
@@ -0,0 +1,58 @@
package rbac_test
import (
"path/filepath"
"testing"
"github.com/marqdo/marqdo/plugins/web/internal/db"
"github.com/marqdo/marqdo/plugins/web/internal/rbac"
)
func TestHasAnyAndExpandRole(t *testing.T) {
if !rbac.HasAny([]string{"desk:access", "comments:create"}, []string{"desk:access"}) {
t.Fatal("expected desk:access held")
}
if rbac.HasAny([]string{"comments:create"}, []string{"desk:access"}) {
t.Fatal("member should not have desk")
}
if !rbac.HasAny([]string{"*"}, []string{"roles:manage"}) {
t.Fatal("star should allow all")
}
admin := rbac.ExpandRole("admin")
if !rbac.HasAny(admin, []string{"roles:manage", "desk:access"}) {
t.Fatalf("admin expand incomplete: %v", admin)
}
member := rbac.ExpandRole("member")
if rbac.HasAny(member, []string{"desk:access"}) {
t.Fatal("member must not get desk:access")
}
}
func TestEnsureSchemaAndAssign(t *testing.T) {
dir := t.TempDir()
url := "sqlite:" + filepath.Join(dir, "rbac.db")
if err := rbac.EnsureSchema(url); err != nil {
t.Fatal(err)
}
sqlDB, err := db.OpenSQL(url)
if err != nil {
t.Fatal(err)
}
_, err = sqlDB.Exec(`INSERT INTO web_users(username, password_hash, created_at) VALUES('alice','x','now')`)
if err != nil {
t.Fatal(err)
}
if err := rbac.AssignRole(url, "alice", "member"); err != nil {
t.Fatal(err)
}
perms, err := rbac.PermissionsForUser(url, "alice")
if err != nil {
t.Fatal(err)
}
if !rbac.HasAny(perms, []string{"comments:create"}) {
t.Fatalf("alice perms=%v", perms)
}
if rbac.HasAny(perms, []string{"roles:manage"}) {
t.Fatal("member should not manage roles")
}
}
+155 -14
View File
@@ -462,6 +462,120 @@ func resolveMain(page map[string]any, dbURL string) (intro string, items []map[s
return intro, items, total
}
// listBind is one secondary page list (compose_list / 列表装配).
type listBind struct {
Items []map[string]any
Target string
HTML string
}
func resolveLists(page map[string]any, dbURL string) []listBind {
raw, ok := page["lists"].([]any)
if !ok || len(raw) == 0 || dbURL == "" {
return nil
}
var out []listBind
for _, entry := range raw {
em, ok := entry.(map[string]any)
if !ok {
continue
}
bindsAny := table.AsBind(em["main"])
arr, _ := bindsAny.([]any)
if len(arr) == 0 {
continue
}
tn, ok := table.BindTableName(arr)
if !ok {
continue
}
sub := map[string]any{"params": pageParams(page)}
if q, ok := em["query"]; ok {
sub["query"] = q
}
if o, ok := em["order"].(string); ok {
sub["order"] = o
}
data := selectPageData(dbURL, tn, sub, 200, 0)
rawRows, _ := data["rows"].([]any)
projected := table.ProjectRows(arr, rawRows)
parr, _ := projected.([]any)
var items []map[string]any
for _, v := range parr {
if m, ok := v.(map[string]any); ok {
items = append(items, m)
}
}
lb := listBind{Items: items}
if t, ok := em["target"].(string); ok {
lb.Target = t
}
lb.HTML = renderListSection(page, items)
out = append(out, lb)
}
return out
}
func renderListSection(page map[string]any, items []map[string]any) string {
var s strings.Builder
s.WriteString(`<div class="list-bind" aria-live="polite">`)
if len(items) == 0 {
s.WriteString(`<p class="list-empty comment-empty">还没有条目。</p>`)
} else {
s.WriteString(`<ul class="list-thread comment-thread">`)
for _, it := range items {
s.WriteString(renderListItem(page, it))
}
s.WriteString(`</ul>`)
}
s.WriteString(`</div>`)
return s.String()
}
func renderListItem(page map[string]any, it map[string]any) string {
title := text(it["title"])
body := text(it["body"])
meta := text(it["meta"])
href := text(it["href"])
if href != "" {
return `<li class="list-item">` + renderCard(page, it) + `</li>`
}
var s strings.Builder
s.WriteString(`<li class="list-item comment-item">`)
s.WriteString(`<div class="comment-meta">`)
if title != "" {
s.WriteString(fmt.Sprintf(`<span class="comment-author">%s</span>`, esc(title)))
}
if meta != "" {
s.WriteString(fmt.Sprintf(`<time>%s</time>`, esc(meta)))
}
s.WriteString(`</div>`)
if body != "" {
escaped := esc(body)
escaped = strings.ReplaceAll(escaped, "\n", "<br>")
s.WriteString(fmt.Sprintf(`<p class="comment-body">%s</p>`, escaped))
}
s.WriteString(`</li>`)
return s.String()
}
func applyListTargets(intro string, lists []listBind) (string, string) {
rest := strings.Builder{}
for _, lb := range lists {
if lb.HTML == "" {
continue
}
if lb.Target != "" && intro != "" {
if injected, ok := injectHTMLIntoID(intro, lb.Target, lb.HTML); ok {
intro = injected
continue
}
}
rest.WriteString(lb.HTML)
}
return intro, rest.String()
}
func fieldCSS(obj map[string]any, field string) string {
css, _ := obj["_css"].(map[string]any)
if css == nil {
@@ -846,7 +960,17 @@ func pageFormHTML(page map[string]any) (formID string, html string) {
if !ok || frm == nil {
return "", ""
}
return id, form.RenderBody(frm, id, nil, nil, "")
ctx := &form.RequestContext{
Params: pageParams(page),
}
if u, ok := page["_nav_user"].(string); ok {
ctx.Username = u
}
if r, ok := page["_route"].(string); ok && r != "" {
ctx.ReturnPath = r
ctx.Path = r
}
return id, form.RenderBodyCtx(frm, id, nil, nil, "", ctx)
}
func pushIntro(buf *strings.Builder, intro string) {
@@ -906,19 +1030,26 @@ func renderFragment(page map[string]any, dbURL, slot string) string {
)
default:
intro, items, _ := resolveMain(page, dbURL)
lists := resolveLists(page, dbURL)
intro, listRest := applyListTargets(intro, lists)
isDetail, _ := page["detail"].(bool)
var body strings.Builder
pushIntroAndForm(&body, intro, page)
if len(items) > 0 {
isDetail, _ := page["detail"].(bool)
if isDetail {
if isDetail {
if len(items) > 0 {
body.WriteString(renderArticle(items[0]))
} else {
}
body.WriteString(listRest)
pushIntroAndForm(&body, intro, page)
} else {
pushIntroAndForm(&body, intro, page)
if len(items) > 0 {
body.WriteString(`<section class="content cards">`)
for _, it := range items {
body.WriteString(renderCard(page, it))
}
body.WriteString(`</section>`)
}
body.WriteString(listRest)
}
return fmt.Sprintf(`<main class="main" data-slot="main">%s</main>`, body.String())
}
@@ -1011,21 +1142,31 @@ func RenderPage(page map[string]any, dbURL string, partID string) string {
if images, ok := page["images_html"].(string); ok && images != "" {
mainHTML.WriteString(images)
}
pushIntroAndForm(&mainHTML, intro, page)
if len(items) > 0 {
isDetail, _ := page["detail"].(bool)
if isDetail {
lists := resolveLists(page, dbURL)
intro, listRest := applyListTargets(intro, lists)
isDetail, _ := page["detail"].(bool)
if isDetail {
if len(items) > 0 {
mainHTML.WriteString(renderArticle(items[0]))
} else {
if total != nil {
mainHTML.WriteString(renderPagination(page, *total, len(items)))
}
}
mainHTML.WriteString(listRest)
pushIntroAndForm(&mainHTML, intro, page)
} else {
pushIntroAndForm(&mainHTML, intro, page)
if len(items) > 0 {
mainHTML.WriteString(`<section class="content cards">`)
for _, it := range items {
mainHTML.WriteString(renderCard(page, it))
}
mainHTML.WriteString(`</section>`)
if total != nil {
mainHTML.WriteString(renderPagination(page, *total, len(items)))
}
}
if total != nil {
mainHTML.WriteString(renderPagination(page, *total, len(items)))
}
mainHTML.WriteString(listRest)
}
styleBlock := ""
+62
View File
@@ -612,6 +612,20 @@ func RoleFromCookie(cookieHeader string) string {
return "visitor"
}
// UsernameFromCookie returns the session username or empty string.
func UsernameFromCookie(cookieHeader string) string {
sid, ok := IDFromCookie(cookieHeader)
if !ok {
return ""
}
if v, ok := GetValue(sid, "username"); ok {
if s, ok := v.(string); ok {
return s
}
}
return ""
}
// RoleAllowed reports whether role is in allowed (empty allowed = all).
func RoleAllowed(role string, allowed []string) bool {
if len(allowed) == 0 {
@@ -625,3 +639,51 @@ func RoleAllowed(role string, allowed []string) bool {
}
return false
}
// PermissionsFromCookie returns session permission codes (empty if anonymous).
func PermissionsFromCookie(cookieHeader string) []string {
sid, ok := IDFromCookie(cookieHeader)
if !ok {
return nil
}
return PermissionsFromSession(sid)
}
// PermissionsFromSession reads the permissions CSV from a session id.
func PermissionsFromSession(sid string) []string {
if v, ok := GetValue(sid, "permissions"); ok {
if s, ok := v.(string); ok && s != "" {
return ParseRolesCSV(s)
}
}
return nil
}
// SetPermissions stores permission codes on the session.
func SetPermissions(sid string, codes []string) {
SetValue(sid, "permissions", strings.Join(codes, ","))
}
// PermissionAllowed reports whether the session holds any of needed.
func PermissionAllowed(held, needed []string) bool {
if len(needed) == 0 {
return true
}
set := map[string]struct{}{}
for _, h := range held {
h = strings.ToLower(strings.TrimSpace(h))
if h == "*" {
return true
}
if h != "" {
set[h] = struct{}{}
}
}
for _, n := range needed {
n = strings.ToLower(strings.TrimSpace(n))
if _, ok := set[n]; ok {
return true
}
}
return false
}
+252
View File
@@ -0,0 +1,252 @@
// 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) }
@@ -0,0 +1,58 @@
package tenant_test
import (
"net/http/httptest"
"testing"
"github.com/marqdo/marqdo/plugins/web/internal/tenant"
)
func TestResolvePathQuery(t *testing.T) {
cfg := tenant.Config{Mode: "path", Param: "t", Column: "tenant_id"}
r := httptest.NewRequest("GET", "/api/items?t=acme", nil)
if got := tenant.Resolve(r, cfg); got != "acme" {
t.Fatalf("got %q", got)
}
}
func TestResolvePathPrefix(t *testing.T) {
cfg := tenant.Config{Mode: "path", Param: "t"}
r := httptest.NewRequest("GET", "/t/beta/items", nil)
if got := tenant.Resolve(r, cfg); got != "beta" {
t.Fatalf("got %q", got)
}
}
func TestResolveHeader(t *testing.T) {
cfg := tenant.Config{Mode: "header", Param: "X-Tenant-Id"}
r := httptest.NewRequest("GET", "/", nil)
r.Header.Set("X-Tenant-Id", "Gamma")
if got := tenant.Resolve(r, cfg); got != "gamma" {
t.Fatalf("got %q", got)
}
}
func TestMergeWhereAndStamp(t *testing.T) {
w := tenant.MergeWhere(nil, "tenant_id", "acme")
arr, ok := w.([]any)
if !ok || len(arr) != 1 {
t.Fatalf("where=%v", w)
}
row := tenant.StampRow(map[string]any{"title": "x"}, "tenant_id", "acme")
if row["tenant_id"] != "acme" {
t.Fatalf("row=%v", row)
}
}
func TestConfigure(t *testing.T) {
out, err := tenant.Configure(map[string]any{}, map[string]any{
"mode": "path", "param": "org", "default_scope": true,
})
if err != nil {
t.Fatal(err)
}
cfg := tenant.FromBag(out)
if cfg.Mode != "path" || cfg.Param != "org" || !cfg.DefaultScope {
t.Fatalf("%+v", cfg)
}
}
+52 -4
View File
@@ -7,13 +7,15 @@ import (
"github.com/marqdo/marqdo/plugins/web/internal/app"
)
// RouteSpec is one ws_routes entry (mode + optional room_key template).
// RouteSpec is one ws_routes entry (mode + optional room_key / on_message / presence).
type RouteSpec struct {
Mode Mode
RoomKey string
Mode Mode
RoomKey string
OnMessage string
Presence bool
}
// RouteWS registers path → {mode, room_key?} on app.ws_routes (Rust web_app_route_ws).
// RouteWS registers path → {mode, room_key?, on_message?, presence?} on app.ws_routes.
func RouteWS(appBag map[string]any, path string, args map[string]any) (map[string]any, error) {
path, err := app.NormalizeRoutePath(path, appBag)
if err != nil {
@@ -24,6 +26,8 @@ func RouteWS(appBag map[string]any, path string, args map[string]any) (map[strin
if mode == ModeRoom && roomKey == "" {
return nil, fmt.Errorf("mode=room requires room_key")
}
onMsg := OnMessageFromArgs(args)
presence := PresenceFromArgs(args)
out := clone(appBag)
wsRoutes := map[string]any{}
if r, ok := out["ws_routes"].(map[string]any); ok {
@@ -33,6 +37,12 @@ func RouteWS(appBag map[string]any, path string, args map[string]any) (map[strin
if roomKey != "" {
spec["room_key"] = roomKey
}
if onMsg != "" {
spec["on_message"] = onMsg
}
if presence {
spec["presence"] = true
}
wsRoutes[path] = spec
out["ws_routes"] = wsRoutes
return out, nil
@@ -46,6 +56,34 @@ func RoomKeyFromArgs(args map[string]any) string {
return ""
}
// OnMessageFromArgs reads on_message / 消息钩子 (lib.member path).
func OnMessageFromArgs(args map[string]any) string {
if v, ok := first(args, "on_message", "消息钩子", "钩子"); ok {
return strings.TrimSpace(fmt.Sprint(v))
}
return ""
}
// PresenceFromArgs reads presence / 在场 flag.
func PresenceFromArgs(args map[string]any) bool {
if v, ok := first(args, "presence", "在场"); ok {
return boolish(v)
}
return false
}
// ExpandTemplate replaces `{name}` tokens using values from PathValue-style map.
func ExpandTemplate(tmpl string, values map[string]string) string {
if tmpl == "" || len(values) == 0 {
return tmpl
}
out := tmpl
for k, v := range values {
out = strings.ReplaceAll(out, "{"+k+"}", v)
}
return out
}
// RoutesOf reads ws_routes from an app bag.
func RoutesOf(appBag map[string]any) map[string]Mode {
out := map[string]Mode{}
@@ -117,6 +155,16 @@ func parseRouteSpec(spec any) RouteSpec {
if rk, ok := t["room_key"]; ok {
out.RoomKey = strings.TrimSpace(fmt.Sprint(rk))
}
if om, ok := t["on_message"]; ok {
out.OnMessage = strings.TrimSpace(fmt.Sprint(om))
} else if om, ok := t["消息钩子"]; ok {
out.OnMessage = strings.TrimSpace(fmt.Sprint(om))
}
if p, ok := t["presence"]; ok {
out.Presence = boolish(p)
} else if p, ok := t["在场"]; ok {
out.Presence = boolish(p)
}
case string:
out.Mode = ParseMode(t)
default:
+27
View File
@@ -113,6 +113,33 @@ func TestRouteWSRoomRequiresKey(t *testing.T) {
}
}
func TestExpandTemplate(t *testing.T) {
got := ws.ExpandTemplate("chat.room.{id}", map[string]string{"id": "lobby"})
if got != "chat.room.lobby" {
t.Fatalf("got %q", got)
}
}
func TestRouteWSOnMessageAndPresence(t *testing.T) {
a := app.New(nil)
out, err := ws.RouteWS(a, "/chat/{id}", map[string]any{
"mode": "room",
"room_key": "chat.room.{id}",
"on_message": "chat.persist",
"presence": true,
})
if err != nil {
t.Fatal(err)
}
spec, err := ws.RouteSpecOf(out, "/chat/{id}")
if err != nil {
t.Fatal(err)
}
if spec.OnMessage != "chat.persist" || !spec.Presence {
t.Fatalf("spec=%+v", spec)
}
}
func TestConnectRefusesBadURL(t *testing.T) {
out := ws.Connect("http://127.0.0.1:1", "hi", nil, 1)
if out["ok"] == true {
+53 -7
View File
@@ -60,6 +60,7 @@ extern int web_page_chrome(char *args_json, char **out_json, char **err_msg);
extern int web_style(char *args_json, char **out_json, char **err_msg);
extern int web_compose_components(char *args_json, char **out_json, char **err_msg);
extern int web_compose_main(char *args_json, char **out_json, char **err_msg);
extern int web_compose_list(char *args_json, char **out_json, char **err_msg);
extern int web_compose_intro(char *args_json, char **out_json, char **err_msg);
extern int web_intro(char *args_json, char **out_json, char **err_msg);
extern int web_render(char *args_json, char **out_json, char **err_msg);
@@ -106,6 +107,15 @@ extern int web_auth_logout(char *args_json, char **out_json, char **err_msg);
extern int web_auth_new(char *args_json, char **out_json, char **err_msg);
extern int web_app_auth(char *args_json, char **out_json, char **err_msg);
extern int web_app_gate(char *args_json, char **out_json, char **err_msg);
extern int web_app_rbac(char *args_json, char **out_json, char **err_msg);
extern int web_app_tenant(char *args_json, char **out_json, char **err_msg);
extern int web_rbac_can(char *args_json, char **out_json, char **err_msg);
extern int web_rbac_ensure(char *args_json, char **out_json, char **err_msg);
extern int web_rbac_assign_role(char *args_json, char **out_json, char **err_msg);
extern int web_rbac_create_role(char *args_json, char **out_json, char **err_msg);
extern int web_rbac_set_role_permissions(char *args_json, char **out_json, char **err_msg);
extern int web_rbac_list_roles(char *args_json, char **out_json, char **err_msg);
extern int web_rbac_list_permissions(char *args_json, char **out_json, char **err_msg);
extern int web_storage_new(char *args_json, char **out_json, char **err_msg);
extern int web_storage_put(char *args_json, char **out_json, char **err_msg);
extern int web_storage_get(char *args_json, char **out_json, char **err_msg);
@@ -155,6 +165,7 @@ static int register_core(void) {
if (host_register((char *)"web_style", (char *)"name,table,strict", web_style) != 0) return 1;
if (host_register((char *)"web_compose_components", (char *)"page,components", web_compose_components) != 0) return 1;
if (host_register((char *)"web_compose_main", (char *)"page,main", web_compose_main) != 0) return 1;
if (host_register((char *)"web_compose_list", (char *)"page,main,query,order,target", web_compose_list) != 0) return 1;
if (host_register((char *)"web_compose_intro", (char *)"page,intro", web_compose_intro) != 0) return 1;
if (host_register((char *)"web_intro", (char *)"table", web_intro) != 0) return 1;
if (host_register((char *)"web_compose_form", (char *)"page,form,id,target", web_compose_form) != 0) return 1;
@@ -199,8 +210,17 @@ static int register_core(void) {
if (host_register((char *)"web_auth_check", (char *)"session_id", web_auth_check) != 0) return 1;
if (host_register((char *)"web_auth_logout", (char *)"session_id", web_auth_logout) != 0) return 1;
if (host_register((char *)"web_auth_new", (char *)"users,session_ttl", web_auth_new) != 0) return 1;
if (host_register((char *)"web_app_auth", (char *)"app,users,session_ttl,admin_prefix,login_redirect,logout_redirect,login_path", web_app_auth) != 0) return 1;
if (host_register((char *)"web_app_gate", (char *)"app,path,roles,match,on_deny,exclude", web_app_gate) != 0) return 1;
if (host_register((char *)"web_app_auth", (char *)"app,users,session_ttl,admin_prefix,login_redirect,logout_redirect,login_path,register,register_path,default_role", web_app_auth) != 0) return 1;
if (host_register((char *)"web_app_gate", (char *)"app,path,roles,permissions,match,on_deny,exclude", web_app_gate) != 0) return 1;
if (host_register((char *)"web_app_rbac", (char *)"app,catalog", web_app_rbac) != 0) return 1;
if (host_register((char *)"web_app_tenant", (char *)"app,mode,param,column,default_scope", web_app_tenant) != 0) return 1;
if (host_register((char *)"web_rbac_can", (char *)"permissions,needed", web_rbac_can) != 0) return 1;
if (host_register((char *)"web_rbac_ensure", (char *)"url", web_rbac_ensure) != 0) return 1;
if (host_register((char *)"web_rbac_assign_role", (char *)"url,username,role", web_rbac_assign_role) != 0) return 1;
if (host_register((char *)"web_rbac_create_role", (char *)"url,name", web_rbac_create_role) != 0) return 1;
if (host_register((char *)"web_rbac_set_role_permissions", (char *)"url,role,permissions,grantable", web_rbac_set_role_permissions) != 0) return 1;
if (host_register((char *)"web_rbac_list_roles", (char *)"url", web_rbac_list_roles) != 0) return 1;
if (host_register((char *)"web_rbac_list_permissions", (char *)"url", web_rbac_list_permissions) != 0) return 1;
if (host_register((char *)"web_storage_new", (char *)"url", web_storage_new) != 0) return 1;
if (host_register((char *)"web_storage_put", (char *)"url,key,body,path,content_type", web_storage_put) != 0) return 1;
if (host_register((char *)"web_storage_get", (char *)"url,key", web_storage_get) != 0) return 1;
@@ -226,7 +246,7 @@ static int register_core(void) {
if (host_register((char *)"web_app_sitemap", (char *)"app,path,base,table,loc,limit,items", web_app_sitemap) != 0) return 1;
if (host_register((char *)"web_app_robots", (char *)"app,body,sitemap", web_app_robots) != 0) return 1;
if (host_register((char *)"web_sitemap_build", (char *)"base,items", web_sitemap_build) != 0) return 1;
if (host_register((char *)"web_app_route_ws", (char *)"app,path,echo,mode", web_app_route_ws) != 0) return 1;
if (host_register((char *)"web_app_route_ws", (char *)"app,path,echo,mode,room_key,on_message,presence", web_app_route_ws) != 0) return 1;
if (host_register((char *)"web_ws_connect", (char *)"url,message,headers,timeout_sec", web_ws_connect) != 0) return 1;
if (host_register((char *)"web_cache_new", (char *)"url", web_cache_new) != 0) return 1;
if (host_register((char *)"web_cache_get", (char *)"url,key", web_cache_get) != 0) return 1;
@@ -424,12 +444,14 @@ func resolveDbURL(url string) string {
}
func dbURLOf(args map[string]any) (string, error) {
if s, ok := argStr(args, "url", "db_url"); ok && s != "" {
if s, ok := argStr(args, "url", "db_url", "数据库"); ok && s != "" {
return resolveDbURL(s), nil
}
if dbObj, ok := args["db"].(map[string]any); ok {
if s, ok := argStr(dbObj, "url"); ok && s != "" {
return resolveDbURL(s), nil
for _, key := range []string{"url", "db", "数据库"} {
if dbObj, ok := args[key].(map[string]any); ok {
if s, ok := argStr(dbObj, "url"); ok && s != "" {
return resolveDbURL(s), nil
}
}
}
return "", fmt.Errorf("missing db url")
@@ -513,6 +535,30 @@ func web_compose_main(argsJSON *C.char, outJSON **C.char, errMsg **C.char) C.int
return replyJSON(outJSON, errMsg, out, err)
}
//export web_compose_list
func web_compose_list(argsJSON *C.char, outJSON **C.char, errMsg **C.char) C.int {
args, err := parseArgs(argsJSON)
if err != nil {
return replyJSON(outJSON, errMsg, nil, err)
}
pageBag := asPageMap(args["page"])
main := args["main"]
if main == nil {
main = args["主体"]
}
if main == nil {
return replyJSON(outJSON, errMsg, nil, fmt.Errorf("missing `main`"))
}
query := args["query"]
if query == nil {
query = args["条件"]
}
order, _ := argStr(args, "order", "排序")
target, _ := argStr(args, "target", "插槽", "表单插槽")
out, err := compose.ComposeList(pageBag, main, query, order, target, callLib)
return replyJSON(outJSON, errMsg, out, err)
}
//export web_compose_intro
func web_compose_intro(argsJSON *C.char, outJSON **C.char, errMsg **C.char) C.int {
args, err := parseArgs(argsJSON)
+183 -58
View File
@@ -4,10 +4,15 @@
# Example: ./scripts/ppa-build-source.sh noble
#
# Launchpad builders have no network and noble's cargo (1.75) cannot read
# Cargo.lock v4. This script therefore:
# Cargo.lock v4. For a *new* upstream SemVer this script:
# 1) cargo vendor → vendor/
# 2) installs a modern Rust toolchain into third_party/rust (cached)
# 3) packs both into the .orig.tar.xz for offline debuild on Launchpad
#
# For debian-only bumps (same upstream X.Y.Z already in the PPA):
# - Reuse the published marqdo_X.Y.Z.orig.tar.xz (never rewrite it)
# - debuild -S -sd (do not re-upload .orig)
# Override: MARQDO_PPA_FORCE_ORIG=1 rebuilds orig; MARQDO_PPA_ORIG=/path uses that file.
set -euo pipefail
SERIES="${1:-noble}"
@@ -47,20 +52,175 @@ RUST_NAME="rust-${RUST_VER}-${RUST_TRIPLE}"
RUST_CACHE="${MARQDO_PPA_RUST_CACHE:-${HOME}/.cache/marqdo-ppa}"
RUST_TARBALL="${RUST_CACHE}/${RUST_NAME}.tar.gz"
RUST_URL="${MARQDO_PPA_RUST_URL:-https://static.rust-lang.org/dist/${RUST_NAME}.tar.gz}"
PPA_OWNER="${MARQDO_PPA_OWNER:-cflmy}"
PPA_NAME="${MARQDO_PPA_NAME:-marqdo}"
ORIG_NAME="marqdo_${VER}.orig.tar.xz"
FORCE_ORIG="${MARQDO_PPA_FORCE_ORIG:-0}"
resolve_existing_orig() {
local candidate
if [ -n "${MARQDO_PPA_ORIG:-}" ]; then
candidate="${MARQDO_PPA_ORIG}"
if [ ! -f "$candidate" ]; then
echo "error: MARQDO_PPA_ORIG not a file: $candidate" >&2
exit 1
fi
echo "$candidate"
return 0
fi
for candidate in \
"$BUILD_AREA/$ORIG_NAME" \
"$RUST_CACHE/$ORIG_NAME" \
"$HOME/.cache/marqdo-ppa/$ORIG_NAME"
do
if [ -f "$candidate" ]; then
echo "$candidate"
return 0
fi
done
return 1
}
download_published_orig() {
local dest="$1"
local urls=(
"https://ppa.launchpadcontent.net/${PPA_OWNER}/${PPA_NAME}/ubuntu/pool/main/m/marqdo/${ORIG_NAME}"
"https://launchpad.net/~${PPA_OWNER}/+archive/ubuntu/${PPA_NAME}/+files/${ORIG_NAME}"
)
local url
mkdir -p "$(dirname "$dest")"
for url in "${urls[@]}"; do
echo " trying ${url}"
if curl -fL --retry 3 --retry-delay 2 --connect-timeout 30 \
-o "${dest}.partial" "$url"; then
mv "${dest}.partial" "$dest"
return 0
fi
rm -f "${dest}.partial"
done
return 1
}
echo "==> upstream ${VER} → debian ${DEB_VER} (${SERIES})"
rm -rf "$PKG_ROOT"
mkdir -p "$PKG_ROOT" "$BUILD_AREA" "$RUST_CACHE"
# Clean export of sources (no target/, .git)
if command -v git >/dev/null && git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
git archive --format=tar HEAD | tar -x -C "$PKG_ROOT"
else
rsync -a --exclude target --exclude .git --exclude build-area "$ROOT"/ "$PKG_ROOT"/
REUSE_ORIG=0
ORIG_SRC=""
if [ "$FORCE_ORIG" != "1" ]; then
# Prefer the bytes already accepted by Launchpad (rewriting .orig is rejected).
if download_published_orig "$RUST_CACHE/$ORIG_NAME"; then
ORIG_SRC="$RUST_CACHE/$ORIG_NAME"
elif ORIG_SRC="$(resolve_existing_orig)"; then
echo "warning: could not fetch PPA ${ORIG_NAME}; using local ${ORIG_SRC}" >&2
echo "warning: if its sha256 differs from the archive, Launchpad will reject the upload" >&2
fi
if [ -n "$ORIG_SRC" ]; then
REUSE_ORIG=1
fi
fi
# Ensure debian/ from working tree (may be newer than last commit)
rsync -a "$ROOT/debian/" "$PKG_ROOT/debian/"
if [ "$REUSE_ORIG" -eq 1 ]; then
echo "==> reusing published ${ORIG_NAME} (debian-only bump; do not rewrite orig)"
echo " source: ${ORIG_SRC}"
sha256sum "$ORIG_SRC"
cp -f "$ORIG_SRC" "$BUILD_AREA/$ORIG_NAME"
# Unpack orig (top dir is usually ${VER} or marqdo-${VER})
tar -xJf "$BUILD_AREA/$ORIG_NAME" -C "$(dirname "$PKG_ROOT")"
if [ ! -d "$PKG_ROOT" ]; then
# Some tarballs use marqdo-${VER}/
if [ -d "$(dirname "$PKG_ROOT")/marqdo-${VER}" ]; then
mv "$(dirname "$PKG_ROOT")/marqdo-${VER}" "$PKG_ROOT"
else
echo "error: unpack did not create ${PKG_ROOT}" >&2
tar -tJf "$BUILD_AREA/$ORIG_NAME" | head -5 >&2
exit 1
fi
fi
rsync -a "$ROOT/debian/" "$PKG_ROOT/debian/"
else
echo "==> building fresh ${ORIG_NAME} (new upstream or MARQDO_PPA_FORCE_ORIG=1)"
# Clean export of sources (no target/, .git)
if command -v git >/dev/null && git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
git archive --format=tar HEAD | tar -x -C "$PKG_ROOT"
else
rsync -a --exclude target --exclude .git --exclude build-area "$ROOT"/ "$PKG_ROOT"/
fi
rsync -a "$ROOT/debian/" "$PKG_ROOT/debian/"
cd "$PKG_ROOT"
echo "==> cargo vendor (Launchpad offline)"
mkdir -p .cargo
cargo vendor --locked vendor >/tmp/marqdo-cargo-vendor.conf
cat > .cargo/config.toml <<'EOF'
[source.crates-io]
replace-with = "vendored-sources"
[source.vendored-sources]
directory = "vendor"
EOF
# dh_clean removes *.orig; drop those paths from vendor checksums so a
# stray clean (or older rules) cannot break `cargo --offline` on Launchpad.
python3 - <<'PY'
from __future__ import annotations
import json
from pathlib import Path
root = Path("vendor")
if not root.is_dir():
raise SystemExit("vendor/ missing after cargo vendor")
n_files = 0
n_json = 0
for checksum in root.rglob(".cargo-checksum.json"):
data = json.loads(checksum.read_text(encoding="utf-8"))
files = data.get("files") or {}
drop = [name for name in files if name.endswith(".orig") or name.endswith(".rej")]
if not drop:
continue
for name in drop:
del files[name]
path = checksum.parent / name
if path.is_file():
path.unlink()
n_files += 1
checksum.write_text(json.dumps(data, indent=4) + "\n", encoding="utf-8")
n_json += 1
print(f"stripped {n_files} *.orig/*.rej from {n_json} vendor checksums")
PY
echo "==> bundle Rust ${RUST_VER} (${RUST_TRIPLE}) for Launchpad"
if [ ! -f "$RUST_TARBALL" ]; then
echo " downloading ${RUST_URL}"
curl -fL --retry 3 --retry-delay 2 -o "${RUST_TARBALL}.partial" "$RUST_URL"
mv "${RUST_TARBALL}.partial" "$RUST_TARBALL"
else
echo " cache hit ${RUST_TARBALL}"
fi
rm -rf third_party/rust
mkdir -p third_party
RUST_EXTRACT="$(mktemp -d "${TMPDIR:-/tmp}/marqdo-rust.XXXXXX")"
tar -xzf "$RUST_TARBALL" -C "$RUST_EXTRACT"
INSTALL_SH="$(find "$RUST_EXTRACT" -maxdepth 2 -name install.sh | head -1)"
if [ -z "$INSTALL_SH" ]; then
echo "error: install.sh not found in ${RUST_TARBALL}" >&2
exit 1
fi
bash "$INSTALL_SH" \
--prefix="$PKG_ROOT/third_party/rust" \
--without=rust-docs \
--disable-ldconfig
rm -rf "$RUST_EXTRACT"
"$PKG_ROOT/third_party/rust/bin/rustc" --version
"$PKG_ROOT/third_party/rust/bin/cargo" --version
cd "$(dirname "$PKG_ROOT")"
echo "==> packing ${ORIG_NAME} (vendor + third_party/rust)"
rm -f "$BUILD_AREA/$ORIG_NAME"
tar -cJf "$BUILD_AREA/$ORIG_NAME" \
--exclude=debian \
-C "$(dirname "$PKG_ROOT")" "$(basename "$PKG_ROOT")"
fi
cd "$PKG_ROOT"
python3 - <<PY
@@ -79,58 +239,19 @@ p.write_text(text2, encoding="utf-8")
print("changelog:", p.read_text(encoding="utf-8").splitlines()[0])
PY
echo "==> cargo vendor (Launchpad offline)"
mkdir -p .cargo
cargo vendor --locked vendor >/tmp/marqdo-cargo-vendor.conf
cat > .cargo/config.toml <<'EOF'
[source.crates-io]
replace-with = "vendored-sources"
[source.vendored-sources]
directory = "vendor"
EOF
echo "==> bundle Rust ${RUST_VER} (${RUST_TRIPLE}) for Launchpad"
if [ ! -f "$RUST_TARBALL" ]; then
echo " downloading ${RUST_URL}"
curl -fL --retry 3 --retry-delay 2 -o "${RUST_TARBALL}.partial" "$RUST_URL"
mv "${RUST_TARBALL}.partial" "$RUST_TARBALL"
else
echo " cache hit ${RUST_TARBALL}"
fi
rm -rf third_party/rust
mkdir -p third_party
RUST_EXTRACT="$(mktemp -d "${TMPDIR:-/tmp}/marqdo-rust.XXXXXX")"
tar -xzf "$RUST_TARBALL" -C "$RUST_EXTRACT"
# Official dist tarball contains install.sh
INSTALL_SH="$(find "$RUST_EXTRACT" -maxdepth 2 -name install.sh | head -1)"
if [ -z "$INSTALL_SH" ]; then
echo "error: install.sh not found in ${RUST_TARBALL}" >&2
exit 1
fi
# --disable-ldconfig avoids needing root; strip docs to save space
bash "$INSTALL_SH" \
--prefix="$PKG_ROOT/third_party/rust" \
--without=rust-docs \
--disable-ldconfig
rm -rf "$RUST_EXTRACT"
"$PKG_ROOT/third_party/rust/bin/rustc" --version
"$PKG_ROOT/third_party/rust/bin/cargo" --version
# Always rebuild orig (vendor + rust toolchain change every run)
cd "$(dirname "$PKG_ROOT")"
ORIG="marqdo_${VER}.orig.tar.xz"
echo "==> packing ${ORIG} (vendor + third_party/rust)"
rm -f "$BUILD_AREA/$ORIG" "marqdo_${VER}.orig.tar.xz"
tar -cJf "$BUILD_AREA/$ORIG" \
--exclude=debian \
-C "$(dirname "$PKG_ROOT")" "$(basename "$PKG_ROOT")"
ln -sfn "$BUILD_AREA/$ORIG" "marqdo_${VER}.orig.tar.xz"
ls -lh "$BUILD_AREA/$ORIG"
ln -sfn "$BUILD_AREA/$ORIG_NAME" "$(dirname "$PKG_ROOT")/$ORIG_NAME"
ls -lh "$BUILD_AREA/$ORIG_NAME"
cd "$PKG_ROOT"
echo "==> debuild -S (key ${GPG_KEY})"
debuild -S -sa -k"${GPG_KEY}" -d
# -sd: debian-only upload (reuse published orig). -sa: include orig (new upstream).
if [ "$REUSE_ORIG" -eq 1 ]; then
DEBUILD_ORIG_FLAG="-sd"
echo "==> debuild -S ${DEBUILD_ORIG_FLAG} (key ${GPG_KEY}; not re-uploading .orig)"
else
DEBUILD_ORIG_FLAG="-sa"
echo "==> debuild -S ${DEBUILD_ORIG_FLAG} (key ${GPG_KEY}; including new .orig)"
fi
debuild -S ${DEBUILD_ORIG_FLAG} -k"${GPG_KEY}" -d
# debuild writes next to package parent (/tmp/marqdo-ppa/); collect into build-area
mkdir -p "$BUILD_AREA"
@@ -146,6 +267,10 @@ shopt -u nullglob
echo "==> artifacts in $BUILD_AREA:"
ls -la "$BUILD_AREA"/marqdo_"${DEB_VER}"* "$BUILD_AREA"/marqdo_"${VER}".orig.tar.* 2>/dev/null || true
if [ "$REUSE_ORIG" -eq 1 ]; then
echo " sha256 of reused orig (must match PPA):"
sha256sum "$BUILD_AREA/$ORIG_NAME"
fi
CHANGES="$BUILD_AREA/marqdo_${DEB_VER}_source.changes"
if [ -f "$CHANGES" ]; then
echo
+26
View File
@@ -0,0 +1,26 @@
---
title: web collab bag smoke
description: route_ws room+presence for collab doc
import web:ext/web/web.mq.md
import json:lib/json.mq.md
import sys:lib/sys.mq.md
---
# main
**首页 = > web.page title="c"**
**应用 = > web.app page=`首页` admin=False**
**应用 = > `应用`.route_ws path="/live/{id}" mode="room" room_key="doc.{id}" presence=True**
**routes = > json.get value=`应用` key="ws_routes"**
**spec = > json.get value=`routes` key="/live/{id}"**
**mode = > json.get value=`spec` key="mode"**
**pr = > json.get value=`spec` key="presence"**
1. `mode` == "room"
1. `pr` == True
> print text=collab-ws-bag-ok
2. *
> print text=presence-fail
> sys.exit code=1
2. *
> print text=mode-fail
> sys.exit code=1
+123
View File
@@ -0,0 +1,123 @@
---
title: web form source live server
description: Request-context field sources — body only; author/slug stamped server-side.
import web:ext/web/web.mq.md
import plugin:lib/plugin.mq.md
import sys:lib/sys.mq.md
---
# main
**p = > plugin.native_path name="web"**
1. `p`
> plugin.load path=`p`
2. *
> sys.exit code=1
`post_schema` =
| 字段 | 类型 | 必填 |
|------|------|------|
| id | integer | false |
| slug | text | true |
| title | text | true |
| content | text | true |
`comment_schema` =
| 字段 | 类型 | 必填 |
|------|------|------|
| id | integer | false |
| post_slug | text | true |
| author | text | true |
| body | text | true |
| created_at | text | false |
**store = > web.db url="sqlite:web-fixtures/data/form-source-live.db"**
> `store`.init name=posts fields=`post_schema`
> `store`.init name=comments fields=`comment_schema`
> `store`.exec sql="DELETE FROM comments"
> `store`.exec sql="DELETE FROM posts"
`seed` =
| slug | title | content |
|------|-------|---------|
| hello | Hello | Body of hello |
> `store`.insert table=posts rows=`seed`
`detail` =
| 属性 | 值 | 样式 |
|------|-----|------|
| title | posts.title | |
| body | posts.content | |
`post_q` =
| 字段 | 操作 | 值 |
|------|------|-----|
| slug | = | {slug} |
`comment_fields` =
| 字段 | 标签 | 类型 | 必填 | 默认 | 来源 |
|------|------|------|------|------|------|
| body | Comment | textarea | true | | client |
| author | | text | true | | session.username |
| post_slug | | text | true | | route.slug |
| created_at | | text | false | | now |
`comment_rules` =
| 字段 | 规则 | 消息 |
|------|------|------|
| body | required | body required |
| author | required | login required |
| post_slug | required | slug required |
**cf = > web.form table="comments" action="insert"**
**cf = > `cf`.fields fields=`comment_fields`**
**cf = > `cf`.rules rules=`comment_rules`**
`comment_cards` =
| 属性 | 值 | 样式 |
|------|-----|------|
| title | comments.author | |
| body | comments.body | |
| meta | comments.created_at | |
`comment_q` =
| 字段 | 操作 | 值 |
|------|------|-----|
| post_slug | = | {slug} |
**post = > web.page title="Post" intro="<section class='post-comments'><h2>Comments</h2><div id='comment-list'></div><div id='comment-form-mount'></div></section>"**
**post = > `post`.compose_main main=`detail`**
**post = > `post`.query query=`post_q`**
**post = > `post`.detail detail=True**
**post = > `post`.compose_list main=`comment_cards` query=`comment_q` order="-created_at" target="#comment-list"**
**post = > `post`.compose_form form=`cf` id="comment" target="#comment-form-mount"**
`users` =
| 行 | 用户 | 密码 |
|----|------|------|
| 1 | alice | secret |
**app = > web.app page=`post` db=`store` port=18117**
**app = > `app`.route path="/post/{slug}" page=`post`**
**app = > `app`.auth users=`users` login_path="/login" login_redirect="/" session_ttl=3600**
**app = > `app`.mount_form id="comment" form=`cf`**
`api` =
| 路径 | 方法 | 表 | 条件 | 排序 | 上限 |
|------|------|----|------|------|------|
| /api/comments | GET | comments | | "-created_at" | 50 |
**app = > `app`.configure json=`api`**
> `app`.listen
+56
View File
@@ -0,0 +1,56 @@
---
title: web RBAC smoke
description: app.rbac flag + gate permissions CSV stored on app bag
import web:ext/web/web.mq.md
import json:lib/json.mq.md
---
# main
> print text=rbac-smoke-start
**首页 = > web.page title="home"**
`用户表` =
| 用户名 | 密码 | 角色 |
|--------|------|------|
| admin | secret | admin |
**应用 = > web.app page=`首页` admin=False**
**应用 = > `应用`.enable_rbac**
**authbag = > json.get value=`应用` key="auth"**
**rbac_on = > json.get value=`authbag` key="rbac"**
1. `rbac_on` == True
> print text=rbac-flag-ok
2. *
> print text=rbac-flag-fail
**应用 = > `应用`.auth users=`用户表` login_path="/login"**
**authbag2 = > json.get value=`应用` key="auth"**
**rbac_kept = > json.get value=`authbag2` key="rbac"**
1. `rbac_kept` == True
> print text=rbac-survives-auth-ok
2. *
> print text=rbac-survives-auth-fail
**应用 = > `应用`.gate path="/desk" permissions="desk:access" match="prefix" on_deny="redirect" exclude="/login"**
**gates = > json.get value=`应用` key="gates"**
**g1 = > at value=`gates` index=1**
**perms = > json.get value=`g1` key="permissions"**
**p0 = > at value=`perms` index=0**
1. `p0` == "desk:access"
> print text=gate-perm-ok
2. *
> print text=gate-perm-fail
**应用2 = > web.app page=`首页` admin=False**
**应用2 = > `应用2`.gate path="/desk/roles" permissions="roles:manage" roles="editor" match="exact"**
**gates2 = > json.get value=`应用2` key="gates"**
**g0 = > at value=`gates2` index=0**
**perms2 = > json.get value=`g0` key="permissions"**
**p1 = > at value=`perms2` index=0**
1. `p1` == "roles:manage"
> print text=gate-roles-manage-ok
2. *
> print text=gate-roles-manage-fail
> print text=rbac-smoke-done
+49
View File
@@ -0,0 +1,49 @@
---
title: web RBAC db register/assign smoke
description: EnsureSchema path via create_role + assign + can
import web:ext/web/web.mq.md
import json:lib/json.mq.md
import sys:lib/sys.mq.md
---
# main
> print text=rbac-db-start
**db = > web.db url="sqlite::memory:"**
**url = > json.get value=`db` key="url"**
**rbac = > web.rbac**
**seed = > `rbac`.create_role url=`db` name="reviewer"**
**ok1 = > json.get value=`seed` key="ok"**
1. `ok1` == True
> print text=create-role-ok
2. *
> print text=create-role-fail
> sys.exit code=1
**setp = > `rbac`.set_role_permissions url=`db` role="reviewer" permissions="comments:create,desk:access"**
**ok2 = > json.get value=`setp` key="ok"**
1. `ok2` == True
> print text=set-perms-ok
2. *
> print text=set-perms-fail
> sys.exit code=1
**can = > `rbac`.can permissions="comments:create,desk:access" needed="desk:access"**
**allowed = > json.get value=`can` key="allowed"**
1. `allowed` == True
> print text=can-ok
2. *
> print text=can-fail
> sys.exit code=1
**deny = > `rbac`.can permissions="comments:create" needed="roles:manage"**
**denied = > json.get value=`deny` key="allowed"**
1. `denied` == False
> print text=can-deny-ok
2. *
> print text=can-deny-fail
> sys.exit code=1
> print text=rbac-db-done
+34
View File
@@ -0,0 +1,34 @@
---
title: browser spa helpers smoke
description: store_set / spa_goto effect bags
import browser:lib/browser.mq.md
import json:lib/json.mq.md
import sys:lib/sys.mq.md
---
# main
**set = > browser.store_set key="k" value="v" scope="memory"**
**op = > json.get value=`set` key="storage"**
**op_name = > json.get value=`op` key="op"**
**scope = > json.get value=`op` key="scope"**
1. `op_name` == "set"
1. `scope` == "memory"
> print text=store-set-ok
2. *
> print text=scope-fail
> sys.exit code=1
2. *
> print text=op-fail
> sys.exit code=1
**nav = > browser.spa_goto url="/item" replace=False**
**n = > json.get value=`nav` key="navigate"**
**url = > json.get value=`n` key="url"**
1. `url` == "/item"
> print text=spa-goto-ok
2. *
> print text=spa-goto-fail
> sys.exit code=1
> print text=spa-helpers-ok
+30
View File
@@ -0,0 +1,30 @@
---
title: web tenant bag smoke
description: app.tenant mode=path stores config
import web:ext/web/web.mq.md
import json:lib/json.mq.md
import sys:lib/sys.mq.md
---
# main
**首页 = > web.page title="t"**
**应用 = > web.app page=`首页` admin=False**
**应用 = > `应用`.tenant mode="path" param="t" column="tenant_id" default_scope=True**
**bag = > json.get value=`应用` key="tenant"**
**mode = > json.get value=`bag` key="mode"**
**param = > json.get value=`bag` key="param"**
**scope = > json.get value=`bag` key="default_scope"**
1. `mode` == "path"
1. `param` == "t"
1. `scope` == True
> print text=tenant-bag-ok
2. *
> print text=scope-fail
> sys.exit code=1
2. *
> print text=param-fail
> sys.exit code=1
2. *
> print text=mode-fail
> sys.exit code=1
+36
View File
@@ -0,0 +1,36 @@
---
title: web WS room + on_message bag smoke
description: route_ws mode=room stores room_key, on_message, presence
import web:ext/web/web.mq.md
import json:lib/json.mq.md
import sys:lib/sys.mq.md
---
# main
**首页 = > web.page title="ws"**
**应用 = > web.app page=`首页` admin=False**
**应用 = > `应用`.route_ws path="/chat/{id}" mode="room" room_key="chat.room.{id}" on_message="chat.persist" presence=True**
**routes = > json.get value=`应用` key="ws_routes"**
**spec = > json.get value=`routes` key="/chat/{id}"**
**mode = > json.get value=`spec` key="mode"**
**rk = > json.get value=`spec` key="room_key"**
**om = > json.get value=`spec` key="on_message"**
**pr = > json.get value=`spec` key="presence"**
1. `mode` == "room"
1. `rk` == "chat.room.{id}"
1. `om` == "chat.persist"
1. `pr` == True
> print text=ws-room-bag-ok
2. *
> print text=presence-fail
> sys.exit code=1
2. *
> print text=on-message-fail
> sys.exit code=1
2. *
> print text=room-key-fail
> sys.exit code=1
2. *
> print text=mode-fail
> sys.exit code=1
+152
View File
@@ -84,6 +84,14 @@ fn ensure_web_plugin_built() {
assert!(lib.is_file(), "missing Go web plugin at {}", lib.display());
// SAFETY: single-threaded Once; children inherit for the rest of the test process.
std::env::set_var("MARQDO_WEB_PLUGIN", &lib);
// Prefer repo `ext/` over a stale `~/.marqdo/ext` so new page methods (e.g. compose_list)
// are visible without requiring `marqdo ext add web` before gold.
if std::env::var_os("MARQDO_EXT").is_none() {
let ext = root.join("ext");
if ext.join("web").join("web.mq.md").is_file() {
std::env::set_var("MARQDO_EXT", &ext);
}
}
});
}
@@ -1784,6 +1792,150 @@ slot-ok",
);
}
#[test]
fn ext_web_form_source_live() {
// Field sources: only body is client-editable; author/slug stamped from session/route.
ensure_web_plugin_built();
let script = "tests/ext/web-form-source-live-server.mq.md";
let bin = env!("CARGO_BIN_EXE_marqdo");
let mut child = Command::new(bin)
.args(["run", script])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.expect("spawn form-source live server");
let base = "http://127.0.0.1:18117";
let ready = std::time::Instant::now();
loop {
if ready.elapsed().as_secs() > 15 {
let _ = child.kill();
panic!("form-source live server did not start in time");
}
let out = Command::new("curl")
.args([
"-s",
"-o",
"/dev/null",
"-w",
"%{http_code}",
&format!("{base}/post/hello"),
])
.output()
.expect("curl probe");
if String::from_utf8_lossy(&out.stdout) == "200" {
break;
}
std::thread::sleep(std::time::Duration::from_millis(300));
}
let page = Command::new("curl")
.args(["-s", &format!("{base}/post/hello")])
.output()
.expect("curl post page");
let html = String::from_utf8_lossy(&page.stdout);
assert!(
html.contains(r#"name="body""#),
"body field missing: {html}"
);
assert!(
!html.contains(r#"name="author""#),
"author must not render (server-only): {html}"
);
assert!(
!html.contains(r#"name="post_slug""#),
"post_slug must not render (server-only): {html}"
);
assert!(
html.contains("_mq_params") && html.contains("hello"),
"expected _mq_params with slug: {html}"
);
let jar = std::env::temp_dir().join("marqdo-form-source-cookies.txt");
let _ = std::fs::remove_file(&jar);
let login = Command::new("curl")
.args([
"-s",
"-c",
jar.to_str().unwrap(),
"-b",
jar.to_str().unwrap(),
"-o",
"/dev/null",
"-w",
"%{http_code}",
"-X",
"POST",
&format!("{base}/login"),
"-d",
"username=alice&password=secret",
])
.output()
.expect("curl login");
let login_code = String::from_utf8_lossy(&login.stdout);
assert!(
login_code == "303" || login_code == "302" || login_code == "200",
"login http_code={login_code}"
);
let post = Command::new("curl")
.args([
"-s",
"-c",
jar.to_str().unwrap(),
"-b",
jar.to_str().unwrap(),
"-o",
"/dev/null",
"-w",
"%{http_code}",
"-X",
"POST",
&format!("{base}/_form/comment"),
"--data-urlencode",
"body=gold comment",
"--data-urlencode",
"author=forged-attacker",
"--data-urlencode",
"post_slug=evil-slug",
"--data-urlencode",
r#"_mq_params={"slug":"hello"}"#,
"--data-urlencode",
"_mq_return=/post/hello",
])
.output()
.expect("curl form post");
let post_code = String::from_utf8_lossy(&post.stdout);
assert!(
post_code == "303" || post_code == "302",
"form post http_code={post_code}"
);
let api = Command::new("curl")
.args(["-s", &format!("{base}/api/comments")])
.output()
.expect("curl comments api");
let body = String::from_utf8_lossy(&api.stdout);
assert!(
body.contains("\"author\":\"alice\"") && body.contains("gold comment"),
"author must be session user, not forged: {body}"
);
assert!(
body.contains("\"post_slug\":\"hello\""),
"post_slug must be route param, not forged: {body}"
);
assert!(
!body.contains("forged-attacker") && !body.contains("evil-slug"),
"forged values must not persist: {body}"
);
let _ = child.kill();
let _ = child.wait();
let _ = std::fs::remove_file(&jar);
}
#[test]
fn ext_web_part_smoke() {
ensure_web_plugin_built();