@spfn/core 0.2.0-beta.2 → 0.2.0-beta.21

package/dist/{types-DRG2XMTR.d.ts → types-7Mhoxnnt.d.ts}

@@ -2,24 +2,112 @@ import { TSchema, Static } from '@sinclair/typebox';
 import { ErrorRegistry, ErrorRegistryInput } from '@spfn/core/errors';
 import { RouteDef, RouteInput } from '@spfn/core/route';
 
+/**
+ * Convert File types in schema to actual File for client usage
+ *
+ * TypeBox File schemas become actual File objects on the client side.
+ */
+type ConvertFileTypes<T> = T extends File ? File : T extends File[] ? File[] : T;
+/**
+ * Extract form data input type with File support
+ *
+ * Maps schema types to runtime types, converting FileSchema to File.
+ */
+type FormDataInput<T> = {
+    [K in keyof T]: ConvertFileTypes<T[K]>;
+};
 /**
  * Extract structured input from RouteInput
+ *
+ * Converts TypeBox schemas to their static types for each input field.
  */
 type StructuredInput<TInput extends RouteInput> = {
     params: TInput['params'] extends TSchema ? Static<TInput['params']> : {};
     query: TInput['query'] extends TSchema ? Static<TInput['query']> : {};
     body: TInput['body'] extends TSchema ? Static<TInput['body']> : {};
+    formData: TInput['formData'] extends TSchema ? FormDataInput<Static<TInput['formData']>> : {};
     headers: TInput['headers'] extends TSchema ? Static<TInput['headers']> : {};
     cookies: TInput['cookies'] extends TSchema ? Static<TInput['cookies']> : {};
 };
 /**
- * Infer route input type
+ * Infer route input type from RouteDef
+ *
+ * @example
+ * ```typescript
+ * // Server route definition
+ * const getUser = route.get('/users/:id')
+ *   .input({ params: Type.Object({ id: Type.String() }) })
+ *   .handler(...);
+ *
+ * // Client: extract input type
+ * type Input = InferRouteInput<typeof getUser>;
+ * // { params: { id: string }, query: {}, body: {}, ... }
+ * ```
  */
 type InferRouteInput<TRoute> = TRoute extends RouteDef<infer TInput, any, any> ? StructuredInput<TInput> : never;
 /**
- * Infer route output type
+ * Infer route output type from RouteDef
+ *
+ * @example
+ * ```typescript
+ * // Server route definition
+ * const getUser = route.get('/users/:id')
+ *   .handler(async (c) => {
+ *     return { id: '1', name: 'John' };
+ *   });
+ *
+ * // Client: extract output type
+ * type Output = InferRouteOutput<typeof getUser>;
+ * // { id: string, name: string }
+ * ```
  */
 type InferRouteOutput<TRoute> = TRoute extends RouteDef<any, any, infer TResponse> ? TResponse : never;
+/**
+ * Extract routes from Router type
+ * Router<TRoutes> has routes in `_routes` property
+ */
+type ExtractRoutes<TRouter> = TRouter extends {
+    _routes: infer TRoutes;
+} ? TRoutes : TRouter;
+/**
+ * Extract output type for a specific route from router
+ *
+ * @example
+ * ```typescript
+ * import type { RouterOutput } from '@spfn/core/nextjs';
+ * import type { AppRouter } from '@/server/router';
+ *
+ * // Get output type for a specific route
+ * type ListData = RouterOutput<AppRouter, 'listExamples'>;
+ *
+ * // Use in props
+ * interface Props {
+ *     data: RouterOutput<AppRouter, 'listExamples'>;
+ * }
+ *
+ * // Extract item type from paginated response
+ * type Example = RouterOutput<AppRouter, 'listExamples'>['items'][number];
+ * ```
+ */
+type RouterOutput<TRouter, K extends keyof ExtractRoutes<TRouter>> = InferRouteOutput<ExtractRoutes<TRouter>[K]>;
+/**
+ * Extract input type for a specific route from router
+ *
+ * @example
+ * ```typescript
+ * import type { RouterInput } from '@spfn/core/nextjs';
+ * import type { AppRouter } from '@/server/router';
+ *
+ * // Get input type for a specific route
+ * type CreateInput = RouterInput<AppRouter, 'createExample'>;
+ *
+ * // Use in function parameter
+ * function submitForm(data: RouterInput<AppRouter, 'createExample'>['body']) {
+ *     // ...
+ * }
+ * ```
+ */
+type RouterInput<TRouter, K extends keyof ExtractRoutes<TRouter>> = InferRouteInput<ExtractRoutes<TRouter>[K]>;
 /**
  * Cookie options for setCookie
  */
@@ -71,7 +159,7 @@ interface ApiConfig {
     /**
      * Request timeout in milliseconds
      *
-     * @default 30000
+     * @default env.SERVER_TIMEOUT (120000)
      */
     timeout?: number;
     /**
@@ -114,6 +202,11 @@ interface ApiConfig {
  * Per-call options
  */
 interface CallOptions {
+    /**
+     * Request timeout in milliseconds
+     * Overrides the global timeout set in ApiConfig
+     */
+    timeout?: number;
     /**
      * Additional headers for this request
      */
@@ -154,4 +247,4 @@ interface CallOptions {
     };
 }
 
-export type { ApiConfig as A, CallOptions as C, InferRouteInput as I, RequestInterceptor as R, SetCookie as S, ResponseInterceptor as a, InferRouteOutput as b };
+export type { ApiConfig as A, CallOptions as C, InferRouteInput as I, RequestInterceptor as R, StructuredInput as S, ResponseInterceptor as a, InferRouteOutput as b, RouterInput as c, RouterOutput as d, CookieOptions as e, SetCookie as f };

package/dist/types-DHQMQlcb.d.ts

@@ -0,0 +1,305 @@
+import { Context } from 'hono';
+import { E as EventRouterDef, I as InferEventNames, b as InferEventPayload } from './router-Di7ENoah.js';
+
+/**
+ * SSE Token Manager
+ *
+ * Auth-agnostic token issuance and verification for SSE connections.
+ * Issues one-time-use tokens with TTL for Token Exchange pattern.
+ *
+ * @example
+ * ```typescript
+ * const manager = new SSETokenManager({ ttl: 30000 });
+ *
+ * // Issue token for authenticated user
+ * const token = await manager.issue('user-123');
+ *
+ * // Verify and consume token (one-time use)
+ * const subject = await manager.verify(token); // 'user-123'
+ * const again = await manager.verify(token);   // null (already consumed)
+ *
+ * // Cleanup on shutdown
+ * manager.destroy();
+ * ```
+ */
+/**
+ * Stored SSE token data
+ */
+interface SSEToken {
+    token: string;
+    subject: string;
+    expiresAt: number;
+}
+/**
+ * Token storage interface
+ *
+ * Implement this for custom storage backends (e.g., Redis for multi-instance).
+ */
+interface SSETokenStore {
+    /** Store a token */
+    set(token: string, data: SSEToken): Promise<void>;
+    /** Get and delete a token (one-time use) */
+    consume(token: string): Promise<SSEToken | null>;
+    /** Remove expired tokens */
+    cleanup(): Promise<void>;
+}
+/**
+ * SSETokenManager configuration
+ */
+interface SSETokenManagerConfig {
+    /**
+     * Token time-to-live in milliseconds
+     * @default 30000
+     */
+    ttl?: number;
+    /**
+     * Custom token store (default: in-memory Map)
+     */
+    store?: SSETokenStore;
+    /**
+     * Cleanup interval in milliseconds
+     * @default 60000
+     */
+    cleanupInterval?: number;
+}
+declare class SSETokenManager {
+    private store;
+    private ttl;
+    private cleanupTimer;
+    constructor(config?: SSETokenManagerConfig);
+    /**
+     * Issue a new one-time-use token for the given subject
+     */
+    issue(subject: string): Promise<string>;
+    /**
+     * Verify and consume a token
+     * @returns subject string if valid, null if invalid/expired/already consumed
+     */
+    verify(token: string): Promise<string | null>;
+    /**
+     * Cleanup timer and resources
+     */
+    destroy(): void;
+}
+
+/**
+ * SSE Types
+ *
+ * Type definitions for Server-Sent Events
+ */
+
+/**
+ * SSE message sent from server
+ */
+interface SSEMessage<TEvent extends string = string, TPayload = unknown> {
+    /** Event name */
+    event: TEvent;
+    /** Event payload */
+    data: TPayload;
+    /** Optional message ID for reconnection */
+    id?: string;
+}
+/**
+ * SSE auth configuration (internal, non-generic)
+ *
+ * Stored in SSEHandlerConfig. Generic user-facing version is SSEAuthConfig.
+ */
+interface SSEHandlerAuthConfig {
+    /**
+     * Enable SSE token authentication
+     * @default false
+     */
+    enabled?: boolean;
+    /**
+     * Token TTL in milliseconds
+     * @default 30000
+     */
+    tokenTtl?: number;
+    /**
+     * Custom token store (e.g., Redis for multi-instance)
+     */
+    store?: SSETokenStore;
+    /**
+     * Extract subject (user ID) from Hono context
+     * @default (c) => c.get('auth')?.userId ?? null
+     */
+    getSubject?: (c: Context) => string | null;
+    /**
+     * Subscription authorization hook (called once on connect)
+     *
+     * Return allowed events subset. Empty array = 403 rejection.
+     */
+    authorize?: (subject: string, events: string[]) => Promise<string[]> | string[];
+    /**
+     * Per-event payload filter map (called on every event emission)
+     *
+     * Return false to skip sending the event to this user.
+     */
+    filter?: Record<string, (subject: string, payload: unknown) => boolean>;
+}
+/**
+ * SSE auth configuration (user-facing, generic)
+ *
+ * Provides type-safe event names and payload inference from EventRouter.
+ *
+ * @example
+ * ```typescript
+ * .events(eventRouter, {
+ *     auth: {
+ *         enabled: true,
+ *         authorize: async (subject, events) => {
+ *             // events: ('userCreated' | 'orderUpdated')[]
+ *             return events.filter(e => hasPermission(subject, e));
+ *         },
+ *         filter: {
+ *             orderUpdated: (subject, payload) => {
+ *                 // payload: { orderId: string; userId: string }
+ *                 return payload.userId === subject;
+ *             },
+ *         },
+ *     },
+ * })
+ * ```
+ */
+interface SSEAuthConfig<TRouter extends EventRouterDef<any>> {
+    enabled?: boolean;
+    tokenTtl?: number;
+    store?: SSETokenStore;
+    getSubject?: (c: Context) => string | null;
+    authorize?: (subject: string, events: InferEventNames<TRouter>[]) => Promise<InferEventNames<TRouter>[]> | InferEventNames<TRouter>[];
+    filter?: {
+        [K in InferEventNames<TRouter>]?: (subject: string, payload: InferEventPayload<TRouter, K>) => boolean;
+    };
+}
+/**
+ * SSE Handler configuration
+ */
+interface SSEHandlerConfig {
+    /**
+     * Keep-alive ping interval in milliseconds
+     * @default 30000
+     */
+    pingInterval?: number;
+    /**
+     * Custom headers for SSE response
+     */
+    headers?: Record<string, string>;
+    /**
+     * Authentication and authorization configuration
+     */
+    auth?: SSEHandlerAuthConfig;
+}
+/**
+ * SSE Client configuration
+ */
+interface SSEClientConfig {
+    /**
+     * Backend API host URL
+     * @default NEXT_PUBLIC_SPFN_API_URL || 'http://localhost:8790'
+     * @example 'http://localhost:8790'
+     * @example 'https://api.example.com'
+     */
+    host?: string;
+    /**
+     * SSE endpoint pathname
+     * @default '/events/stream'
+     */
+    pathname?: string;
+    /**
+     * Full URL (overrides host + pathname)
+     * @deprecated Use host and pathname instead
+     * @example 'http://localhost:8790/events/stream'
+     */
+    url?: string;
+    /**
+     * Auto reconnect on disconnect
+     * @default true
+     */
+    reconnect?: boolean;
+    /**
+     * Reconnect delay in milliseconds
+     * @default 3000
+     */
+    reconnectDelay?: number;
+    /**
+     * Maximum reconnect attempts (0 = infinite)
+     * @default 0
+     */
+    maxReconnectAttempts?: number;
+    /**
+     * Include credentials (cookies) in request
+     * @default false
+     */
+    withCredentials?: boolean;
+    /**
+     * Acquire a one-time SSE token before connecting.
+     *
+     * Called on every (re)connect. The returned token is appended
+     * to the SSE URL as `?token=...`.
+     *
+     * For automatic token acquisition via RPC proxy, use `createAuthSSEClient` instead.
+     *
+     * @example
+     * ```typescript
+     * // Recommended: use createAuthSSEClient for automatic token handling
+     * import { createAuthSSEClient } from '@spfn/core/event/sse/client';
+     * const client = createAuthSSEClient<EventRouter>();
+     *
+     * // Manual: provide acquireToken directly
+     * acquireToken: async () => {
+     *     const res = await fetch('/api/rpc/eventsToken', {
+     *         method: 'POST',
+     *         credentials: 'include',
+     *     });
+     *     const data = await res.json();
+     *     return data.token;
+     * }
+     * ```
+     */
+    acquireToken?: () => Promise<string>;
+}
+/**
+ * Event handler function
+ */
+type SSEEventHandler<TPayload> = (payload: TPayload) => void;
+/**
+ * Event handlers map for EventRouter
+ */
+type SSEEventHandlers<TRouter extends EventRouterDef<any>> = {
+    [K in InferEventNames<TRouter>]?: SSEEventHandler<InferEventPayload<TRouter, K>>;
+};
+/**
+ * Subscription options
+ */
+interface SSESubscribeOptions<TRouter extends EventRouterDef<any>> {
+    /**
+     * Events to subscribe
+     */
+    events: InferEventNames<TRouter>[];
+    /**
+     * Event handlers
+     */
+    handlers: SSEEventHandlers<TRouter>;
+    /**
+     * Called when connection opens
+     */
+    onOpen?: () => void;
+    /**
+     * Called on connection error
+     */
+    onError?: (error: Event) => void;
+    /**
+     * Called when reconnecting
+     */
+    onReconnect?: (attempt: number) => void;
+}
+/**
+ * SSE connection state
+ */
+type SSEConnectionState = 'connecting' | 'open' | 'closed' | 'error';
+/**
+ * Unsubscribe function
+ */
+type SSEUnsubscribe = () => void;
+
+export { type SSEHandlerConfig as S, type SSEAuthConfig as a, SSETokenManager as b, type SSEToken as c, type SSETokenStore as d, type SSETokenManagerConfig as e, type SSEMessage as f, type SSEHandlerAuthConfig as g, type SSEClientConfig as h, type SSEEventHandler as i, type SSEEventHandlers as j, type SSESubscribeOptions as k, type SSEConnectionState as l, type SSEUnsubscribe as m };

package/docs/cache.md

@@ -0,0 +1,133 @@
+# Cache
+
+Redis caching with type-safe operations.
+
+## Setup
+
+```bash
+REDIS_URL=redis://localhost:6379
+```
+
+## Basic Usage
+
+```typescript
+import { cache } from '@spfn/core/cache';
+
+// Set
+await cache.set('user:123', { id: '123', name: 'John' });
+await cache.set('session:abc', data, { ttl: 3600 });  // 1 hour
+
+// Get
+const user = await cache.get<User>('user:123');
+
+// Delete
+await cache.del('user:123');
+
+// Check existence
+const exists = await cache.exists('user:123');
+```
+
+## TTL Options
+
+```typescript
+// Set with TTL (seconds)
+await cache.set('key', value, { ttl: 60 });      // 1 minute
+await cache.set('key', value, { ttl: 3600 });    // 1 hour
+await cache.set('key', value, { ttl: 86400 });   // 1 day
+
+// No expiration
+await cache.set('key', value);  // Permanent until deleted
+```
+
+## Patterns
+
+### Cache-Aside
+
+```typescript
+async function getUser(id: string): Promise<User>
+{
+    const cached = await cache.get<User>(`user:${id}`);
+    if (cached)
+    {
+        return cached;
+    }
+
+    const user = await userRepo.findById(id);
+    if (user)
+    {
+        await cache.set(`user:${id}`, user, { ttl: 3600 });
+    }
+
+    return user;
+}
+```
+
+### Cache Invalidation
+
+```typescript
+async function updateUser(id: string, data: Partial<User>)
+{
+    const user = await userRepo.update(id, data);
+    await cache.del(`user:${id}`);  // Invalidate cache
+    return user;
+}
+```
+
+### Cache with Prefix
+
+```typescript
+const userCache = cache.prefix('user');
+
+await userCache.set('123', user);     // Key: user:123
+await userCache.get('123');
+await userCache.del('123');
+```
+
+## Hash Operations
+
+```typescript
+// Set hash field
+await cache.hset('user:123', 'name', 'John');
+
+// Get hash field
+const name = await cache.hget('user:123', 'name');
+
+// Get all hash fields
+const user = await cache.hgetall('user:123');
+
+// Delete hash field
+await cache.hdel('user:123', 'name');
+```
+
+## List Operations
+
+```typescript
+// Push to list
+await cache.lpush('queue', item);
+await cache.rpush('queue', item);
+
+// Pop from list
+const item = await cache.lpop('queue');
+const item = await cache.rpop('queue');
+
+// Get list range
+const items = await cache.lrange('queue', 0, -1);  // All items
+```
+
+## Best Practices
+
+```typescript
+// 1. Use consistent key naming
+`user:${id}`
+`session:${token}`
+`cache:posts:${page}`
+
+// 2. Set appropriate TTL
+{ ttl: 300 }    // 5 min for frequently changing data
+{ ttl: 3600 }   // 1 hour for stable data
+{ ttl: 86400 }  // 1 day for rarely changing data
+
+// 3. Invalidate on write
+await userRepo.update(id, data);
+await cache.del(`user:${id}`);
+```

package/docs/codegen.md

@@ -0,0 +1,74 @@
+# Codegen
+
+Automatic API client generation from route definitions.
+
+## Setup
+
+### Configure Generator
+
+```typescript
+// codegen.config.ts
+import { defineCodegenConfig } from '@spfn/core/codegen';
+
+export default defineCodegenConfig({
+    generators: [
+        {
+            name: 'api-client',
+            output: './src/client/api.ts',
+            router: './src/server/server.config.ts'
+        }
+    ]
+});
+```
+
+## Generate Client
+
+```bash
+# Generate once
+pnpm spfn codegen run
+
+# Watch mode (dev server includes this)
+pnpm spfn:dev
+```
+
+## Generated Client
+
+```typescript
+// src/client/api.ts (generated)
+import { createApi } from '@spfn/core/nextjs';
+import type { AppRouter } from '@/server/server.config';
+
+export const api = createApi<AppRouter>();
+```
+
+## Usage
+
+```typescript
+import { api } from '@/client/api';
+
+// Type-safe API calls
+const user = await api.getUser.call({
+    params: { id: '123' }
+});
+
+const users = await api.getUsers.call({
+    query: { page: 1, limit: 20 }
+});
+
+const created = await api.createUser.call({
+    body: { email: 'user@example.com', name: 'User' }
+});
+```
+
+## CLI Commands
+
+```bash
+# Generate API client
+pnpm spfn codegen run
+
+# List registered generators
+pnpm spfn codegen list
+
+# Run specific generator
+pnpm spfn codegen run --name api-client
+```