@spfn/core 0.3.0-beta.3 → 0.3.0-beta.30

package/dist/token-manager-BT5EnUAR.d.ts

@@ -1,278 +0,0 @@
-import { TSchema } from '@sinclair/typebox';
-
-/**
- * Event System Types
- */
-
-/**
- * Pub/Sub capable cache interface for multi-instance events
- */
-interface PubSubCache {
-    /**
-     * Publish a message to a channel
-     */
-    publish(channel: string, message: unknown): Promise<void>;
-    /**
-     * Subscribe to a channel
-     */
-    subscribe(channel: string, handler: (message: unknown) => void | Promise<void>): Promise<void>;
-}
-/**
- * Event handler function type
- */
-type EventHandler<TPayload> = (payload: TPayload) => void | Promise<void>;
-/**
- * Job queue sender function type (used by job module)
- */
-type JobQueueSender = (queueName: string, payload: unknown) => Promise<void>;
-/**
- * Event definition interface
- */
-interface EventDef<TPayload = void> {
-    /**
-     * Unique event name
-     */
-    readonly name: string;
-    /**
-     * TypeBox payload schema (optional)
-     */
-    readonly schema?: TSchema;
-    /**
-     * Subscribe to this event (in-memory handler)
-     */
-    subscribe: (handler: EventHandler<TPayload>) => () => void;
-    /**
-     * Unsubscribe all handlers
-     */
-    unsubscribeAll: () => void;
-    /**
-     * Emit the event (triggers all subscribers and queued jobs)
-     */
-    emit: TPayload extends void ? () => Promise<void> : (payload: TPayload) => Promise<void>;
-    /**
-     * Enable cache-based pub/sub for multi-instance support
-     * Must await before emitting events to ensure subscription is ready
-     */
-    useCache: (cache: PubSubCache) => Promise<EventDef<TPayload>>;
-    /**
-     * Internal: Register a job queue to receive this event
-     * Called by job registration system
-     */
-    _registerJobQueue: (queueName: string, sender: JobQueueSender) => void;
-    /**
-     * Internal: Drop the cache binding (cache + subscribed flag).
-     * Called by the event cache transport on shutdown so a later useCache can
-     * rebind a fresh cache in the same process.
-     */
-    _resetCache: () => void;
-    /**
-     * Type inference helper
-     */
-    _payload: TPayload;
-}
-/**
- * Infer payload type from EventDef
- */
-type InferEventPayload$1<TEvent> = TEvent extends EventDef<infer TPayload> ? TPayload : never;
-
-/**
- * Event Router
- *
- * Type-safe event router for SSE subscription
- *
- * @example
- * ```typescript
- * import { defineEvent, defineEventRouter } from '@spfn/core/event';
- * import { Type } from '@sinclair/typebox';
- *
- * const userCreated = defineEvent('user.created', Type.Object({
- *     userId: Type.String(),
- * }));
- *
- * const orderPlaced = defineEvent('order.placed', Type.Object({
- *     orderId: Type.String(),
- *     amount: Type.Number(),
- * }));
- *
- * export const eventRouter = defineEventRouter({
- *     userCreated,
- *     orderPlaced,
- * });
- *
- * export type EventRouter = typeof eventRouter;
- * ```
- */
-
-/**
- * Event Router Definition
- */
-interface EventRouterDef<TEvents extends Record<string, EventDef<any>>> {
-    /**
-     * Event definitions
-     */
-    readonly events: TEvents;
-    /**
-     * Event names as array
-     */
-    readonly eventNames: (keyof TEvents)[];
-    /**
-     * Type inference helper - payload types by event name
-     */
-    readonly _types: {
-        [K in keyof TEvents]: TEvents[K]['_payload'];
-    };
-}
-/**
- * Infer event names from EventRouter
- */
-type InferEventNames<T> = T extends EventRouterDef<infer E> ? keyof E & string : never;
-/**
- * Infer payload type for specific event
- */
-type InferEventPayload<T extends EventRouterDef<any>, K extends InferEventNames<T>> = T['_types'][K];
-/**
- * Infer all event payloads map
- */
-type InferEventPayloads<T extends EventRouterDef<any>> = T['_types'];
-/**
- * Define an event router for SSE subscription
- *
- * @example
- * ```typescript
- * export const eventRouter = defineEventRouter({
- *     userCreated,
- *     orderPlaced,
- * });
- *
- * // Type inference
- * type Names = InferEventNames<typeof eventRouter>;
- * // 'userCreated' | 'orderPlaced'
- *
- * type Payload = InferEventPayload<typeof eventRouter, 'userCreated'>;
- * // { userId: string }
- * ```
- */
-declare function defineEventRouter<TEvents extends Record<string, EventDef<any>>>(events: TEvents): EventRouterDef<TEvents>;
-
-/**
- * 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();
- * ```
- */
-/**
- * Minimal cache client interface (compatible with ioredis Redis | Cluster)
- */
-type CacheClient = {
-    set(key: string, value: string, ...args: any[]): Promise<any>;
-    getdel?(key: string): Promise<string | null>;
-    get(key: string): Promise<string | null>;
-    del(...keys: string[]): Promise<number>;
-};
-/**
- * Stored SSE token data
- */
-interface SSEToken {
-    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;
-}
-/**
- * Redis/Valkey-backed token store for multi-instance deployments.
- *
- * Uses SET EX for automatic TTL expiry and GETDEL for atomic one-time consumption.
- * No cleanup needed — Redis handles expiration automatically.
- *
- * @example
- * ```typescript
- * import { getCache } from '@spfn/core/cache';
- *
- * const cache = getCache();
- * if (cache) {
- *     const store = new CacheTokenStore(cache);
- *     const manager = new SSETokenManager({ store });
- * }
- * ```
- */
-declare class CacheTokenStore implements SSETokenStore {
-    private cache;
-    private prefix;
-    constructor(cache: CacheClient);
-    set(token: string, data: SSEToken): Promise<void>;
-    consume(token: string): Promise<SSEToken | null>;
-    cleanup(): Promise<void>;
-}
-declare class SSETokenManager {
-    private store;
-    private ttl;
-    private cleanupTimer;
-    constructor(config?: SSETokenManagerConfig);
-    /**
-     * How long an issued token stays valid, in milliseconds.
-     *
-     * Exposed so a caller that has to report an expiry to its client computes the same
-     * number this manager stamps on the token, instead of assuming the default.
-     */
-    get ttlMs(): number;
-    /**
-     * 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;
-}
-
-export { CacheTokenStore as C, type EventDef as E, type InferEventNames as I, type JobQueueSender as J, type PubSubCache as P, SSETokenManager as S, type EventHandler as a, type EventRouterDef as b, type InferEventPayload$1 as c, type InferEventPayloads as d, type InferEventPayload as e, defineEventRouter as f, type SSEToken as g, type SSETokenManagerConfig as h, type SSETokenStore as i };

package/dist/types-9oszaJqp.d.ts

@@ -1,250 +0,0 @@
-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 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 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
- */
-interface CookieOptions {
-    httpOnly?: boolean;
-    secure?: boolean;
-    sameSite?: 'strict' | 'lax' | 'none';
-    maxAge?: number;
-    path?: string;
-    domain?: string;
-}
-/**
- * Cookie to set in response
- */
-interface SetCookie {
-    name: string;
-    value: string;
-    options?: CookieOptions;
-}
-/**
- * Request interceptor - called before fetch
- */
-type RequestInterceptor = (url: string, init: RequestInit) => Promise<RequestInit> | RequestInit;
-/**
- * Response interceptor - called after fetch
- */
-type ResponseInterceptor = (response: Response, body: any) => Promise<{
-    response: Response;
-    body: any;
-}> | {
-    response: Response;
-    body: any;
-};
-/**
- * Client configuration
- */
-interface ApiConfig {
-    /**
-     * Base URL for RPC endpoint
-     *
-     * @default '/api/rpc'
-     * @example '/api/rpc', 'http://localhost:3000/api/rpc'
-     */
-    baseUrl?: string;
-    /**
-     * Default headers for all requests
-     */
-    headers?: Record<string, string>;
-    /**
-     * Request timeout in milliseconds
-     *
-     * @default env.SERVER_TIMEOUT (120000)
-     */
-    timeout?: number;
-    /**
-     * Custom fetch implementation
-     */
-    fetch?: typeof fetch;
-    /**
-     * Global request interceptor
-     */
-    onRequest?: RequestInterceptor;
-    /**
-     * Global response interceptor
-     */
-    onResponse?: ResponseInterceptor;
-    /**
-     * Custom error registry for deserialization
-     *
-     * Core HTTP errors are automatically registered. Use this to add your custom application errors.
-     *
-     * @example
-     * ```typescript
-     * import { errorRegistry } from '@spfn/core/errors';
-     * import { authErrorRegistry } from '@myapp/auth/errors';
-     * import { PaymentFailedError } from '@/server/errors';
-     *
-     * const api = createApi<AppRouter>({
-     *   errorRegistry: [errorRegistry, authErrorRegistry, PaymentFailedError]
-     * });
-     * ```
-     */
-    errorRegistry?: ErrorRegistry | ErrorRegistryInput[];
-    /**
-     * Enable debug logging
-     *
-     * @default false
-     */
-    debug?: boolean;
-}
-/**
- * Per-call options
- */
-interface CallOptions {
-    /**
-     * Request timeout in milliseconds
-     * Overrides the global timeout set in ApiConfig
-     */
-    timeout?: number;
-    /**
-     * Additional headers for this request
-     */
-    headers?: Record<string, string>;
-    /**
-     * Override cookies for this request
-     *
-     * Note: Cookies are automatically forwarded by the proxy.
-     * Use this only when you need to override them.
-     */
-    cookies?: Record<string, string>;
-    /**
-     * Request-specific interceptor
-     */
-    onRequest?: RequestInterceptor;
-    /**
-     * Response-specific interceptor
-     */
-    onResponse?: ResponseInterceptor;
-    /**
-     * Next.js-specific fetch options
-     *
-     * @example
-     * // Time-based revalidation
-     * { next: { revalidate: 60 } }
-     *
-     * // Disable cache
-     * { cache: 'no-store' }
-     *
-     * // Tag-based revalidation
-     * { next: { tags: ['users'] } }
-     */
-    fetchOptions?: RequestInit & {
-        next?: {
-            revalidate?: number | false;
-            tags?: string[];
-        };
-    };
-}
-
-export type { ApiConfig as A, CallOptions as C, InferRouteInput as I, RequestInterceptor as R, SetCookie as S, ResponseInterceptor as a, InferRouteOutput as b, CookieOptions as c, RouterInput as d, RouterOutput as e, StructuredInput as f };