weifuwu 0.3.0 → 0.5.0

package/dist/postgres/client.d.ts

@@ -0,0 +1,2 @@
+import type { PostgresOptions, PostgresClient } from './types.ts';
+export declare function postgres(opts?: string | PostgresOptions): PostgresClient;

package/dist/postgres/index.d.ts

@@ -0,0 +1,2 @@
+export { postgres } from './client.ts';
+export type { PostgresOptions, PostgresClient, TableProxy, ListOptions, TableBuilder } from './types.ts';

package/dist/postgres/migrate.d.ts

@@ -0,0 +1,3 @@
+import type { Sql } from 'postgres';
+import type { TableDef } from './types.ts';
+export declare function runMigrations(sql: Sql<{}>, tables: TableDef[]): Promise<void>;

package/dist/postgres/table.d.ts

@@ -0,0 +1,4 @@
+import type { Sql } from 'postgres';
+import { z } from 'zod';
+import type { TableDef, TableProxy } from './types.ts';
+export declare function buildTable(sql: Sql<{}>, tables: TableDef[]): <T extends Record<string, z.ZodTypeAny>>(name: string, schema: T) => TableProxy<z.output<z.ZodObject<T>>, z.input<z.ZodObject<T>>>;

package/dist/postgres/types.d.ts

@@ -0,0 +1,51 @@
+import type { Sql } from 'postgres';
+import type { z } from 'zod';
+import type { Context, Handler } from '../types.ts';
+declare module '../types.ts' {
+    interface Context {
+        sql?: Sql<{}>;
+    }
+}
+export interface PostgresOptions {
+    connection?: string | Record<string, unknown>;
+    signal?: AbortSignal;
+}
+export interface PostgresClient {
+    (req: Request, ctx: Context, next: Handler): Response | Promise<Response>;
+    sql: Sql<{}>;
+    table: TableBuilder;
+    migrate: () => Promise<void>;
+    close: () => Promise<void>;
+}
+export type TableBuilder = <T extends Record<string, z.ZodTypeAny>>(name: string, schema: T, opts?: {
+    primaryKey?: string;
+}) => TableProxy<z.output<z.ZodObject<T>>, z.input<z.ZodObject<T>>>;
+export interface TableProxy<TRow = unknown, TInsert = unknown> {
+    $type: TRow;
+    $insert: TInsert;
+    get: (id: number | string) => Promise<TRow | undefined>;
+    list: (filter?: Record<string, unknown>, opts?: ListOptions) => Promise<{
+        rows: TRow[];
+        count: number;
+    }>;
+    create: (data: TInsert) => Promise<TRow>;
+    patch: (id: number | string, data: Partial<TInsert>) => Promise<TRow | undefined>;
+    remove: (id: number | string) => Promise<boolean>;
+}
+export interface ListOptions {
+    limit?: number;
+    offset?: number;
+    sort?: Record<string, 'asc' | 'desc'>;
+}
+export interface ColumnDef {
+    name: string;
+    sqlType: string;
+    nullable: boolean;
+    isPrimaryKey: boolean;
+    defaultExpr: string | null;
+    autoGenerate: boolean;
+}
+export interface TableDef {
+    name: string;
+    columns: ColumnDef[];
+}

package/dist/router.d.ts

@@ -1,27 +1,13 @@
 import { type WebSocket } from 'ws';
 import type { IncomingMessage } from 'node:http';
 import type { Duplex } from 'node:stream';
-import { type GraphQLSchema } from 'graphql';
-import { streamText } from 'ai';
 import type { Context, Handler, Middleware, ErrorHandler } from './types.ts';
-type StreamTextParams = Parameters<typeof streamText>[0];
 export type WebSocketHandler = {
     open?: (ws: WebSocket, ctx: Context) => void | Promise<void>;
     message?: (ws: WebSocket, ctx: Context, data: string | Buffer) => void | Promise<void>;
     close?: (ws: WebSocket, ctx: Context) => void | Promise<void>;
     error?: (ws: WebSocket, ctx: Context, error: Error) => void | Promise<void>;
 };
-export type AIOptions = Omit<StreamTextParams, 'model'> & {
-    model: string | (() => any);
-};
-export type AIHandler = (req: Request, ctx: Context) => AIOptions | Promise<AIOptions>;
-export type GraphQLOptions = {
-    schema: string | GraphQLSchema;
-    rootValue?: any;
-    resolvers?: any;
-    context?: (req: Request, ctx: Context) => Record<string, any> | Promise<Record<string, any>>;
-    graphiql?: boolean;
-};
 type WsUpgradeHandler = (req: IncomingMessage, socket: Duplex, head: Buffer) => void;
 export declare class Router {
     private root;
@@ -42,8 +28,6 @@ export declare class Router {
     onError(handler: ErrorHandler): this;
     route(method: string, path: string, ...args: [...Middleware[], Handler]): this;
     ws(path: string, ...args: [...Middleware[], WebSocketHandler]): this;
-    graphql(path: string, ...args: [...Middleware[], GraphQLOptions]): this;
-    ai(path: string, ...args: [...Middleware[], AIHandler]): this;
     handler(): Handler;
     websocketHandler(): WsUpgradeHandler;
     private splitPath;

package/dist/workflow/engine.d.ts

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

package/dist/workflow/index.d.ts

@@ -0,0 +1,8 @@
+export { tool } from './tool.ts';
+export { createWorkflowEngine } from './engine.ts';
+export { createSSEManager } from './sse.ts';
+export { resolveRef, resolveValue } from './reference.ts';
+export { generateWorkflow } from './llm.ts';
+export { workflow } from './route.ts';
+export type { WorkflowOptions, WorkflowHandler } from './route.ts';
+export type { Tool, ToolContext, Workflow, Node, WorkflowState, SSEEvent, SSEManager, WorkflowEngine, ExecuteOptions, StreamEvent, Condition, SubWorkflow } from './types.ts';

package/dist/workflow/llm.d.ts

@@ -0,0 +1,10 @@
+import type { Tool, Workflow } from './types.ts';
+export declare function generateWorkflow(goal: string, tools: Record<string, Tool>, generateFn: (prompt: {
+    system: string;
+    messages: {
+        role: string;
+        content: string;
+    }[];
+}) => Promise<{
+    text: string;
+}>): Promise<Workflow>;

package/dist/workflow/nodes.d.ts

@@ -0,0 +1,10 @@
+import type { Node, WorkflowContext } from './types.ts';
+export type NodeExecutor = (node: Node, ctx: WorkflowContext) => Promise<unknown>;
+export declare function executeEval(node: Node, ctx: WorkflowContext): Promise<unknown>;
+export declare function executeSet(node: Node, ctx: WorkflowContext): Promise<unknown>;
+export declare function executeGet(node: Node, ctx: WorkflowContext): Promise<unknown>;
+export declare function executeIf(node: Node, ctx: WorkflowContext): Promise<unknown>;
+export declare function executeWhile(node: Node, ctx: WorkflowContext): Promise<unknown>;
+export declare function executeCall(node: Node, ctx: WorkflowContext): Promise<unknown>;
+export declare function executeHttp(node: Node, ctx: WorkflowContext): Promise<unknown>;
+export declare function executeNode(node: Node, ctx: WorkflowContext): Promise<unknown>;

package/dist/workflow/reference.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowContext } from './types.ts';
+export declare function resolveRef(path: string, ctx: WorkflowContext): unknown;
+export declare function resolveValue(v: unknown, ctx: WorkflowContext): unknown;

package/dist/workflow/route.d.ts

@@ -0,0 +1,11 @@
+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>;
+    model?: Parameters<typeof generateText>[0]['model'];
+    stream?: boolean;
+}
+export type WorkflowHandler = (req: Request, ctx: Context) => WorkflowOptions | Promise<WorkflowOptions>;
+import type { Context } from '../types.ts';
+export declare function workflow(handler: WorkflowHandler): Router;

package/dist/workflow/sse.d.ts

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

package/dist/workflow/tool.d.ts

@@ -0,0 +1,8 @@
+import type { z } from 'zod';
+import type { Tool, ToolContext } from './types.ts';
+export declare function tool<TInput = unknown, TOutput = unknown>(def: {
+    name?: string;
+    description: string;
+    inputSchema: z.ZodSchema<TInput>;
+    execute: (input: TInput, ctx: ToolContext) => Promise<TOutput>;
+}): Tool<TInput, TOutput>;

package/dist/workflow/types.d.ts

@@ -0,0 +1,86 @@
+import type { z } from 'zod';
+export type NodeType = 'eval' | 'set' | 'get' | 'if' | 'while' | 'call' | 'http';
+export interface Tool<TInput = unknown, TOutput = unknown> {
+    name: string;
+    description: string;
+    inputSchema: z.ZodSchema<TInput>;
+    execute: (input: TInput, ctx: ToolContext) => Promise<TOutput>;
+}
+export interface ToolContext {
+    workflowId?: string;
+    nodeId: string;
+    onStream?: (event: StreamEvent) => Promise<void>;
+}
+export interface StreamEvent {
+    type: string;
+    chunk?: string;
+    accumulated?: string;
+    [key: string]: unknown;
+}
+export interface Node {
+    id: string;
+    tool: NodeType | string;
+    input: Record<string, unknown>;
+    conditions?: Condition[];
+    body?: Node[];
+}
+export interface Condition {
+    test: string | boolean;
+    body: Node[];
+}
+export interface Workflow {
+    name?: string;
+    nodes: Node[];
+    functions?: Record<string, SubWorkflow>;
+}
+export interface SubWorkflow {
+    inputSchema: Record<string, unknown>;
+    workflow: {
+        nodes: Node[];
+    };
+}
+export interface WorkflowState {
+    workflowId: string;
+    status: 'running' | 'completed' | 'error';
+    goal: string;
+    result?: unknown;
+    error?: string;
+    startTime: number;
+    endTime?: number;
+}
+export interface SSEEvent {
+    event: string;
+    data: unknown;
+}
+export interface ExecuteOptions {
+    initialInput?: Record<string, unknown>;
+    maxSteps?: number;
+}
+export interface WorkflowContext {
+    variables: Map<string, unknown>;
+    nodeOutputs: Map<string, unknown>;
+    functions: Record<string, SubWorkflow>;
+    stepCount: number;
+    maxSteps: number;
+    input: Record<string, unknown>;
+    toolRegistry: Map<string, Tool>;
+    sseManager?: SSEManager;
+    workflowId?: string;
+    onNodeEvent?: (event: SSEEvent) => void;
+}
+export interface SSEManager {
+    createStream: (workflowId: string) => ReadableStream<Uint8Array>;
+    send: (workflowId: string, event: SSEEvent) => void;
+    close: (workflowId: string) => void;
+}
+export interface EngineOptions {
+    tools: Record<string, Tool>;
+    model?: unknown;
+    sseManager?: SSEManager;
+}
+export interface WorkflowEngine {
+    execute: (workflow: Workflow, options?: ExecuteOptions) => Promise<unknown>;
+    getState: (workflowId: string) => WorkflowState | undefined;
+    runAsync: (workflowId: string, workflow: Workflow, options?: ExecuteOptions) => Promise<void>;
+    generateWorkflow: (goal: string) => Promise<Workflow>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weifuwu",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Web-standard HTTP framework for Node.js — (req, ctx) => Response",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -14,7 +14,7 @@
     "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",
+    "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",
     "prepublishOnly": "npm run build && tsc --emitDeclarationOnly --outdir dist",
     "test": "node --test 'test/**/*.test.ts'"
   },
@@ -23,6 +23,7 @@
     "ai": "^6",
     "esbuild": "^0.28.0",
     "graphql": "^16",
+    "postgres": "^3.4.9",
     "react": "^19",
     "react-dom": "^19",
     "ws": "^8",