weifuwu 0.90.0 → 0.91.0

package/dist/server/db/typed-query.d.ts

@@ -0,0 +1,113 @@
+/**
+ * typedQuery——跨表查询的类型完整体（W3）
+ *
+ * 问题（P4 根因）：
+ *   `orm.query.from('kb_chunks kc').join(...).select(...).run()` —— query
+ *   builder 泛型面未绑定 shape——行类型恒为 `Row`（{ [col]: unknown }）——
+ *   消费端被迫 `as unknown as X / as Array<Record<string, any>>`（平台 35 处）。
+ *
+ * 方案（纯类型面——运行时零成本）：
+ *   `createTypedQuery(orm, schema)`——schema 为「表名 → shape」注册表。
+ *   from/join 的 spec（`'kb_chunks kc'`）在类型层解析表/alias——select 的
+ *   列引用（`'kc.id'`/裸列=主表）解析为对应列 Infer——行类型 = tuple
+ *   保序映射 + aggregate/vectorScore 的 AS 键并入——未知列/未知 alias
+ *   编译期红（never）。运行时 = SelectBuilder 链转发（零解析——纯转发）。
+ *
+ * 判负（诚实裁剪）：
+ *   - `col AS alias` 不做（平台 0 消费——aggregate/vectorScore 的 as
+ *     参数面已覆盖键别名场景——可被新增论证推翻）
+ *   - where 值类型×列绑定不做（z.enum 坍缩 [string]——值面收益低——已登记
+ *     W2/W3 修复面：enum 签名推断增强）
+ *   - and/or 组合内层键不校验（外键校验已覆盖主要场景——组合式文档注明）
+ */
+import type { ZodRawShape, ZodType } from '../../shared/zod.ts';
+import type { Orm } from './orm.ts';
+import type { WhereExpr, WhereField } from './query.ts';
+/** schema 注册表（表名 → shape） */
+export type TypedSchema = Record<string, ZodRawShape>;
+type OutOf<Z> = Z extends ZodType<infer O> ? O : never;
+/** from/join spec 解析：'kb_chunks kc' → { table: 'kb_chunks'; alias: 'kc' } */
+type Split<F extends string> = F extends `${infer T} ${infer A}` ? {
+    table: T;
+    alias: A;
+} : {
+    table: F;
+    alias: F;
+};
+/** alias → 表名注册表（from 主表 + join 累积） */
+type AddAlias<Reg extends Record<string, string>, F extends string> = Reg & {
+    [K in Split<F>['alias']]: Split<F>['table'];
+};
+/** 列引用校验/解析：`'kc.id'` → kc 表 id 列的 Out；裸列 → 主表 */
+type ColOut<Sch, Reg, Main, C extends string> = C extends `${infer A}.${infer Col}` ? A extends keyof Reg ? Reg[A] extends keyof Sch ? Col extends keyof Sch[Reg[A] & keyof Sch] ? OutOf<Sch[Reg[A] & keyof Sch][Col & keyof Sch[Reg[A] & keyof Sch]]> : never : never : never : C extends keyof Sch[Main & keyof Sch] ? OutOf<Sch[Main & keyof Sch][C & keyof Sch[Main & keyof Sch]]> : never;
+/** select 列 → 行类型（对象键 = 列名去 alias 前缀——`kc.id` → `id`；同名键后覆盖） */
+export type SelRow<Sch, Reg, Main, C extends readonly unknown[]> = {
+    [K in Extract<C[number], string> as K extends `${string}.${infer Col}` ? Col : K]: ColOut<Sch, Reg, Main, K>;
+};
+/** where 键白名单（合法列引用联合） */
+type ColRefs<Sch, Reg, Main> = keyof Sch[Main & keyof Sch] | {
+    [A in keyof Reg]: A extends string ? (Reg[A] extends keyof Sch ? `${A & string}.${keyof Sch[Reg[A] & keyof Sch] & string}` : never) : never;
+}[keyof Reg];
+/** 值面列型绑定（W4——W1 登记失效断言复活）：string 列（含 enum 字面量）按列型收紧
+ *  （eq:'robot' 红——enum 外拒绝）；jsonb/unknown 列保留 WhereField 宽面（深度等值兼容） */
+type WhereFieldOf<V> = V extends string ? {
+    col?: string;
+    eq?: V;
+    gt?: V;
+    gte?: V;
+    lt?: V;
+    lte?: V;
+    ne?: V;
+    in?: V[];
+    notIn?: V[];
+    like?: string;
+    ilike?: string;
+    isNull?: boolean;
+    between?: [V, V];
+} : WhereField;
+/** where 约束（对象键 ∈ 合法列引用——字面量多余键红；值面 WhereField 保留组合式） */
+export type TWhere<Sch, Reg, Main> = {
+    [K in ColRefs<Sch, Reg, Main> as K & string]?: WhereFieldOf<ColOut<Sch, Reg, Main, K & string>> | WhereExpr[];
+};
+/** aggregate AS 键并入行 */
+type WithAgg<Row extends object, As extends string, V> = Row & {
+    [K in As]: V;
+};
+/** 查询入口（from 后状态） */
+export interface TypedQuery<Sch extends TypedSchema> {
+    from<F extends string>(spec: F): TSelect<Sch, AddAlias<{}, F>, Split<F>['table'], {}>;
+}
+/** 类型化 Select 链（Row 为累积行类型——select/aggregate 并入） */
+export interface TSelect<Sch, Reg extends Record<string, string>, Main, Row extends object = {}> {
+    join<F extends string>(spec: F, on: WhereExpr): TSelect<Sch, AddAlias<Reg, F>, Split<F>['table'] extends Main ? Main : Main, Row>;
+    select<C extends readonly (ColRefs<Sch, Reg, Main>)[]>(...cols: C): TSelect<Sch, Reg, Main, Row & SelRow<Sch, Reg, Main, C>>;
+    where<W extends TWhere<Sch, Reg, Main>>(w: W): this;
+    groupBy(...cols: string[]): this;
+    having<W extends TWhere<Sch, Reg, Main>>(w: W): this;
+    count<As extends string>(col: '*', as: As, filter?: WhereExpr): TSelect<Sch, Reg, Main, WithAgg<Row, As, number>>;
+    sum<As extends string>(col: string, as: As, filter?: WhereExpr): TSelect<Sch, Reg, Main, WithAgg<Row, As, number>>;
+    avg<As extends string>(col: string, as: As, filter?: WhereExpr): TSelect<Sch, Reg, Main, WithAgg<Row, As, number>>;
+    min<As extends string>(col: string, as: As, filter?: WhereExpr): TSelect<Sch, Reg, Main, WithAgg<Row, As, number>>;
+    max<As extends string>(col: string, as: As, filter?: WhereExpr): TSelect<Sch, Reg, Main, WithAgg<Row, As, number>>;
+    vectorScore<As extends string>(col: string, vec: number[], as: As): TSelect<Sch, Reg, Main, WithAgg<Row, As, number>>;
+    orderBy(col: string, dir?: 'asc' | 'desc'): this;
+    limit(n: number): this;
+    offset(n: number): this;
+    distinct(): this;
+    run(): Promise<Row[]>;
+    one(): Promise<Row | undefined>;
+}
+/**
+ * createTypedQuery——orm.query 的类型化入口（schema 仅类型锚点——运行时零成本）
+ *
+ * @example
+ * const q = createTypedQuery(orm, { kb_chunks, kb_documents })
+ * const rows = await q.from('kb_chunks kc')
+ *   .join('kb_documents kd', { 'kd.id': { col: 'kc.document_id' } })
+ *   .select('kc.id', 'kc.content', 'kd.filename')
+ *   .where({ 'kc.agent_id': { eq: String(agentId) } })
+ *   .run()
+ * // rows[0].id: string · rows[0].filename: string | null · rows[0].nope: 编译期红
+ */
+export declare function createTypedQuery<Sch extends TypedSchema>(orm: Orm, _schema: Sch): TypedQuery<Sch>;
+export {};

package/dist/server/email/api.d.ts

@@ -0,0 +1,15 @@
+import type { EmailMessage, EmailResult } from './contracts.ts';
+export interface EmailApiOptions {
+    /** 默认 EMAIL_API_KEY（兼容回退 RESEND_API_KEY）——构造时无 key 明确 throw */
+    apiKey?: string;
+    /** 默认 EMAIL_API_URL（兼容回退 RESEND_API_URL）→ 'https://api.resend.com' */
+    baseUrl?: string;
+    /** HTTP 超时 ms——默认 10_000（上游挂起 → 502——不无限挂） */
+    timeoutMs?: number;
+    /** 默认发件人 */
+    from: string;
+}
+export interface EmailApiClient {
+    send(msg: EmailMessage): Promise<EmailResult>;
+}
+export declare function createEmailApi(opts: EmailApiOptions): EmailApiClient;

package/dist/server/email/contracts.d.ts

@@ -24,9 +24,14 @@ export interface EmailResult {
     accepted: boolean;
 }
 /**
- * 邮件客户端（ctx.email）：统一 send 接口，适配器抽象底层服务商。
- * 适配器在中间件构造时解析（配置错误尽早暴露）——resend / smtp / 自定义函数。
+ * 邮件接口（ctx.email）：统一 send 接口——适配器抽象底层服务商。
+ * 适配器在中间件构造时解析（配置错误尽早暴露）——API / 自定义函数。
  */
-export interface Mailer {
+export interface EmailInterface {
     send(msg: EmailMessage): Promise<EmailResult>;
 }
+/** 兼容别名（= EmailInterface——对齐 Ai/AIInterface 命名） */
+export type Mailer = EmailInterface;
+/** 统一校验层（所有实现共享——API/MemoryEmail 同一语义）：
+ *  to 必填非空（零收件人发送=语义错误）；From/To CRLF 注入拒绝（header 注入） */
+export declare function validateMessage(msg: EmailMessage): void;

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

@@ -1,26 +1,16 @@
 /**
- * weifuwu/email — 邮件发送中间件
- *
- * 注入 ctx.email.send —— 统一发送接口，适配器抽象底层服务商。
+ * weifuwu/email — 邮件发送中间件（模块：app.use 注入 ctx.email + send 直接可用）
  *
+ * 发送通道 = **HTTP API（Resend 兼容端点——POST /emails）——不再直连 SMTP**。
  * 适配器：
- *   - 'resend'（默认推荐）：一个 POST，独立开发者首选
- *   - 'smtp'：自研 SMTP 客户端（node:net + node:tls，零依赖），任意服务商/自建 Postfix
+ *   - 默认 'api'：createEmailApi（apiKey/baseUrl——EMAIL_API_KEY/EMAIL_API_URL env）
  *   - 自定义函数：`adapter: async (msg) => ...` 一行接入任意服务商
- *
- * 裁剪声明：
- *   ✅ 统一 send 接口 / text + html / 多收件人 / 自定义适配器
- *   ❌ 附件（SMTP MIME multipart 未实现）、退信/送达率（服务商职责）、
- *      批量营销、隐式入队（文档给"发邮件 = ctx.queue.add"示例）
+ *   - MemoryEmail / MemoryEmailServer：测试/离线（主包导出——同 ai 模块模式）
  *
  * ```ts
  * import { email } from 'weifuwu'
  *
- * app.use(email({
- *   from: 'no-reply@your.app',
- *   adapter: 'resend',            // 或 'smtp'
- *   resend: { apiKey: process.env.RESEND_API_KEY },
- * }))
+ * app.use(email({ from: 'no-reply@your.app' }))   // read EMAIL_API_KEY/EMAIL_API_URL
  *
  * app.post('/api/notify', async (req, ctx) => {
  *   await ctx.email.send({ to: 'user@x.com', subject: '通知', html: '<h1>hi</h1>' })
@@ -29,33 +19,36 @@
  * ```
  */
 import type { Context, Middleware } from '../types.ts';
-import { type SmtpConfig } from './smtp.ts';
-import type { Mailer, EmailMessage, EmailResult } from './contracts.ts';
-/** 契约（src/email/contracts.ts 单一来源）：ctx.email 类型 = Mailer */
-export type { Mailer, EmailMessage, EmailResult };
+import { type EmailInterface, type EmailMessage, type EmailResult } from './contracts.ts';
+/** 契约（contracts.ts 单一来源） */
+export type { EmailInterface, Mailer, EmailMessage, EmailResult } from './contracts.ts';
+export { validateMessage } from './contracts.ts';
+export { createEmailApi, type EmailApiClient, type EmailApiOptions } from './api.ts';
+export { MemoryEmail, createMemoryEmail, type MemoryEmailOptions } from './memory-email.ts';
+export { MemoryEmailServer, createMemoryEmailServer, type MemoryEmailServerHandle, type MemoryEmailServerOptions } from './memory-email-server.ts';
 /** 适配器：输入已标准化的邮件消息，输出结果。 */
 export type EmailAdapter = (msg: EmailMessage) => Promise<EmailResult>;
 export interface EmailOptions {
     /** 默认发件人 */
     from: string;
-    adapter?: 'resend' | 'smtp' | EmailAdapter;
-    resend?: {
-        apiKey?: string;
-        /** 测试可注入 mock 地址 */
-        baseUrl?: string;
-    };
-    smtp?: SmtpConfig;
-    /** E3：resend 适配器 HTTP 超时 ms（SMTP 用 smtp.timeoutMs——默认 30s）。默认 10_000 */
+    /** API 发送 key（默认 EMAIL_API_KEY——兼容回退 RESEND_API_KEY） */
+    apiKey?: string;
+    /** API 发送端点（默认 EMAIL_API_URL——兼容回退 RESEND_API_URL → 'https://api.resend.com'） */
+    baseUrl?: string;
+    /** HTTP 超时 ms。默认 10_000 */
     timeoutMs?: number;
+    /** 自定义适配器函数（完全替换 API 路径——如 no-op） */
+    adapter?: EmailAdapter;
 }
 export interface EmailInjected {
-    email: Mailer;
+    email: EmailInterface;
 }
 declare module '../types.ts' {
     interface Context {
-        email?: Mailer;
+        email?: EmailInterface;
     }
 }
-export interface EmailClient extends Middleware<Context, Context & EmailInjected> {
+/** 模块 = 中间件（ctx.email）+ send 直接可用（worker/测试场景） */
+export interface EmailClient extends Middleware<Context, Context & EmailInjected>, EmailInterface {
 }
 export declare function email(options: EmailOptions): EmailClient;

package/dist/server/email/memory-email-server.d.ts

@@ -0,0 +1,43 @@
+import { type MemoryEmailOptions } from './memory-email.ts';
+import type { EmailMessage } from './contracts.ts';
+export interface MemoryEmailServerOptions extends MemoryEmailOptions {
+    port?: number;
+    /** 请求级注入（测试对 HTTP 面全控——替代自建 mock）：
+     *  undefined = 走默认 handler（记录 + onSend 注入）
+     *  { status, body } = 故障注入（4xx/5xx）
+     *  { hang } = 挂起（超时测试） */
+    respond?: (req: MemoryEmailRequest) => MemoryEmailRespond | undefined;
+}
+/** 已接收请求（断言传输细节——路径/认证/体） */
+export interface MemoryEmailRequest {
+    method: string;
+    path: string;
+    headers: Record<string, string>;
+    body: Record<string, unknown>;
+}
+/** 注入响应描述 */
+export type MemoryEmailRespond = {
+    status: number;
+    body?: unknown;
+} | {
+    hang: true;
+};
+/** 正名构造（new MemoryEmailServer() / MemoryEmailServer() / createMemoryEmailServer() 等价） */
+export interface MemoryEmailServer {
+    new (options?: MemoryEmailServerOptions): Promise<MemoryEmailServerHandle>;
+}
+export interface MemoryEmailServerHandle {
+    port: number;
+    /** 完整 base URL（http://127.0.0.1:{port}——给 EMAIL_API_URL 指向） */
+    url: string;
+    /** 收件箱（GET /emails 同步返回——测试断言用） */
+    emails: EmailMessage[];
+    /** 已接收请求记录（断言用——含 respond 注入的请求） */
+    requests: MemoryEmailRequest[];
+    /** 强制断开所有连接（hang 场景清理） */
+    closeAllConnections(): void;
+    close(): Promise<void>;
+}
+/** 工厂（= MemoryEmailServer 正名——createMemoryEmailServer 兼容别名） */
+export declare const createMemoryEmailServer: typeof MemoryEmailServer;
+export declare function MemoryEmailServer(options?: MemoryEmailServerOptions): Promise<MemoryEmailServerHandle>;

package/dist/server/email/memory-email.d.ts

@@ -0,0 +1,30 @@
+/**
+ * weifuwu/email — MemoryEmail（内存实现——参考 MemoryAi）
+ *
+ * 契约直实现 EmailClient（中间件 + send 直接可用）——确定性：
+ *   - onSend 决策注入（测试对发送行为全控——同 MemoryAi.onChat）
+ *   - 默认（无注入）：记录到 sent + accepted（不编造上游行为——id 为 memory-mail-N）
+ *   - 复用统一校验层（validateMessage——to 必填/CRLF 注入拒绝——与 API 路径一致）
+ *
+ * 用途：测试（断言 sent 记录）/ 离线 dev / 无上游 key 环境。
+ * 真实发送由 API provider（api.ts——HTTP 端点——不直连 SMTP）承担。
+ */
+import type { Context, Middleware } from '../types.ts';
+import { type EmailInterface, type EmailMessage, type EmailResult } from './contracts.ts';
+export interface MemoryEmailOptions {
+    /** 决策注入（默认未注入：记录 + accepted——确定性） */
+    onSend?: (msg: EmailMessage) => EmailResult | Promise<EmailResult>;
+}
+export interface MemoryEmail extends Middleware<Context, Context & {
+    email: EmailInterface;
+}>, EmailInterface {
+    /** 已发送记录（默认路径——断言用） */
+    sent: EmailMessage[];
+}
+export interface MemoryEmail {
+    new (options?: MemoryEmailOptions): MemoryEmail;
+}
+/** 模块构造（new MemoryEmail() / MemoryEmail() / createMemoryEmail() 等价） */
+export declare function MemoryEmail(options?: MemoryEmailOptions): MemoryEmail;
+/** 工厂别名（= MemoryEmail——与 createMemorySql/createMemoryAi 命名对称） */
+export declare const createMemoryEmail: typeof MemoryEmail;

package/dist/server/index.d.ts

@@ -17,21 +17,39 @@ export { rateLimit } from './middleware/rate-limit.ts';
 export type { RateLimitOptions, RateLimitInjected, RateLimitAlgorithm } from './middleware/rate-limit.ts';
 export { email } from './email/index.ts';
 export type { EmailOptions, EmailMessage, EmailResult, EmailAdapter, EmailInjected } from './email/index.ts';
-export type { Mailer } from './email/contracts.ts';
-export { sendSmtp } from './email/smtp.ts';
-export type { SmtpConfig } from './email/smtp.ts';
-export { userSystem } from './user/index.ts';
+export type { Mailer, EmailInterface } from './email/contracts.ts';
+export { MemoryEmail, createMemoryEmail, MemoryEmailServer, createMemoryEmailServer } from './email/index.ts';
+export { userSystem, BUILTIN_APP_ID, WEIFUWU_USER_SCHEMA } from './user/index.ts';
+export { appAuth } from './user/app-auth.ts';
+export { z, type Infer, type ZodType, type ZodRawShape } from '../shared/zod.ts';
+export { shape, f, type Shape, type FieldDbMeta, type BodyOf, type PatchOf } from './db/shape.ts';
+export { bodyOf, type BodyOfOptions } from './db/body.ts';
+export { listQuery, errorResponse, type ListQueryOptions } from './db/http.ts';
+export { diffConsistency, normalizeType, type ConsistencyIssue, type DeclaredTable, type LiveTable } from './db/consistency.ts';
+export { compileSchemaDDL, compileSchemaDdl, ddlToSql, type SchemaModule, type TableDecl, type IndexDecl, type EnumDecl } from './db/schema.ts';
+export { createOrm, memoryAdapter, postgresAdapter, type Orm, type CtxOrm, type OrmTable, type RowOf, type OrmTenant, type DbAdapter } from './db/orm.ts';
+export { eq, ne, gt, gte, lt, lte, inArray, notInArray, between, like, ilike, contains, startsWith, endsWith, eqCol, isNull, isNotNull, and, or, not, cols, type ColRef, type ShapeCols } from './db/ops.ts';
+export { createTypedQuery, type TypedQuery, type TSelect, type TypedSchema, type SelRow, type TWhere } from './db/typed-query.ts';
+export type { WhereExpr, Query } from './db/query.ts';
+export { buildQuery, createQueryBuilder } from './db/query-builder.ts';
+export * as ops from './db/ops.ts';
 export { hashPassword, verifyPassword } from './user/password.ts';
 export { signToken, verifyToken, generateRefreshToken } from './user/token.ts';
-export { messager } from './messager/index.ts';
+export { messager, WEIFUWU_MESSAGER_SCHEMA } from './messager/index.ts';
 export type { UserSystemOptions, UserInjected, AuthApi, RegisterInput } from './user/index.ts';
 export type { MessagerOptions, MessagerInjected, MessagerClient, MessagerSystem, MessagerHandlerOptions, Message, Conversation } from './messager/index.ts';
+export { workflowSystem, WEIFUWU_WORKFLOW_SCHEMA } from './workflows/index.ts';
+export type { WorkflowSystem, WorkflowSystemOptions, WorkflowClient, WorkflowCrud, WorkflowRecord, WorkflowRunRecord, CompileGateInput } from './workflows/index.ts';
 export { queue } from './queue/index.ts';
 export { scheduler } from './scheduler/index.ts';
 export type { QueueOptions, QueueClient, QueueInjected, QueueWorker, WorkerOptions, AddOptions, Job } from './queue/index.ts';
-export { ai } from './ai/index.ts';
-export type { Ai, ApprovalRequest } from './ai/contracts.ts';
-export type { AiOptions, AiInjected, AiClient, AiClientModule, ChatResponse, AgentConfig, AgentTool, AgentRunner, ToolContext, AgentRunResult, AgentStep, WfEmitter, } from './ai/index.ts';
+export { OpenAi, MemoryAi, createMemoryAi } from './ai/index.ts';
+export type { Ai, AIInterface, ApprovalRequest, ImageGenRequest, ImageGenResult, VideoGenRequest, VideoGenStatus } from './ai/contracts.ts';
+export type { ImageGenOptions, VideoGenOptions, ImageGenClient, VideoGenClient } from './ai/multimodal.ts';
+export type { MemoryAiOptions, OpenAiOptions, AiClientModule, AiInjected } from './ai/index.ts';
+export { MemoryAiServer, createMemoryAiServer } from './ai/memory-server.ts';
+export type { MemoryAiServerOptions, MemoryAiServerHandle } from './ai/memory-server.ts';
+export type { AiClient, ChatResponse, AgentConfig, AgentTool, AgentRunner, ToolContext, AgentRunResult, AgentStep, WfEmitter, } from './ai/index.ts';
 export type { WfStreamEvent, WfMessageStart, WfToken, WfUsage, WfDone, WfError, WfErrorCode, WfToolCall, WfToolResult, WfToolProgress, WfStep, WfApprovalRequest, WfApprovalResponse, WfApprovalDecision, ChatMessage, ChatParams, MessageRole, ToolCall, ToolDefinition, } from './ai/types.ts';
 export { ui } from './ui/index.ts';
 export type { GraphQLOptions, GraphQLHandler } from './graphql.ts';
@@ -39,8 +57,13 @@ export { postgres, MIGRATIONS_TABLE } from './postgres/index.ts';
 export type { PostgresOptions, PostgresClient, PostgresInjected } from './postgres/types.ts';
 export { redis } from './redis/index.ts';
 export type { RedisOptions, RedisClient, RedisInjected } from './redis/types.ts';
-export type { Sql, Redis, PoolConnection, PostgresPoolConnection, RedisPoolConnection } from './db/contracts.ts';
+export type { Redis, PoolConnection, PostgresPoolConnection, RedisPoolConnection } from './db/contracts.ts';
 export { MemoryRedis } from './db/memory-redis.ts';
-export { MemorySql, createMemorySql } from './db/memory-sql.ts';
+export { MemorySql, createMemoryOrm } from './db/memory-sql.ts';
+export { MemoryRedisServer } from './db/redis-server.ts';
+export { workflow } from './workflow/index.ts';
+export type { WorkflowEngine, WorkflowOptions } from './workflow/index.ts';
+export type { WorkflowDef, StepDef, StepHandler, StepEnv, RunResult, ExecuteOptions, WorkflowCtx, StepOutput, RunStatus } from './workflow/contracts.ts';
+export type { KVStore } from './workflow/store.ts';
 export { ok, created, noContent, badRequest, unauthorized, forbidden, notFound, conflict, unprocessable, tooManyRequests, serverError, redirect } from './response.ts';
 export { parseBody } from './request.ts';