weifuwu 0.90.0 → 0.91.0

package/dist/server/messager/index.d.ts

@@ -13,7 +13,7 @@
  */
 import { type Context, type Middleware } from '../types.ts';
 import type { Router } from '../core/router.ts';
-import type { SqlClient } from '../postgres/types.ts';
+import type { Orm } from '../db/orm.ts';
 import type { Redis } from '../db/contracts.ts';
 import type { WebSocketHandler } from '../core/ws.ts';
 export type MessageSenderType = 'user' | 'agent' | 'system';
@@ -98,23 +98,14 @@ export interface MessagerSystem extends Middleware<Context, Context & MessagerIn
     /** 核心服务（测试/服务层直接调用；ctx.msg 同对象） */
     client: MessagerClient;
     /** 幂等建表（conversations + members + messages） */
-    migrate: () => Promise<void>;
     /** HTTP 路由（P3）：/api/messages/* */
     routes: (app: Router<any>, opts?: {
         prefix?: string;
     }) => void;
 }
 export interface MessagerOptions {
-    sql: SqlClient;
-    /**
-     * 连接级事务（传 `pg.transaction` / `pool.begin`）——提供时会话创建原子。
-     * 不传 → 裸执行（回退面：成员 insert 失败时孤儿会话——低影响；并发唯一性由
-     * M9 direct_key 唯一约束兜底）。
-     * M10（2027-XX）：原实现 sql.unsafe('BEGIN'/'COMMIT') 在连接池下断裂——
-     * pool.query 每条 acquire/release 任意连接（BEGIN 在 A、INSERT 在 B、COMMIT 在 C）
-     * ——`pool.begin` 才是连接亲和的正途。
-     */
-    transaction?: <T>(fn: (sql: SqlClient) => Promise<T>) => Promise<T>;
+    /** 声明式 ORM（postgres() 中间件的 .orm——表绑定/校验/事务） */
+    orm: Orm;
     /** Redis（可选：多进程广播/实时推送需要；不传则仅本进程内广播）——
      * 传 `redis().redis`（中间件）或 `new RedisPool()`/`RedisPool.create()` */
     redis?: Redis;
@@ -125,4 +116,134 @@ declare module '../types.ts' {
         msg?: MessagerClient;
     }
 }
+export declare const MESSAGER_TABLES: {
+    readonly conversations: {
+        readonly id: import("../db/shape.ts").WithMeta<import("../../shared/zod.ts").ZodString, {
+            pk: true;
+            default: "random";
+        }>;
+        readonly type: import("../../shared/zod.ts").ZodString;
+        readonly created_by: import("../../shared/zod.ts").ZodNullable<import("../../shared/zod.ts").ZodString>;
+        readonly direct_key: import("../../shared/zod.ts").ZodNullable<import("../../shared/zod.ts").ZodString>;
+        readonly created_at: import("../db/shape.ts").WithMeta<import("../../shared/zod.ts").ZodDate, {
+            default: "now";
+        }>;
+    };
+    readonly members: {
+        readonly conversation_id: import("../db/shape.ts").WithMeta<import("../../shared/zod.ts").ZodString, {
+            notNull: true;
+        }>;
+        readonly user_id: import("../db/shape.ts").WithMeta<import("../../shared/zod.ts").ZodString, {
+            notNull: true;
+        }>;
+        readonly last_read_at: import("../../shared/zod.ts").ZodNullable<import("../../shared/zod.ts").ZodDate>;
+        readonly joined_at: import("../db/shape.ts").WithMeta<import("../../shared/zod.ts").ZodDate, {
+            default: "now";
+        }>;
+    };
+    readonly messages: {
+        readonly id: import("../db/shape.ts").WithMeta<import("../../shared/zod.ts").ZodString, {
+            pk: true;
+            default: "random";
+        }>;
+        readonly conversation_id: import("../db/shape.ts").WithMeta<import("../../shared/zod.ts").ZodString, {
+            notNull: true;
+        }>;
+        readonly sender_type: import("../../shared/zod.ts").ZodString;
+        readonly sender_id: import("../../shared/zod.ts").ZodNullable<import("../../shared/zod.ts").ZodString>;
+        readonly content: import("../db/shape.ts").WithMeta<import("../../shared/zod.ts").ZodString, {
+            notNull: true;
+        }>;
+        readonly msg_type: import("../../shared/zod.ts").ZodString;
+        readonly created_at: import("../db/shape.ts").WithMeta<import("../../shared/zod.ts").ZodDate, {
+            default: "now";
+        }>;
+        readonly edited_at: import("../../shared/zod.ts").ZodNullable<import("../../shared/zod.ts").ZodDate>;
+        readonly deleted_at: import("../../shared/zod.ts").ZodNullable<import("../../shared/zod.ts").ZodDate>;
+    };
+};
 export declare function messager(options: MessagerOptions): MessagerSystem;
+export declare const WEIFUWU_MESSAGER_SCHEMA: {
+    tables: ({
+        name: string;
+        columns: {
+            id: import("../db/shape.ts").WithMeta<import("../../shared/zod.ts").ZodString, {
+                pk: true;
+                default: "random";
+            }>;
+            type: import("../../shared/zod.ts").ZodString;
+            created_by: import("../../shared/zod.ts").ZodString;
+            direct_key: import("../../shared/zod.ts").ZodNullable<import("../../shared/zod.ts").ZodString>;
+            created_at: import("../../shared/zod.ts").ZodDate;
+            conversation_id?: undefined;
+            user_id?: undefined;
+            last_read_at?: undefined;
+            joined_at?: undefined;
+            sender_type?: undefined;
+            sender_id?: undefined;
+            content?: undefined;
+            msg_type?: undefined;
+            edited_at?: undefined;
+            deleted_at?: undefined;
+        };
+        uniques?: undefined;
+        indexes?: undefined;
+    } | {
+        name: string;
+        columns: {
+            conversation_id: import("../db/shape.ts").WithMeta<import("../../shared/zod.ts").ZodString, {
+                notNull: true;
+            }>;
+            user_id: import("../db/shape.ts").WithMeta<import("../../shared/zod.ts").ZodString, {
+                notNull: true;
+            }>;
+            last_read_at: import("../../shared/zod.ts").ZodDate;
+            joined_at: import("../../shared/zod.ts").ZodDate;
+            id?: undefined;
+            type?: undefined;
+            created_by?: undefined;
+            direct_key?: undefined;
+            created_at?: undefined;
+            sender_type?: undefined;
+            sender_id?: undefined;
+            content?: undefined;
+            msg_type?: undefined;
+            edited_at?: undefined;
+            deleted_at?: undefined;
+        };
+        uniques: string[][];
+        indexes?: undefined;
+    } | {
+        name: string;
+        columns: {
+            id: import("../db/shape.ts").WithMeta<import("../../shared/zod.ts").ZodString, {
+                pk: true;
+                default: "random";
+            }>;
+            conversation_id: import("../db/shape.ts").WithMeta<import("../../shared/zod.ts").ZodString, {
+                notNull: true;
+            }>;
+            sender_type: import("../../shared/zod.ts").ZodString;
+            sender_id: import("../../shared/zod.ts").ZodString;
+            content: import("../../shared/zod.ts").ZodString;
+            msg_type: import("../../shared/zod.ts").ZodString;
+            created_at: import("../../shared/zod.ts").ZodDate;
+            edited_at: import("../../shared/zod.ts").ZodDate;
+            deleted_at: import("../../shared/zod.ts").ZodDate;
+            type?: undefined;
+            created_by?: undefined;
+            direct_key?: undefined;
+            user_id?: undefined;
+            last_read_at?: undefined;
+            joined_at?: undefined;
+        };
+        indexes: {
+            cols: (string | {
+                col: string;
+                desc: true;
+            })[];
+            name: string;
+        }[];
+        uniques?: undefined;
+    })[];
+};

package/dist/server/postgres/client.d.ts

@@ -1,12 +1,12 @@
 /**
  * weifuwu/postgres — PostgreSQL 中间件（自研客户端）
  *
- * 注入 ctx.sql（callable tagged template + 方法面）。
+ * 注入 ctx.orm（声明式 ORM——业务唯一数据入口；ctx.sql 已删除）。
  * 零第三方依赖——PG v3 协议自研。
  *
- *   ctx.sql`SELECT * FROM t WHERE id = ${id}`   ← tagged template → 参数化
- *   ctx.sql.unsafe(sql, params?)                 ← 原生 SQL（DDL/动态表名）
- *   ctx.sql.begin(fn)                            ← 事务（postgres.js 兼容）
+ *   ctx.orm.table('users').select().where({...}).run()   ← 表绑定查询
+ *   ctx.orm.query.from(...).join(...)                     ← 跨表查询
+ *   ctx.orm.execute(sql, params?)                         ← 原生逃生舱（DDL/迁移）
  */
 import type { PostgresOptions, PostgresClient } from './types.ts';
 export declare const MIGRATIONS_TABLE = "_weifuwu_migrations";

package/dist/server/postgres/types.d.ts

@@ -1,20 +1,16 @@
 import type { Context, Middleware, Closeable } from '../types.ts';
-import type { Sql } from '../db/contracts.ts';
-declare module '../types.ts' {
-    interface Context {
-        sql: Sql;
-    }
-}
-/** 契约：SQL 标签模板（ctx.sql）——定义于 src/db/contracts.ts（自研引擎实现） */
-export type { Sql };
-/** 旧名兼容（SqlClient → Sql，契约单一来源 db/contracts.ts） */
-export type SqlClient = Sql;
+import type { Orm, OrmTenant, CtxOrm } from '../db/orm.ts';
 export interface PostgresInjected {
-    sql: SqlClient;
+    /** 声明式 ORM（shape+operator+adapter——业务唯一数据入口；ctx.sql 已删除）
+     *  W1：tenant 配置后为 CtxOrm（ctxTable 自动 scope 面）；未配置时 ctxTable
+     *  等价 table（无 scope 语义——类型统一 CtxOrm——诚实标注） */
+    orm: CtxOrm;
 }
 export interface PostgresOptions {
     /** 连接字符串（默认 DATABASE_URL） */
     connection?: string;
+    /** 内存模式（测试——AST 直执行零 wire：不建 PgPool——memorySql 直调） */
+    memory?: boolean;
     /** 池大小（连接数）。默认 10。 */
     max?: number;
     /** 池全忙时 acquire 超时 ms（防饿死）。默认 30_000。0 = 无限。 */
@@ -22,6 +18,9 @@ export interface PostgresOptions {
     /** 语句超时 ms（慢查询保护，会话级 SET statement_timeout）。默认 0 = 禁用。 */
     statementTimeoutMs?: number;
     /** 查询观测钩子（慢查询日志/审计） */
+    /** 租户 scope（W1 接线——中间件注入 ctx.orm = orm.withCtx(ctx)——select/update/delete
+     *  自动预置 tenant 条件 + insert 自动注入字段——平台手写 app_id 过滤收口） */
+    tenant?: OrmTenant;
     /** 查询观测钩子（慢查询日志/审计）；第 4 参数为请求级 traceId（x-trace-id 头，无则 undefined） */
     onQuery?: (query: string, durationMs: number, rowCount: number, traceId?: string) => void;
     /** postgres.js 兼容名（= max） */
@@ -39,14 +38,20 @@ export interface PostgresOptions {
     idle_timeout?: number;
 }
 export interface PostgresClient extends Middleware<Context, Context & PostgresInjected>, Closeable {
-    sql: SqlClient;
+    /** 声明式 ORM（shape+operator+adapter——表绑定/校验/类型收窄/gql） */
+    orm: Orm;
     /** Creates the migration tracking table (_weifuwu_migrations). Called once at startup. */
     migrate: () => Promise<void>;
     /** Record that a module's migration has been applied (idempotent). */
     markMigrated: (moduleName: string) => Promise<void>;
     /** Check whether a module has already been migrated. */
     isMigrated: (moduleName: string) => Promise<boolean>;
-    transaction: <T>(fn: (sql: SqlClient) => Promise<T>, retryOpts?: {
+    /** 迁移面（DDL 唯一入口）：执行 + 记录（已迁移名跳过）。业务查询不 execute——全算子化。 */
+    runMigration: (name: string, sql: string) => Promise<void>;
+    /** 声明式 Schema 迁移（SchemaModule → 生成 DDL → 执行+记录——业务零 SQL 字符串） */
+    migrateModule: (name: string, mod: import('../db/schema.ts').SchemaModule) => Promise<void>;
+    /** ORM 面事务（fn 收 orm——含 orm.query/execute——连接级同连接） */
+    transaction: <T>(fn: (orm: Orm) => Promise<T>, retryOpts?: {
         maxRetries?: number;
     }) => Promise<T>;
     /** Connection pool configuration summary. */
@@ -56,5 +61,20 @@ export interface PostgresClient extends Middleware<Context, Context & PostgresIn
         waiting: number;
         max: number;
     };
+    /** 一致性诊断（W3）：orm 注册表（声明权威）vs information_schema（库实况）——
+     *  表缺失/列缺失 error（必须修）· 类型不匹配 warn（声明/DDL 对齐面·粗粒度
+     *  等价组）· 库多余表/列 warn（残留提示）——零参数（registry 自动枚举——
+     *  惰性注册先用 tables(orm) 先行） */
+    checkConsistency: () => Promise<{
+        ok: boolean;
+        issues: {
+            level: 'error' | 'warn';
+            kind: string;
+            table: string;
+            column?: string;
+            expected?: string;
+            found?: string;
+        }[];
+    }>;
     close: () => Promise<void>;
 }

package/dist/server/redis/types.d.ts

@@ -10,6 +10,8 @@ export type { Redis };
 export type RedisOptions = {
     /** Redis URL（默认 REDIS_URL 环境变量；两者都缺 → 构造抛错，禁止静默回退 localhost） */
     url?: string;
+    /** 内存模式（测试——MemoryRedis 直调零 wire） */
+    memory?: boolean;
     /** 池大小（连接数）。默认 5。 */
     poolSize?: number;
     /** 所有 key 自动加前缀（多应用共享 Redis 时隔离命名空间） */

package/dist/server/response.d.ts

@@ -7,9 +7,9 @@
  * import { ok, created, badRequest, notFound, redirect } from 'weifuwu'
  *
  * app.get('/users/:id', async (req, ctx) => {
- *   const [user] = await ctx.sql`SELECT * FROM users WHERE id = ${ctx.params.id}`
- *   if (!user) return notFound('用户不存在')
- *   return ok(user)
+ *   const user = await ctx.orm.query.from('users').where({ id: { eq: ctx.params.id } }).run()
+ *   if (!user.length) return notFound('用户不存在')
+ *   return ok(user[0])
  * })
  * ```
  */

package/dist/server/types.d.ts

@@ -1,6 +1,3 @@
-import type { Sql } from "./postgres/types.ts";
-export type { Sql };
-export type { SqlClient } from './postgres/types.ts';
 /** Re-export for downstream usage. */
 /** Lightweight WebSocket interface for WS handler types (avoids external dep resolution). */
 export interface WebSocket {
@@ -89,9 +86,9 @@ export declare class HttpError extends Error {
  *
  * const myMw = createMiddleware({
  *   injects: ['myField'],
- *   depends: ['sql'],
+ *   depends: ['orm'],
  *   setup: async (ctx) => {
- *     const result = await ctx.sql`SELECT ...`
+ *     const result = await ctx.orm.query.from('things').where({ kind: { eq: 'x' } }).run()
  *     return { myField: result }
  *   },
  * })

package/dist/server/user/app-auth.d.ts

@@ -0,0 +1,74 @@
+/**
+ * weifuwu/appAuth — 业务侧认证中间件（分离模式：_builtin 控制平面签发 token →
+ * 业务应用独立进程解析——零网络验签·ctx 注入与 userSystem 同语义）
+ *
+ * 与 userSystem 的分工（路由命名空间定案）：
+ *   userSystem = _builtin 侧（控制平面：建库/成员/签发/全量路由）
+ *   appAuth    = 业务应用侧（薄：验签解析 → ctx.session/ctx.user/ctx.appId/ctx.builtin）
+ *
+ * 运行时注入面（类型由应用层标注——平台模式 AppCtx 自包含接口）：
+ *   ctx.user    { id, email?, name? } | null   （token 包内——零查库）
+ *   ctx.session { userId, appId, role } | null  （身份三元组——主面）
+ *   ctx.appId   string                          （便捷面）
+ *   ctx.auth    { requireAuth(), userId, appId, role }（薄方法面）
+ *   ctx.builtin { get/post }                    （机器客户端——appId+appKey 自动带）
+ *
+ * 注：
+ *   - token 由 _builtin 签发（HMAC-SHA256·共享 secret）——验签零网络
+ *   - 角色变更/停用即时性：TTL 后生效（诚实边界——需即时配 verifyToken 在线校验）
+ *   - ctx.user 无查库——业务需要更多面用 ctx.orm 自查（共享 DB 模式）
+ */
+import type { Middleware, Context, User } from '../types.ts';
+/**
+ * AuthInterface 公共面（两实现同构视图）：
+ *   本地 = userSystem().asAppAuth()（查库——角色/账号即时）
+ *   远程 = appAuth()（token 验签快照——TTL 边界）
+ * 业务代码只见 AuthPort（薄面字段——两实现都真）——方法面（AuthApi）为
+ * 控制平面专属（本地超集——远程不存在——分离部署时业务侧不用） */
+/** 当前会话（token 解出的应用态——{ userId, appId, role }·平台账号 token = null） */
+export interface Session {
+    userId: string;
+    appId: string;
+    role: string;
+}
+export interface AuthPort {
+    /** 未登录抛 HttpError(401)；返回当前会话三元组 */
+    requireAuth(): Session;
+    readonly userId: string | undefined;
+    readonly appId: string | undefined;
+    readonly role: string | undefined;
+}
+/** 中间件注入面（本地/远程同构） */
+export interface AuthInjected extends Context {
+    /** 当前用户（token 包内/查库——未登录 = null） */
+    user: User | null;
+    /** 身份三元组（主面） */
+    session: Session | null;
+    /** 便捷面（token 应用态） */
+    appId?: string;
+    /** 公共薄面（方法面=控制平面专属——业务代码勿用） */
+    auth: AuthPort;
+    /** 机器客户端（仅远程实现 appAuth·builtin 配置时） */
+    builtin?: BuiltinClient;
+}
+export interface BuiltinClient {
+    get<T = unknown>(path: string): Promise<T>;
+    post<T = unknown>(path: string, body?: unknown): Promise<T>;
+}
+export interface AppAuthOptions {
+    /** HMAC 共享密钥（与 _builtin 签发面一致） */
+    secret: string;
+    /** 机器通信（可选——不配则无 ctx.builtin） */
+    builtin?: {
+        /** _builtin 控制平面 baseUrl（如 http://localhost:3000） */
+        baseUrl: string;
+        /** 本应用 id（X-Wf-App-Id） */
+        appId: string;
+        /** 本应用 appKey（X-Wf-App-Key） */
+        appKey: string;
+    };
+    /** 在线校验（可选——每次请求回 _builtin 强制校验 token——默认关=纯验签零网络） */
+    verifyToken?: (token: string) => Promise<boolean>;
+}
+/** 业务侧认证中间件工厂（分离模式——解析 _builtin 签发的 token——远程实现） */
+export declare function appAuth(options: AppAuthOptions): Middleware<Context, AuthInjected>;