@lark-apaas/coding-steering 0.1.6-alpha.8 → 0.1.6-alpha.9

package/steering/design-stack/skills/feishu/references/events.md

@@ -1,198 +0,0 @@
-# 事件订阅 (Events)
-
-> 开放平台文档（Markdown 版）：https://open.larkoffice.com/document/server-docs/event-subscription-guide/overview
-
-通过 WebSocket 长连接接收飞书事件推送，无需公网 IP / 域名，无需加解密。
-
-## WebSocket 长连接（推荐）
-
-使用 NestJS `OnModuleInit` 生命周期钩子启动 WebSocket 长连接：
-
-```typescript
-import { Injectable, OnModuleInit } from '@nestjs/common';
-import * as lark from '@larksuiteoapi/node-sdk';
-
-@Injectable()
-export class FeishuEventService implements OnModuleInit {
-  private readonly wsClient: lark.WSClient;
-
-  constructor(private readonly feishuService: FeishuService) {
-    const client = this.feishuService.getClient();
-    this.wsClient = new lark.WSClient({
-      appId: FEISHU_APP_ID,
-      appSecret: FEISHU_APP_SECRET,
-      loggerLevel: lark.LoggerLevel.info,
-    });
-  }
-
-  onModuleInit() {
-    this.wsClient.start({
-      eventDispatcher: new lark.EventDispatcher({}).register({
-        'im.message.receive_v1': async (data) => {
-          // 处理收到的消息事件
-        },
-      }),
-    });
-  }
-}
-```
-
-## 消息卡片回调（card.action.trigger）
-
-用户点击卡片按钮、选择下拉项等交互操作会触发 `card.action.trigger` 回调，通过长连接接收，在 `EventDispatcher.register()` 中注册处理函数即可。
-
-> **前置配置**：开发者后台 → 事件与回调 → 订阅方式 → 选择「**使用长连接接收事件/回调**」（而非 HTTP 回调地址）
-
-```typescript
-import { Injectable, OnModuleInit } from '@nestjs/common';
-import * as lark from '@larksuiteoapi/node-sdk';
-
-@Injectable()
-export class FeishuEventService implements OnModuleInit {
-  private readonly wsClient: lark.WSClient;
-
-  constructor(private readonly feishuService: FeishuService) {
-    this.wsClient = new lark.WSClient({
-      appId: FEISHU_APP_ID,
-      appSecret: FEISHU_APP_SECRET,
-      loggerLevel: lark.LoggerLevel.info,
-    });
-  }
-
-  onModuleInit() {
-    this.wsClient.start({
-      eventDispatcher: new lark.EventDispatcher({}).register({
-        // 普通消息事件
-        'im.message.receive_v1': async (data) => {
-          // 处理收到的消息事件
-        },
-
-        // 消息卡片交互回调
-        'card.action.trigger': async (data) => {
-          const {
-            action,    // 用户触发的交互动作
-            operator,  // 操作者信息
-            context,   // 卡片上下文
-          } = data;
-
-          // action.value      — 交互元素配置的 value（JSON 对象）
-          // action.tag        — 触发的组件类型：'button' | 'select_static' | 'date_picker' 等
-          // action.option     — 下拉选框选中的值（select_static 专用）
-          // action.form_value — 表单容器提交数据（Record<string, string | string[]>）
-          // action.name       — 用户操作的交互组件名称（开发者自定义）
-          // operator.open_id  — 操作者 open_id（直接字段，非嵌套）
-          // operator.user_id  — 操作者 user_id（字符串）
-          // operator.union_id — 操作者 union_id
-          // context.open_message_id   — 卡片消息 ID（可用于 patch 更新）
-          // context.open_chat_id      — 所在会话 ID
-
-          // 返回新卡片内容可直接更新该卡片（返回 undefined 则不更新）
-          // 响应体为 v2 格式：{ toast?, card: { type: 'raw', data: { schema: '2.0', ... } } }
-          if (action.value?.confirm) {
-            return {
-              toast: {
-                type: 'success',
-                content: '操作已完成',
-                i18n: { zh_cn: '操作已完成', en_us: 'Done' },
-              },
-              card: {
-                type: 'raw',
-                data: {
-                  schema: '2.0',
-                  config: { update_multi: true },
-                  header: {
-                    template: 'green',
-                    title: { content: '已确认', tag: 'plain_text' },
-                  },
-                  body: {
-                    direction: 'vertical',
-                    elements: [
-                      { tag: 'markdown', content: '操作已完成 ✅' },
-                    ],
-                  },
-                },
-              },
-            };
-          }
-        },
-      }),
-    });
-  }
-}
-```
-
-### card.action.trigger 事件数据结构
-
-长连接模式下事件为 v2 格式，`EventDispatcher` 解析后将 `header` 和 `event` 字段平铺到 `data` 中：
-
-| 字段 | 类型 | 说明 |
-|------|------|------|
-| `action.value` | `Record<string, any>` | 交互元素配置的 value 数据 |
-| `action.tag` | `string` | 组件类型：`button` / `select_static` / `date_picker` 等 |
-| `action.option` | `string?` | 下拉选框选中项（select_static 触发时有值） |
-| `action.timezone` | `string?` | 时区（日期选择器触发时有值） |
-| `action.form_value` | `Record<string, string \| string[]>?` | 表单容器提交数据（form 组件触发时有值） |
-| `action.name` | `string?` | 用户操作的交互组件名称（开发者在组件上自定义） |
-| `operator.open_id` | `string` | 操作者 open_id（直接字段，非嵌套） |
-| `operator.user_id` | `string?` | 操作者 user_id |
-| `operator.union_id` | `string?` | 操作者 union_id |
-| `operator.tenant_key` | `string?` | 操作者所在租户 key |
-| `context.open_message_id` | `string` | 卡片所在消息 ID |
-| `context.open_chat_id` | `string` | 卡片所在会话 ID |
-| `token` | `string` | 回调 token（验签用，长连接模式无需手动验签） |
-| `host` | `string` | 宿主环境，如 `im_message` |
-
-### card.action.trigger 响应体结构（v2 格式）
-
-处理函数 return 的对象会作为响应体直接更新卡片，必须使用 v2 格式：
-
-```json
-{
-  "toast": {
-    "type": "info",
-    "content": "提示内容",
-    "i18n": { "zh_cn": "提示内容", "en_us": "Message" }
-  },
-  "card": {
-    "type": "raw",
-    "data": {
-      "schema": "2.0",
-      "config": { "update_multi": true },
-      "header": {
-        "title": { "tag": "plain_text", "content": "标题" },
-        "template": "blue"
-      },
-      "body": {
-        "direction": "vertical",
-        "elements": [
-          { "tag": "markdown", "content": "卡片内容" }
-        ]
-      }
-    }
-  }
-}
-```
-
-| 字段 | 必需 | 说明 |
-|------|------|------|
-| `toast` | 否 | 在用户侧显示浮层提示；`type` 可选 `info` / `success` / `error` / `warning` |
-| `card` | 否 | 更新后的卡片内容；不返回则卡片保持不变 |
-| `card.type` | 是 | 固定为 `"raw"` |
-| `card.data.schema` | 是 | 固定为 `"2.0"` |
-| `card.data.body.elements` | 是 | 卡片元素列表（嵌套在 `body` 中，非根级） |
-
-> **与旧版区别**：v1 格式直接在根级放 `elements`；v2 格式必须将元素放在 `card.data.body.elements` 中，且外层需要 `card.type: "raw"` 包装。
-
-### 卡片更新方式对比
-
-| 方式 | 说明 |
-|------|------|
-| 处理函数直接 return 卡片 | 即时更新触发交互的卡片（推荐，3 秒内处理完成） |
-| `client.im.message.patch()` | 异步更新，适合耗时操作（需在另一协程/队列中处理） |
-
-## 当前不支持
-
-以下模式需要飞书通过 HTTP 回调应用服务，当前环境暂不支持：
-
-- Webhook 事件订阅（HTTP 模式）— 使用上方 WebSocket 长连接代替
-- HTTP 模式 CardActionHandler — 使用长连接 `card.action.trigger` 代替（见上方）

package/steering/design-stack/skills/feishu/references/id-convert.md

@@ -1,128 +0,0 @@
-# 妙搭与飞书开放平台 — ID 识别与转换
-
-> 开放平台文档（Markdown 版）：https://open.larkoffice.com/document/uAjLw4CM/ukTMukTMukTM/spark-v1/overview.md
->
-> 飞书用户身份体系官方说明：https://open.larkoffice.com/document/platform-overveiw/basic-concepts/user-identity-introduction/introduction
->
-> **承接 `user-identity` skill 决策树**：如果只需 妙搭 userId → 飞书 user_id（employee_id），在 nestjs-react-fullstack 项目内优先用 `AuthNPaasService`。本文覆盖 `AuthNPaasService` 不支持的场景：需要 `open_id` / `union_id`、或需要任何方向的反查、或不在该模板内的项目。
-
-## ID 识别速查
-
-拿到一个 ID 后，先判断它属于哪个体系：
-
-| ID 来源 | 获取方式 | 格式特征 | 说明 |
-|---------|---------|---------|------|
-| 妙搭 userId | 后端 `req.userContext.userId`、前端 `useCurrentUserProfile().user_id` | 纯数字字符串 | **两者是同一个 ID**（dataloom 底层同源） |
-| 妙搭 tenantId | `req.userContext.tenantId` | 纯数字字符串 | 租户/工作区标识 |
-| 妙搭 appId | `req.userContext.appId` | 纯数字字符串 | 当前应用标识 |
-| 飞书 open_id | 飞书开放平台 API 返回 | `ou_` 开头 | 应用级，同一用户在不同应用中 open_id 不同 |
-| 飞书 union_id | 飞书开放平台 API 返回 | `on_` 开头 | 开发者级，同一开发者下的多个应用中相同 |
-| 飞书 user_id（即 `employee_id`） | 飞书通讯录 API 返回 / `AuthNPaasService` 返回 | 无固定前缀 | 企业级，用户在企业内的身份标识，全企业唯一 |
-
-> 官方定义：`user_id` 也称为 `employee_id`，两者在多数业务场景等价（除飞书招聘）。它**不是**员工工号（`employee_no` 是另一个独立字段）。
->
-> 飞书还有第四种 ID `lark_id`（跨企业全局物理身份），仅用于跨企业场景，应用开发流程中基本不接触，本文不涉及。
-
-## 决策树：我需要转换吗？
-
-```
-拿到的 ID 是什么？
-├─ 妙搭 userId（纯数字）
-│  ├─ nestjs-react-fullstack 项目内要拿飞书 user_id → 用 AuthNPaasService（见 user-identity skill），单向
-│  ├─ 要调飞书开放平台 API 拿 open_id/union_id → 用下方 spark id_convert API
-│  └─ 仅妙搭内部使用 → 直接用，不需要转换
-├─ 飞书 open_id（ou_ 开头）→ 要在妙搭中查用户？
-│  ├─ 是 → 转换为妙搭 userId（用下方 spark id_convert API type 20）
-│  └─ 否（仅飞书 API 使用）→ 直接用
-├─ 飞书 union_id（on_ 开头）→ 要在妙搭中查用户？
-│  ├─ 是 → 转换为妙搭 userId（用下方 spark id_convert API type 21）
-│  └─ 否 → 直接用
-└─ 飞书 user_id（即 employee_id）
-   ├─ 妙搭 userId → 飞书 user_id：nestjs-react-fullstack 项目内用 AuthNPaasService（仅此一种方法）
-   └─ 飞书 user_id → 妙搭 userId：无单步方案，必须两步走（见下方"反向：飞书 user_id → 妙搭 userId"）
-```
-
-### 反向：飞书 user_id → 妙搭 userId（两步走）
-
-`spark id_convert` 不接受 `user_id` 作为输入；`AuthNPaasService` 也没有反向方法。要把飞书 user_id 转回妙搭 userId，必须分两步：
-
-```typescript
-// Step 1: 飞书通讯录 API，用 user_id 查询用户，从响应里读 open_id
-//         需要权限 contact:contact.base:readonly
-const userRes = await client.contact.user.get({
-  path: { user_id: '<飞书 user_id / employee_id>' },
-  params: { user_id_type: 'user_id' },   // ← 告诉接口"我传入的是 user_id 类型"
-});
-if (userRes.code !== 0) throw new Error(`contact.user.get failed: ${userRes.msg}`);
-const openId = userRes.data?.user?.open_id;
-if (!openId) throw new Error('open_id missing in contact.user.get response');
-
-// Step 2: spark id_convert type 20，open_id → 妙搭 userId
-//         需要权限"获取 ID 转换信息"
-type IdConvertResp = { items: { source_id: string; target_id: string }[] };
-const convRes = await client.request<IdConvertResp>({
-  method: 'POST',
-  url: '/open-apis/spark/v1/directory/user/id_convert',
-  data: { id_convert_type: 20, ids: [openId] },
-});
-if (convRes.code !== 0) throw new Error(`id_convert failed: ${convRes.msg}`);
-const miaodaUserId = convRes.data?.items?.[0]?.target_id;
-```
-
-> 批量场景同理：先调通讯录批量接口（`GET /open-apis/contact/v3/users/batch`，参数 `user_ids[]` + `user_id_type=user_id`，可通过 `client.request({ method: 'GET', url: '...', params: {...} })` 直接调）拿一组 `open_id`，再传给 spark id_convert（最多 100 个）。**响应里用 `source_id` 字段匹配回原 user_id**，不要按下标对位，飞书不保证返回顺序与请求一致。
-
-## 转换 API
-
-### 所需权限
-
-| 权限标识 | 说明 |
-|----------|------|
-| `获取 ID 转换信息` | spark 通讯录 ID 转换权限（需在开发者后台申请） |
-
-### 转换类型
-
-| id_convert_type | 方向 |
-|-----------------|------|
-| `10` | 妙搭 userId → 飞书 open_id |
-| `11` | 妙搭 userId → 飞书 union_id |
-| `20` | 飞书 open_id → 妙搭 userId |
-| `21` | 飞书 union_id → 妙搭 userId |
-
-### 调用示例
-
-```typescript
-// 妙搭 userId → 飞书 open_id
-const res = await client.request({
-  method: 'POST',
-  url: '/open-apis/spark/v1/directory/user/id_convert',
-  data: {
-    id_convert_type: 10,
-    ids: ['123456789837364'],  // 妙搭 userId 列表，最多 100 个
-  },
-});
-// res.data.items — [{ source_id: '123456789837364', target_id: 'ou_1234cdjhjfedgfhgdhy3884' }]
-
-// 飞书 open_id → 妙搭 userId
-const res2 = await client.request({
-  method: 'POST',
-  url: '/open-apis/spark/v1/directory/user/id_convert',
-  data: {
-    id_convert_type: 20,
-    ids: ['ou_1234cdjhjfedgfhgdhy3884'],
-  },
-});
-```
-
-> 频率限制 50 次/秒，批量最多 100 个 ID。优先批量调用，避免逐个转换。
-
-## Common Mistakes
-
-| 错误 | 正确做法 |
-|------|----------|
-| 把妙搭 userId 当飞书 open_id 传给飞书 API | 两套体系不互通；nestjs-react-fullstack 项目内用 `AuthNPaasService`，其他场景调 spark `id_convert` |
-| 混淆 `req.userContext.userId` 和 `useCurrentUserProfile().user_id` | 同一个 ID，dataloom 同源，前后端获取方式不同而已 |
-| 把 `employee_id` 当作员工工号 | `employee_id` 等价于 `user_id`，是企业内身份标识；工号是另一个独立字段 `employee_no` |
-| 误以为 `AuthNPaasService` 能反查（飞书 user_id → 妙搭 userId） | 只支持 妙搭 userId → 飞书 user_id 单向；反向需要"通讯录 API user_id → open_id"+"spark id_convert type 20 open_id → 妙搭 userId"两步 |
-| 想用飞书 user_id (employee_id) 直接调 spark `id_convert` 反查妙搭 | spark `id_convert` 只支持 open_id (type 20) / union_id (type 21) 反查，不支持 user_id；走两步方案 |
-| 逐个调用 ID 转换接口 | 一次传入多个 ID（最多 100 个），减少请求次数 |
-| 用 `client.spark.*` 语义化调用 | SDK 无内置 spark 模块，需用 `client.request()` 通用方式 |

package/steering/design-stack/skills/feishu/references/messaging.md

@@ -1,207 +0,0 @@
-# 消息 (Messaging)
-
-> 开放平台文档（Markdown 版）：https://open.larkoffice.com/document/server-docs/im-v1/introduction.md
-
-使用 `@larksuiteoapi/node-sdk` 在 NestJS 中发送和回复飞书消息。
-
-## 所需权限
-
-| 权限标识 | 说明 |
-|----------|------|
-| `im:message:send_as_bot` | 以应用身份发送消息 |
-
-## 发送消息
-
-```typescript
-// 发送文本消息
-const res = await client.im.message.create({
-  params: { receive_id_type: 'chat_id' },
-  data: {
-    receive_id: 'oc_xxx',
-    content: JSON.stringify({ text: '你好，这是一条测试消息' }),
-    msg_type: 'text',
-  },
-});
-if (res.code !== 0) throw new Error(`[${res.code}] ${res.msg}`);
-```
-
-### receive_id_type 与 ID 前缀对应关系
-
-| receive_id_type | ID 前缀 | 说明 |
-|-----------------|---------|------|
-| `chat_id` | `oc_` | 群聊 ID |
-| `open_id` | `ou_` | 用户 open_id |
-| `union_id` | `on_` | 用户 union_id |
-| `user_id` | 无固定前缀 | 用户 user_id |
-| `email` | - | 用户邮箱 |
-
-## 发送富文本消息
-
-```typescript
-await client.im.message.create({
-  params: { receive_id_type: 'chat_id' },
-  data: {
-    receive_id: 'oc_xxx',
-    content: JSON.stringify({
-      zh_cn: {
-        title: '项目更新',
-        content: [
-          [
-            { tag: 'text', text: '版本 2.0 已发布，主要更新：' },
-            { tag: 'a', text: '查看详情', href: 'https://example.com' },
-          ],
-        ],
-      },
-    }),
-    msg_type: 'post',
-  },
-});
-```
-
-## 发送卡片消息
-
-```typescript
-// 方式 1：JSON 卡片
-await client.im.message.create({
-  params: { receive_id_type: 'chat_id' },
-  data: {
-    receive_id: 'oc_xxx',
-    content: JSON.stringify({
-      header: {
-        template: 'blue',
-        title: { content: '卡片标题', tag: 'plain_text' },
-      },
-      elements: [
-        { tag: 'markdown', content: '**进度更新**\n- 前端：80%\n- 后端：60%' },
-        {
-          tag: 'action',
-          actions: [
-            { tag: 'button', text: { tag: 'plain_text', content: '确认' }, type: 'primary' },
-          ],
-        },
-      ],
-    }),
-    msg_type: 'interactive',
-  },
-});
-
-// 方式 2：SDK 内置默认卡片（快速使用）
-await client.im.message.create({
-  params: { receive_id_type: 'chat_id' },
-  data: {
-    receive_id: 'oc_xxx',
-    content: lark.messageCard.defaultCard({ title: '标题', content: '内容' }),
-    msg_type: 'interactive',
-  },
-});
-
-// 方式 3：卡片模板（推荐，在卡片搭建工具中配置后使用 template_id）
-await client.im.message.createByCard({
-  params: { receive_id_type: 'chat_id' },
-  data: {
-    receive_id: 'oc_xxx',
-    template_id: 'your_template_id',
-    template_variable: { title: '标题', content: '正文内容' },
-  },
-});
-```
-
-## 回复消息
-
-```typescript
-await client.im.message.reply({
-  path: { message_id: 'om_xxx' },
-  data: {
-    content: JSON.stringify({ text: '收到，我马上处理' }),
-    msg_type: 'text',
-  },
-});
-```
-
-## 编辑消息（24h 内）
-
-```typescript
-await client.im.message.update({
-  path: { message_id: 'om_xxx' },
-  data: {
-    content: JSON.stringify({ text: '已更新的消息内容' }),
-    msg_type: 'text',
-  },
-});
-```
-
-## 更新卡片消息
-
-```typescript
-await client.im.message.patch({
-  path: { message_id: 'om_xxx' },
-  data: {
-    content: JSON.stringify({
-      elements: [{ tag: 'markdown', content: '已更新的卡片内容' }],
-    }),
-  },
-});
-```
-
-## 消息内容格式
-
-### text（文本）
-
-```json
-{"text": "你好，这是一条消息"}
-```
-
-支持 @ 用户：`{"text": "<at user_id=\"ou_xxx\">张三</at> 请查看"}`
-
-### post（富文本）
-
-```json
-{
-  "zh_cn": {
-    "title": "标题",
-    "content": [
-      [
-        {"tag": "text", "text": "普通文本"},
-        {"tag": "a", "text": "链接文字", "href": "https://example.com"},
-        {"tag": "at", "user_id": "ou_xxx"}
-      ]
-    ]
-  }
-}
-```
-
-### interactive（卡片）
-
-```json
-{
-  "header": {
-    "template": "blue",
-    "title": {"content": "卡片标题", "tag": "plain_text"}
-  },
-  "elements": [
-    {"tag": "markdown", "content": "**标题**\n内容文本"},
-    {
-      "tag": "action",
-      "actions": [
-        {"tag": "button", "text": {"tag": "plain_text", "content": "按钮"}, "type": "primary"}
-      ]
-    }
-  ]
-}
-```
-
-## 使用限制
-
-- 向同一用户发消息限频：**5 QPS**
-- 向同一群组发消息限频：群内机器人共享 **5 QPS**
-- 文本消息最大 **150 KB**
-- 卡片/富文本消息最大 **30 KB**
-
-## Common Mistakes
-
-| 错误 | 正确做法 |
-|------|----------|
-| `content` 传对象 | 必须 `JSON.stringify({text: 'hello'})` |
-| 群聊 ID 用 `open_id` 类型 | `oc_` 开头的是 `chat_id` |
-| 富文本 content 不是二维数组 | `content: [[{tag:'text', text:'...'}]]` 外层是行数组 |
-| 忘记开启机器人能力 | 应用能力 → 添加机器人 |

package/steering/design-stack/skills/feishu/references/oauth.md

@@ -1,164 +0,0 @@
-# OAuth 用户授权
-
-> 开放平台文档（Markdown 版）：https://open.larkoffice.com/document/ukTMukTMukTM/uMTNz4yM1MjLzUzM
-
-默认的 tenant_access_token 以应用身份调用 API。
-部分场景（个人日历、搜索联系人）需要 user_access_token 代表用户操作。
-
-## 授权流程
-
-### 1. 构造 redirect_uri 并重定向用户到授权页面
-
-```typescript
-// 域名和路径根从运行时获取
-const redirectUri = `https://${req.hostname}${process.env.CLIENT_BASE_PATH}/feishu/oauth/callback`;
-const authorizeUrl = `https://open.feishu.cn/open-apis/authen/v1/authorize?app_id=${FEISHU_APP_ID}&redirect_uri=${encodeURIComponent(redirectUri)}&state=${state}`;
-// 返回 302 重定向或将 URL 返回给前端
-```
-
-### 2. 回调中用 code 换取 token
-
-```typescript
-const userId = req.userContext.userId; // 当前登录用户
-await client.userAccessToken.initWithCode({ [userId]: code });
-```
-
-### 3. 获取 token（自动 refresh）
-
-```typescript
-const token = await client.userAccessToken.get(userId);
-```
-
-### 4. 携带 user_access_token 调用 API
-
-```typescript
-await client.calendar.calendarEvent.create(
-  { data: { summary: '我的日程', ... } },
-  lark.withUserAccessToken(token),
-);
-```
-
-## Token 持久化与用户关联
-
-SDK 默认将 token 存在内存，重启后丢失。生产环境需持久化到数据库。
-
-### 建表
-
-```sql
-CREATE TABLE feishu_user_token (
-  user_id           VARCHAR(64) PRIMARY KEY,  -- req.userContext.userId
-  open_id           VARCHAR(64) NOT NULL,     -- 飞书用户标识
-  access_token      TEXT NOT NULL,
-  refresh_token     TEXT NOT NULL,
-  token_expire_at   TIMESTAMPTZ NOT NULL,
-  refresh_expire_at TIMESTAMPTZ NOT NULL,
-  updated_at        TIMESTAMPTZ DEFAULT NOW()
-);
-```
-
-### FeishuOAuthService 示例
-
-回调保存和 token 刷新的完整 NestJS Service 实现：
-
-- `access_token` 有效期 2 小时，`refresh_token` 有效期 30 天
-- 每次 refresh 后，服务端会同时返回**新的 `refresh_token`**（token rotation），必须用新值覆盖旧值，否则下次刷新会失败
-
-```typescript
-import { Injectable, Inject } from '@nestjs/common';
-import { DRIZZLE_DATABASE, type PostgresJsDatabase } from '@lark-apaas/fullstack-nestjs-core';
-import { eq } from 'drizzle-orm';
-import { feishuUserToken } from '@server/database/schema';
-
-@Injectable()
-export class FeishuOAuthService {
-  private readonly EXPIRY_BUFFER_MS = 3 * 60 * 1000; // 预留 3 分钟 buffer
-
-  constructor(
-    private readonly feishuService: FeishuService,
-    @Inject(DRIZZLE_DATABASE) private readonly db: PostgresJsDatabase,
-  ) {}
-
-  /** 回调中用 code 换取 token 并持久化（Step 2 之后调用） */
-  async handleCallback(userId: string, code: string) {
-    const client = this.feishuService.getClient();
-    const tokenRes = await client.authen.oidcAccessToken.create({
-      data: { grant_type: 'authorization_code', code },
-    });
-    if (tokenRes.code !== 0 || !tokenRes.data) {
-      throw new Error(`Feishu OAuth token error [${tokenRes.code}]: ${tokenRes.msg}`);
-    }
-    const { access_token, refresh_token, open_id, expires_in, refresh_expires_in } = tokenRes.data;
-    const now = Date.now();
-    await this.db.insert(feishuUserToken).values({
-      userId,
-      openId: open_id,
-      accessToken: access_token,
-      refreshToken: refresh_token,
-      tokenExpireAt: new Date(now + expires_in * 1000),
-      refreshExpireAt: new Date(now + refresh_expires_in * 1000),
-    }).onConflictDoUpdate({
-      target: feishuUserToken.userId,
-      set: {
-        openId: open_id,
-        accessToken: access_token,
-        refreshToken: refresh_token,
-        tokenExpireAt: new Date(now + expires_in * 1000),
-        refreshExpireAt: new Date(now + refresh_expires_in * 1000),
-      },
-    });
-  }
-
-  /** 获取有效的 user_access_token，自动刷新 */
-  async getValidToken(userId: string): Promise<string> {
-    const [stored] = await this.db
-      .select()
-      .from(feishuUserToken)
-      .where(eq(feishuUserToken.userId, userId));
-    if (!stored) throw new Error('用户未授权飞书，请先完成 OAuth 授权');
-
-    const now = Date.now();
-
-    // 1. access_token 未过期 → 直接返回
-    if (stored.tokenExpireAt.getTime() - now > this.EXPIRY_BUFFER_MS) {
-      return stored.accessToken;
-    }
-
-    // 2. access_token 过期，但 refresh_token 未过期 → 刷新
-    if (stored.refreshExpireAt.getTime() - now > this.EXPIRY_BUFFER_MS) {
-      const client = this.feishuService.getClient();
-      const res = await client.authen.oidcRefreshAccessToken.create({
-        data: { grant_type: 'refresh_token', refresh_token: stored.refreshToken },
-      });
-      if (res.code !== 0 || !res.data) {
-        throw new Error(`Feishu OAuth refresh error [${res.code}]: ${res.msg}`);
-      }
-      const { access_token, refresh_token, expires_in, refresh_expires_in } = res.data;
-
-      // 必须同时更新 access_token 和 refresh_token（token rotation）
-      await this.db.update(feishuUserToken)
-        .set({
-          accessToken: access_token,
-          refreshToken: refresh_token,
-          tokenExpireAt: new Date(now + expires_in * 1000),
-          refreshExpireAt: new Date(now + refresh_expires_in * 1000),
-        })
-        .where(eq(feishuUserToken.userId, userId));
-      return access_token;
-    }
-
-    // 3. refresh_token 也过期 → 需要用户重新授权（回到第 1 步）
-    throw new Error('飞书授权已过期，请重新授权');
-  }
-}
-```
-
-#### 在业务代码中使用
-
-```typescript
-// 在 Controller 或其他 Service 中注入 FeishuOAuthService
-const token = await this.feishuOAuthService.getValidToken(req.userContext.userId);
-await this.feishuService.getClient().calendar.calendarEvent.create(
-  { data: { summary: '我的日程', ... } },
-  lark.withUserAccessToken(token),
-);
-```