@spfn/core 0.2.0-beta.9 → 0.3.0-beta.10

package/dist/boss-DI1r4kTS.d.ts

@@ -1,244 +0,0 @@
-import { TSchema } from '@sinclair/typebox';
-import PgBoss from 'pg-boss';
-
-/**
- * Job System Types
- *
- * Type definitions for the pg-boss based job system
- */
-
-/**
- * Job options passed to pg-boss
- */
-interface JobOptions {
-    /**
-     * Maximum retry attempts
-     * @default 3
-     */
-    retryLimit?: number;
-    /**
-     * Delay between retries in milliseconds
-     * @default 1000
-     */
-    retryDelay?: number;
-    /**
-     * Job expiration in seconds
-     * @default 300 (5 minutes)
-     */
-    expireInSeconds?: number;
-    /**
-     * Job priority (higher = more important)
-     * @default 0
-     */
-    priority?: number;
-    /**
-     * Singleton key - only one job with this key can exist
-     */
-    singletonKey?: string;
-    /**
-     * Keep completed jobs for this many seconds
-     * @default 604800 (7 days)
-     */
-    retentionSeconds?: number;
-}
-/**
- * Send options for individual job dispatch
- */
-interface JobSendOptions {
-    /**
-     * Delay execution by this many seconds
-     */
-    startAfter?: number | Date;
-    /**
-     * Singleton key for this specific job instance
-     */
-    singletonKey?: string;
-    /**
-     * Priority override
-     */
-    priority?: number;
-}
-/**
- * Job handler function type
- */
-type JobHandler<TInput, TOutput = void> = TInput extends void ? () => Promise<TOutput> : (input: TInput) => Promise<TOutput>;
-/**
- * Compensate handler function type (for rollback)
- */
-type CompensateHandler<TInput, TOutput> = (input: TInput, output: TOutput) => Promise<void>;
-/**
- * Job definition interface
- */
-interface JobDef<TInput = void, TOutput = void> {
-    /**
-     * Unique job name
-     */
-    readonly name: string;
-    /**
-     * TypeBox input schema (optional)
-     */
-    readonly inputSchema?: TSchema;
-    /**
-     * TypeBox output schema (optional, for workflow integration)
-     */
-    readonly outputSchema?: TSchema;
-    /**
-     * Cron expression for scheduled jobs
-     */
-    readonly cronExpression?: string;
-    /**
-     * Run once on server start
-     */
-    readonly runOnce?: boolean;
-    /**
-     * Event name this job subscribes to
-     */
-    readonly subscribedEvent?: string;
-    /**
-     * Event definition this job subscribes to (internal use)
-     */
-    readonly _subscribedEventDef?: unknown;
-    /**
-     * Job options
-     */
-    readonly options?: JobOptions;
-    /**
-     * Job handler
-     */
-    readonly handler: JobHandler<TInput, TOutput>;
-    /**
-     * Compensate handler for rollback (optional, for workflow integration)
-     */
-    readonly compensate?: CompensateHandler<TInput, TOutput>;
-    /**
-     * Send job to queue (returns immediately, executes in background)
-     */
-    send: TInput extends void ? (options?: JobSendOptions) => Promise<string | null> : (input: TInput, options?: JobSendOptions) => Promise<string | null>;
-    /**
-     * Run job synchronously (for testing/debugging)
-     */
-    run: TInput extends void ? () => Promise<TOutput> : (input: TInput) => Promise<TOutput>;
-    /**
-     * Type inference helpers
-     */
-    _input: TInput;
-    _output: TOutput;
-}
-/**
- * Job router entry - can be a job or nested router
- */
-type JobRouterEntry = JobDef<any, any> | JobRouter<any>;
-/**
- * Job router interface
- */
-interface JobRouter<TJobs extends Record<string, JobRouterEntry> = Record<string, JobRouterEntry>> {
-    readonly jobs: TJobs;
-    readonly _jobs: TJobs;
-}
-/**
- * Infer input type from JobDef
- */
-type InferJobInput<TJob> = TJob extends JobDef<infer TInput, any> ? TInput : never;
-/**
- * Infer output type from JobDef
- */
-type InferJobOutput<TJob> = TJob extends JobDef<any, infer TOutput> ? TOutput : never;
-
-/**
- * pg-boss Wrapper
- *
- * Manages pg-boss instance lifecycle
- */
-
-/**
- * Options for pg-boss initialization
- *
- * @example
- * ```typescript
- * await initBoss({
- *     connectionString: process.env.DATABASE_URL,
- *     schema: 'spfn_queue',
- *     clearOnStart: process.env.NODE_ENV === 'development',
- * });
- * ```
- */
-interface BossOptions {
-    /**
-     * PostgreSQL connection string
-     *
-     * @example 'postgresql://user:password@localhost:5432/mydb'
-     */
-    connectionString: string;
-    /**
-     * Schema name for pg-boss tables
-     *
-     * pg-boss creates its own tables in this schema.
-     *
-     * @default 'spfn_queue'
-     */
-    schema?: string;
-    /**
-     * Maintenance interval in seconds
-     *
-     * pg-boss runs maintenance tasks (cleanup, archiving) at this interval.
-     *
-     * @default 120
-     */
-    maintenanceIntervalSeconds?: number;
-    /**
-     * Monitor state changes interval in seconds
-     *
-     * When set, pg-boss emits state change events at this interval.
-     *
-     * @default undefined (disabled)
-     */
-    monitorIntervalSeconds?: number;
-    /**
-     * Clear all pending/scheduled jobs on startup
-     *
-     * Useful for development mode to start with a clean queue.
-     * Should be false in production.
-     *
-     * @default false
-     */
-    clearOnStart?: boolean;
-}
-/**
- * @deprecated Use BossOptions instead
- */
-type BossConfig = BossOptions;
-/**
- * Initialize pg-boss with the given configuration
- *
- * Must be called before registerJobs(). Typically handled by defineServerConfig().
- *
- * @param options - pg-boss configuration options
- * @returns The pg-boss instance
- *
- * @example
- * ```typescript
- * const boss = await initBoss({
- *     connectionString: process.env.DATABASE_URL!,
- *     schema: 'spfn_queue',
- * });
- * ```
- */
-declare function initBoss(options: BossOptions): Promise<PgBoss>;
-/**
- * Get the current pg-boss instance
- */
-declare function getBoss(): PgBoss | null;
-/**
- * Stop pg-boss gracefully
- */
-declare function stopBoss(): Promise<void>;
-/**
- * Check if pg-boss is initialized and running
- */
-declare function isBossRunning(): boolean;
-/**
- * Check if jobs should be cleared on start
- */
-declare function shouldClearOnStart(): boolean;
-
-export { type BossOptions as B, type CompensateHandler as C, type InferJobInput as I, type JobRouter as J, type JobOptions as a, type JobHandler as b, type JobDef as c, type JobRouterEntry as d, type JobSendOptions as e, type InferJobOutput as f, getBoss as g, isBossRunning as h, initBoss as i, shouldClearOnStart as j, type BossConfig as k, stopBoss as s };

package/dist/router-Di7ENoah.d.ts

@@ -1,151 +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;
-    /**
-     * 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>;
-
-export { type EventRouterDef as E, type InferEventNames as I, type JobQueueSender as J, type PubSubCache as P, type EventDef as a, type InferEventPayload as b, type InferEventPayloads as c, defineEventRouter as d, type EventHandler as e, type InferEventPayload$1 as f };

package/dist/types-B-e_f2dQ.d.ts

@@ -1,121 +0,0 @@
-import { E as EventRouterDef, I as InferEventNames, b as InferEventPayload } from './router-Di7ENoah.js';
-
-/**
- * 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 Handler configuration
- */
-interface SSEHandlerConfig {
-    /**
-     * Keep-alive ping interval in milliseconds
-     * @default 30000
-     */
-    pingInterval?: number;
-    /**
-     * Custom headers for SSE response
-     */
-    headers?: Record<string, string>;
-}
-/**
- * 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;
-}
-/**
- * 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, SSEMessage as a, SSEClientConfig as b, SSEEventHandler as c, SSEEventHandlers as d, SSESubscribeOptions as e, SSEConnectionState as f, SSEUnsubscribe as g };

package/docs/cache.md

@@ -1,133 +0,0 @@
-# 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

@@ -1,74 +0,0 @@
-# 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
-```