weifuwu 0.5.1 → 0.7.0

package/dist/messager/client.d.ts

@@ -0,0 +1,2 @@
+import type { MessagerOptions, MessagerModule } from './types.ts';
+export declare function messager(options: MessagerOptions): MessagerModule;

package/dist/messager/index.d.ts

@@ -0,0 +1,2 @@
+export { messager } from './client.ts';
+export type { MessagerOptions, MessagerModule, Channel, ChannelMember, Message } from './types.ts';

package/dist/messager/migrate.d.ts

@@ -0,0 +1,2 @@
+import type { Sql } from 'postgres';
+export declare function migrate(sql: Sql<{}>): Promise<void>;

package/dist/messager/rest.d.ts

@@ -0,0 +1,9 @@
+import type { Sql } from 'postgres';
+import { Router } from '../router.ts';
+import type { AgentModule } from '../agent/types.ts';
+interface RestDeps {
+    sql: Sql<{}>;
+    agents?: AgentModule;
+}
+export declare function buildRouter(deps: RestDeps): Router;
+export {};

package/dist/messager/types.d.ts

@@ -0,0 +1,53 @@
+import type { AgentModule } from '../agent/types.ts';
+export interface MessagerOptions {
+    pg: any;
+    agents?: AgentModule;
+    webhookTimeout?: number;
+}
+export interface Channel {
+    id: number;
+    tenant_id: string | null;
+    name: string;
+    type: 'channel' | 'dm';
+    created_by: number;
+    created_at: string;
+}
+export interface ChannelMember {
+    id: number;
+    channel_id: number;
+    member_id: number;
+    member_type: 'user' | 'agent' | 'webhook';
+    role: 'admin' | 'member';
+    last_read_id: number | null;
+}
+export interface Message {
+    id: number;
+    channel_id: number;
+    sender_id: number;
+    sender_type: 'user' | 'agent' | 'webhook';
+    type: 'text' | 'image' | 'file' | 'system';
+    content: string;
+    file_url: string | null;
+    file_name: string | null;
+    file_size: number | null;
+    mime_type: string | null;
+    created_at: string;
+}
+export interface MessagerModule {
+    migrate: () => Promise<void>;
+    router: () => any;
+    wsHandler: () => any;
+    send: (channelId: number, content: string, opts?: {
+        sender_type?: string;
+        sender_id?: number;
+        type?: string;
+    }) => Promise<Message>;
+    close: () => Promise<void>;
+}
+export interface WSMessage {
+    type: 'message' | 'typing' | 'read';
+    channel_id: number;
+    content?: string;
+    is_typing?: boolean;
+    last_message_id?: number;
+}

package/dist/messager/ws.d.ts

@@ -0,0 +1,9 @@
+import type { Sql } from 'postgres';
+import type { AgentModule } from '../agent/types.ts';
+interface WSDeps {
+    sql: Sql<{}>;
+    agents?: AgentModule;
+}
+export declare function broadcastToChannel(channelId: number, data: any): void;
+export declare function createWSHandler(deps: WSDeps): any;
+export {};

package/dist/queue/index.d.ts

@@ -0,0 +1,2 @@
+import type { Queue, QueueOptions } from './types.ts';
+export declare function queue(opts?: QueueOptions): Queue;

package/dist/queue/types.d.ts

@@ -0,0 +1,32 @@
+import type { Redis } from 'ioredis';
+import type { Context, Handler } from '../types.ts';
+declare module '../types.ts' {
+    interface Context {
+        queue: Queue;
+    }
+}
+export interface QueueJob<T = unknown> {
+    id: string;
+    type: string;
+    payload: T;
+    createdAt: number;
+    runAt: number;
+    schedule?: string;
+}
+export interface QueueOptions {
+    redis?: Redis;
+    url?: string;
+    prefix?: string;
+    pollInterval?: number;
+}
+export interface Queue {
+    (req: Request, ctx: Context, next: Handler): Response | Promise<Response>;
+    add<T>(type: string, payload: T, opts?: {
+        delay?: number;
+        schedule?: string;
+    }): Promise<string>;
+    process<T>(type: string, handler: (job: QueueJob<T>) => Promise<void>): void;
+    run(): Promise<void>;
+    stop(): void;
+    close(): Promise<void>;
+}

package/dist/redis/index.d.ts

@@ -0,0 +1,3 @@
+import type { RedisOptions, RedisClient } from './types.ts';
+export { redis as default };
+export declare function redis(opts?: string | RedisOptions): RedisClient;

package/dist/redis/types.d.ts

@@ -0,0 +1,16 @@
+import type { Redis, RedisOptions as IORedisOptions } from 'ioredis';
+import type { Context, Handler } from '../types.ts';
+declare module '../types.ts' {
+    interface Context {
+        redis: Redis;
+    }
+}
+export type { Redis };
+export type RedisOptions = IORedisOptions & {
+    url?: string;
+};
+export interface RedisClient {
+    (req: Request, ctx: Context, next: Handler): Response | Promise<Response>;
+    redis: Redis;
+    close: () => Promise<void>;
+}

package/dist/tenant/client.d.ts

@@ -0,0 +1,2 @@
+import type { TenantOptions, TenantModule } from './types.ts';
+export declare function tenant(options: TenantOptions): TenantModule;

package/dist/tenant/graphql.d.ts

@@ -0,0 +1,3 @@
+import type { Sql } from 'postgres';
+import { Router } from '../router.ts';
+export declare function buildGraphQLHandler(sql: Sql<{}>): Router;

package/dist/tenant/index.d.ts

@@ -0,0 +1,2 @@
+export { tenant } from './client.ts';
+export type { TenantOptions, TenantModule, TenantContext, FieldDef, FieldType, RelationDef, UserTableRow } from './types.ts';

package/dist/tenant/migrate.d.ts

@@ -0,0 +1,6 @@
+import type { Sql } from 'postgres';
+export interface MigrateOptions {
+    sql: Sql<{}>;
+    usersTable: string;
+}
+export declare function migrate(opts: MigrateOptions): Promise<void>;

package/dist/tenant/rest.d.ts

@@ -0,0 +1,3 @@
+import type { Sql } from 'postgres';
+import { Router } from '../router.ts';
+export declare function buildRouter(sql: Sql<{}>, usersTable: string): Router;

package/dist/tenant/schema.d.ts

@@ -0,0 +1,5 @@
+import type { FieldDef } from './types.ts';
+export declare function createTableSQL(tenantId: string, slug: string, fields: FieldDef[]): string;
+export declare function addColumnSQL(tenantId: string, slug: string, field: FieldDef): string;
+export declare function dropTableSQL(tenantId: string, slug: string): string;
+export declare function createIndexesSQL(tenantId: string, slug: string, fields: FieldDef[]): string[];

package/dist/tenant/types.d.ts

@@ -0,0 +1,47 @@
+import type { Context } from '../types.ts';
+declare module '../types.ts' {
+    interface Context {
+        tenant: TenantContext;
+    }
+}
+export interface TenantContext {
+    id: string;
+    name: string;
+    role: string;
+}
+export type FieldType = 'string' | 'integer' | 'float' | 'boolean' | 'text' | 'datetime' | 'date' | 'enum' | 'json' | 'vector';
+export interface RelationDef {
+    table: string;
+    field?: string;
+    onDelete?: 'cascade' | 'restrict' | 'setnull';
+}
+export interface FieldDef {
+    name: string;
+    type: FieldType;
+    required?: boolean;
+    unique?: boolean;
+    index?: boolean | 'desc' | 'gin' | 'hnsw';
+    default?: unknown;
+    options?: string[];
+    dimensions?: number;
+    relation?: RelationDef;
+}
+export interface UserTableRow {
+    id: number;
+    tenant_id: string;
+    slug: string;
+    label: string;
+    fields: FieldDef[];
+    created_at: string;
+}
+export interface TenantOptions {
+    pg: any;
+    usersTable: string;
+}
+export interface TenantModule {
+    migrate: () => Promise<void>;
+    middleware: () => (req: Request, ctx: Context, next: any) => Promise<Response>;
+    router: () => any;
+    graphql: () => any;
+    close: () => Promise<void>;
+}

package/dist/tenant/utils.d.ts

@@ -0,0 +1,10 @@
+import type { FieldDef } from './types.ts';
+export declare function internalTableName(tenantId: string, slug: string): string;
+export declare function pascalCase(slug: string): string;
+export declare function sqlTypeForField(field: FieldDef): string;
+export declare function validateSlug(slug: string): string | null;
+export declare function validateFieldDefs(fields: FieldDef[]): string[];
+export declare function formatDefault(field: FieldDef): string;
+export declare function mapFieldToZod(field: FieldDef): string;
+export declare function getRelationFields(fields: FieldDef[]): FieldDef[];
+export declare function findRelation(fields: FieldDef[], targetSlug: string): FieldDef | undefined;

package/dist/user/client.d.ts

@@ -0,0 +1,2 @@
+import type { UserOptions, UserModule } from './types.ts';
+export declare function user(options: UserOptions): UserModule;

package/dist/user/index.d.ts

@@ -0,0 +1,2 @@
+export { user } from './client.ts';
+export type { UserOptions, UserData, UserModule, AuthResult, OAuth2Client } from './types.ts';

package/dist/user/migrate.d.ts

@@ -0,0 +1,6 @@
+export interface MigrateOptions {
+    usersTable: string;
+    pg: any;
+    oauth2?: boolean;
+}
+export declare function migrate(opts: MigrateOptions): Promise<void>;

package/dist/user/oauth2.d.ts

@@ -0,0 +1,20 @@
+import type { Context } from '../types.ts';
+import type { OAuth2Client } from './types.ts';
+interface OAuth2Deps {
+    pg: any;
+    usersTable: string;
+    jwtSecret: string;
+    expiresIn: string | number;
+}
+export declare function createOAuth2Server(deps: OAuth2Deps): {
+    authorizeHandler: (req: Request, _ctx: Context) => Promise<Response>;
+    consentHandler: (req: Request) => Promise<Response>;
+    tokenHandler: (req: Request) => Promise<Response>;
+    registerClient: (data: {
+        name: string;
+        redirectUris: string[];
+    }) => Promise<OAuth2Client>;
+    getClient: (clientId: string) => Promise<OAuth2Client | null>;
+    revokeClient: (clientId: string) => Promise<void>;
+};
+export {};

package/dist/user/types.d.ts

@@ -0,0 +1,54 @@
+import type { Middleware } from '../types.ts';
+import type { Router } from '../router.ts';
+export interface UserData {
+    id: number;
+    email: string;
+    name: string;
+    role: string;
+    created_at: Date;
+    updated_at: Date;
+}
+export interface AuthResult {
+    user: Omit<UserData, 'password'>;
+    token: string;
+}
+export interface OAuth2Client {
+    id: number;
+    name: string;
+    clientId: string;
+    clientSecret: string;
+    redirectUris: string[];
+    scopes: string;
+}
+export interface OAuth2ServerOptions {
+    server: true;
+}
+export interface UserOptions {
+    pg: any;
+    jwtSecret: string;
+    table?: string;
+    expiresIn?: string | number;
+    oauth2?: OAuth2ServerOptions;
+}
+export interface UserModule {
+    router: () => Router;
+    middleware: () => Middleware;
+    migrate: () => Promise<void>;
+    register: (data: {
+        email: string;
+        password: string;
+        name: string;
+    }) => Promise<AuthResult>;
+    login: (data: {
+        email: string;
+        password: string;
+    }) => Promise<AuthResult>;
+    verify: (token: string) => Promise<Omit<UserData, 'password'> | null>;
+    registerClient: (data: {
+        name: string;
+        redirectUris: string[];
+    }) => Promise<OAuth2Client>;
+    getClient: (clientId: string) => Promise<OAuth2Client | null>;
+    revokeClient: (clientId: string) => Promise<void>;
+    close: () => Promise<void>;
+}

package/dist/workflow/engine.d.ts

@@ -1,7 +1,7 @@
 import type { Tool, WorkflowEngine, SSEManager } from './types.ts';
 import { type LanguageModel } from 'ai';
 export declare function createWorkflowEngine(options: {
-    tools: Record<string, Tool>;
+    tools: Record<string, Tool<any, any>>;
     sseManager?: SSEManager;
     model?: LanguageModel;
 }): WorkflowEngine;

package/dist/workflow/llm.d.ts

@@ -1,5 +1,5 @@
 import type { Tool, Workflow } from './types.ts';
-export declare function generateWorkflow(goal: string, tools: Record<string, Tool>, generateFn: (prompt: {
+export declare function generateWorkflow(goal: string, tools: Record<string, Tool<any, any>>, generateFn: (prompt: {
     system: string;
     messages: {
         role: string;

package/dist/workflow/route.d.ts

@@ -2,7 +2,7 @@ import { Router } from '../router.ts';
 import type { Tool as WfTool } from './types.ts';
 import type { generateText } from 'ai';
 export interface WorkflowOptions {
-    tools: Record<string, WfTool>;
+    tools: Record<string, WfTool<any, any>>;
     model?: Parameters<typeof generateText>[0]['model'];
     stream?: boolean;
 }

package/dist/workflow/types.d.ts

@@ -63,7 +63,7 @@ export interface WorkflowContext {
     stepCount: number;
     maxSteps: number;
     input: Record<string, unknown>;
-    toolRegistry: Map<string, Tool>;
+    toolRegistry: Map<string, Tool<any, any>>;
     sseManager?: SSEManager;
     workflowId?: string;
     onNodeEvent?: (event: SSEEvent) => void;
@@ -74,7 +74,7 @@ export interface SSEManager {
     close: (workflowId: string) => void;
 }
 export interface EngineOptions {
-    tools: Record<string, Tool>;
+    tools: Record<string, Tool<any, any>>;
     model?: unknown;
     sseManager?: SSEManager;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weifuwu",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "description": "Web-standard HTTP framework for Node.js — (req, ctx) => Response",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -14,15 +14,18 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "esbuild index.ts --bundle --format=esm --platform=node --outfile=dist/index.js --external:react --external:react-dom --external:esbuild --external:graphql --external:ws --external:zod --external:@graphql-tools/schema --external:ai --external:postgres",
+    "build": "esbuild index.ts --bundle --format=esm --platform=node --outfile=dist/index.js --external:react --external:react-dom --external:esbuild --external:graphql --external:ws --external:zod --external:@graphql-tools/schema --external:ai --external:postgres --external:jsonwebtoken",
     "prepublishOnly": "npm run build && tsc --emitDeclarationOnly --outdir dist",
     "test": "node --test 'test/**/*.test.ts'"
   },
   "dependencies": {
+    "@ai-sdk/openai": "^3.0.66",
     "@graphql-tools/schema": "^10",
     "ai": "^6",
     "esbuild": "^0.28.0",
     "graphql": "^16",
+    "ioredis": "^5.11.0",
+    "jsonwebtoken": "^9.0.3",
     "postgres": "^3.4.9",
     "react": "^19",
     "react-dom": "^19",
@@ -32,6 +35,7 @@
   "type": "module",
   "license": "MIT",
   "devDependencies": {
+    "@types/jsonwebtoken": "^9.0.10",
     "@types/react": "^19",
     "@types/react-dom": "^19",
     "@types/ws": "^8.18.1",