@flightdev/core 0.6.7

package/dist/actions/index.js

@@ -0,0 +1,3 @@
+export { RedirectError, clearActions, collectStream, cookies, createActionContext, createActionMiddleware, createActionReference, createLoggingMiddleware, createMemoryAdapter, createProgressReporter, createQueueManager, createQueuedAction, createRetryMiddleware, createStreamableAction, createTimingMiddleware, defaultRetryStrategy, executeAction, executeFormAction, executeWithMiddleware, exponentialBackoff, fixedDelay, generateActionId, getAction, getAllActions, handleActionRequest, isRedirectError, parseFormData, pipeline, redirect, registerAction, responseToStream, streamToResponse } from '../chunk-72MYOTUB.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/actions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/adapters/index.d.ts

@@ -0,0 +1,502 @@
+import { UIFrameworkAdapter, RenderContext, RenderResult } from '../render/index.js';
+
+/**
+ * Flight Universal Handler - Platform-agnostic request handler
+ *
+ * This is the core abstraction that allows Flight applications to run anywhere.
+ * Adapters can use this handler, or implement their own - zero lock-in.
+ *
+ * @module @flightdev/core/adapters/handler
+ */
+
+/**
+ * Route rules for per-path configuration
+ * Similar to Nitro's routeRules - completely optional to use
+ */
+interface RouteRules {
+    [pattern: string]: RouteRuleConfig;
+}
+interface RouteRuleConfig {
+    /** Cache configuration */
+    cache?: {
+        /** Max age in seconds */
+        maxAge?: number;
+        /** Stale-while-revalidate in seconds */
+        swr?: number;
+        /** Vary headers */
+        vary?: string[];
+    };
+    /** CORS configuration */
+    cors?: boolean | CorsOptions;
+    /** Headers to add to response */
+    headers?: Record<string, string>;
+    /** Redirect configuration */
+    redirect?: string | {
+        to: string;
+        statusCode?: 301 | 302 | 303 | 307 | 308;
+    };
+    /** Proxy to another URL */
+    proxy?: string;
+    /** Render mode override */
+    render?: 'ssr' | 'ssg' | 'csr' | 'isr';
+    /** ISR revalidation time in seconds */
+    isr?: number;
+    /** Prerender at build time */
+    prerender?: boolean;
+}
+interface CorsOptions {
+    origin?: string | string[] | boolean;
+    methods?: string[];
+    allowedHeaders?: string[];
+    exposedHeaders?: string[];
+    credentials?: boolean;
+    maxAge?: number;
+}
+/**
+ * Handler options - all optional, user configures what they need
+ */
+interface UniversalHandlerOptions {
+    /** Route manifest from build */
+    manifest?: RouteManifest;
+    /** UI framework adapter (optional - for SSR) */
+    framework?: UIFrameworkAdapter;
+    /** Route rules (optional) */
+    routeRules?: RouteRules;
+    /** Static files directory (optional) */
+    staticDir?: string;
+    /** Base path (optional) */
+    basePath?: string;
+    /** Custom error handler (optional) */
+    onError?: (error: Error, request: Request) => Response | Promise<Response>;
+    /** Custom not found handler (optional) */
+    onNotFound?: (request: Request) => Response | Promise<Response>;
+    /** Hooks for extensibility (optional) */
+    hooks?: HandlerHooks;
+}
+/**
+ * Handler hooks for extensibility - all optional
+ */
+interface HandlerHooks {
+    /** Before handling request */
+    beforeHandle?: (request: Request) => Request | Promise<Request> | void;
+    /** After getting response, before sending */
+    afterHandle?: (request: Request, response: Response) => Response | Promise<Response> | void;
+    /** Before SSR render */
+    beforeRender?: (context: RenderContext) => void | Promise<void>;
+    /** After SSR render */
+    afterRender?: (result: RenderResult) => RenderResult | Promise<RenderResult>;
+}
+/**
+ * Route manifest from build
+ */
+interface RouteManifest {
+    routes: Array<{
+        path: string;
+        component: string;
+        mode: 'ssr' | 'ssg' | 'csr' | 'isr';
+        handler?: string;
+    }>;
+    staticFiles?: string[];
+}
+/**
+ * Universal handler interface
+ */
+interface UniversalHandler {
+    /** Handle a fetch request */
+    fetch(request: Request, env?: unknown, ctx?: unknown): Promise<Response>;
+    /** Check if this handler can handle the request */
+    canHandle(request: Request): boolean;
+}
+/**
+ * Create a universal request handler
+ *
+ * This is the main abstraction for handling requests.
+ * Adapters can use this, extend it, or ignore it completely.
+ *
+ * @example
+ * ```typescript
+ * // Using the handler (optional)
+ * import { createUniversalHandler } from '@flightdev/core/adapters';
+ *
+ * const handler = createUniversalHandler({
+ *   manifest: await import('./manifest.json'),
+ *   routeRules: {
+ *     '/api/**': { cors: true },
+ *     '/blog/**': { cache: { maxAge: 3600 } },
+ *   },
+ * });
+ *
+ * // In your adapter
+ * export default {
+ *   fetch: handler.fetch,
+ * };
+ * ```
+ */
+declare function createUniversalHandler(options?: UniversalHandlerOptions): UniversalHandler;
+
+/**
+ * Flight Adapters - Optional Validation Helpers
+ *
+ * This module provides optional validation utilities for adapter options.
+ * Zod is NOT required - these are only used if the developer chooses to
+ * add runtime validation to their adapter.
+ *
+ * @example Without validation (default - no Zod needed)
+ * ```typescript
+ * import { createAdapter } from '@flightdev/core/adapters';
+ *
+ * export default function myAdapter(options = {}) {
+ *     return createAdapter({
+ *         name: 'my-adapter',
+ *         adapt: async (builder) => { ... }
+ *     });
+ * }
+ * ```
+ *
+ * @example With optional Zod validation (if developer wants it)
+ * ```typescript
+ * import { createValidatedAdapter } from '@flightdev/core/adapters';
+ * import { z } from 'zod';
+ *
+ * const optionsSchema = z.object({
+ *     port: z.number().default(3000),
+ *     healthCheck: z.boolean().default(true),
+ * });
+ *
+ * export default createValidatedAdapter(
+ *     'my-adapter',
+ *     optionsSchema,
+ *     (options) => ({
+ *         adapt: async (builder) => { ... }
+ *     })
+ * );
+ * ```
+ *
+ * @module @flightdev/core/adapters/validation
+ */
+
+/**
+ * Minimal Zod-like schema interface
+ * This allows the validation helper to work with Zod or any compatible library
+ * without requiring Zod as a direct dependency
+ */
+interface ZodLikeSchema<T = unknown> {
+    parse(data: unknown): T;
+    safeParse(data: unknown): {
+        success: true;
+        data: T;
+    } | {
+        success: false;
+        error: unknown;
+    };
+}
+/**
+ * Options for validated adapter factory
+ */
+interface ValidatedAdapterOptions<T> {
+    /** Parsed and validated options */
+    adapt: (builder: AdapterBuilder) => Promise<void>;
+    /** Optional emulate function */
+    emulate?: FlightAdapter['emulate'];
+    /** Optional supports declaration */
+    supports?: FlightAdapter['supports'];
+}
+/**
+ * Create a validated adapter factory
+ *
+ * This helper validates adapter options at runtime using a Zod-like schema.
+ * The developer chooses whether to use this - it's completely optional.
+ *
+ * @param name - Adapter name
+ * @param schema - Zod-like schema for options validation
+ * @param factory - Factory function that receives validated options
+ * @returns Adapter factory function
+ *
+ * @example
+ * ```typescript
+ * import { createValidatedAdapter } from '@flightdev/core/adapters';
+ * import { z } from 'zod';
+ *
+ * const schema = z.object({
+ *     port: z.number().default(3000),
+ *     region: z.string().optional(),
+ * });
+ *
+ * export default createValidatedAdapter('my-adapter', schema, (options) => ({
+ *     adapt: async (builder) => {
+ *         // options is fully typed: { port: number; region?: string }
+ *         console.log(`Using port ${options.port}`);
+ *     }
+ * }));
+ * ```
+ */
+declare function createValidatedAdapter<TSchema extends ZodLikeSchema>(name: string, schema: TSchema, factory: (options: ReturnType<TSchema['parse']>) => ValidatedAdapterOptions<ReturnType<TSchema['parse']>>): (options?: unknown) => FlightAdapter;
+/**
+ * Validate adapter options without throwing
+ * Returns null if validation fails, useful for optional validation
+ *
+ * @param schema - Zod-like schema
+ * @param options - Options to validate
+ * @returns Validated options or null
+ */
+declare function validateAdapterOptions<TSchema extends ZodLikeSchema>(schema: TSchema, options: unknown): ReturnType<TSchema['parse']> | null;
+/**
+ * Assert adapter options are valid, throwing detailed error if not
+ *
+ * @param name - Adapter name for error messages
+ * @param schema - Zod-like schema
+ * @param options - Options to validate
+ * @returns Validated options
+ * @throws Error with detailed message if validation fails
+ */
+declare function assertValidOptions<TSchema extends ZodLikeSchema>(name: string, schema: TSchema, options: unknown): ReturnType<TSchema['parse']>;
+/**
+ * Extract the inferred type from a Zod-like schema
+ * Useful for typing adapter options in TypeScript
+ */
+type InferSchema<T extends ZodLikeSchema> = ReturnType<T['parse']>;
+
+/**
+ * Flight Adapters - Universal deployment adapters
+ *
+ * Adapters transform Flight's output for different deployment targets.
+ * The user chooses where to deploy - Flight provides the adapters.
+ */
+/** Build manifest containing all generated assets */
+interface BuildManifest {
+    /** Entry points by name */
+    entries: Record<string, string>;
+    /** All generated files */
+    files: string[];
+    /** Route information */
+    routes: RouteManifestEntry[];
+    /** Server entry point (if applicable) */
+    serverEntry?: string;
+    /** Client entry point */
+    clientEntry?: string;
+}
+/** Route information in manifest */
+interface RouteManifestEntry {
+    /** Route path pattern */
+    path: string;
+    /** Render mode for this route */
+    mode: 'ssr' | 'ssg' | 'csr' | 'isr';
+    /** Component/handler file path */
+    component: string;
+    /** Pre-rendered paths (for SSG/ISR) */
+    prerendered?: string[];
+}
+/** Builder utilities passed to adapters */
+interface AdapterBuilder {
+    /** Build manifest */
+    manifest: BuildManifest;
+    /** Project root directory */
+    root: string;
+    /** Build output directory */
+    outDir: string;
+    /** Read a file from the build output */
+    readFile(path: string): Promise<string>;
+    /** Write a file to the adapter output */
+    writeFile(path: string, content: string): Promise<void>;
+    /** Copy files from build to adapter output */
+    copy(from: string, to: string): Promise<void>;
+    /** Get all files matching a pattern */
+    glob(pattern: string): Promise<string[]>;
+    /** Compress files for production */
+    compress?(files: string[]): Promise<void>;
+    /** Log info message */
+    log: {
+        info(message: string): void;
+        warn(message: string): void;
+        error(message: string): void;
+    };
+}
+/** Flight adapter interface */
+interface FlightAdapter {
+    /** Adapter name */
+    name: string;
+    /**
+     * Transform the build output for the target platform
+     * This is called after Flight's build process completes
+     */
+    adapt(builder: AdapterBuilder): Promise<void>;
+    /**
+     * Optional: Start listening for requests (for Node.js/Bun adapters)
+     */
+    listen?(server: unknown, port: number): Promise<void>;
+    /**
+     * Optional: Emulate the platform during development
+     * Useful for testing platform-specific behavior locally
+     */
+    emulate?(): {
+        /** Platform-specific env vars */
+        env?: Record<string, string>;
+        /** Custom middleware for dev server */
+        middleware?: unknown[];
+    };
+    /**
+     * Optional: Declare what this adapter supports
+     * Flight uses this to warn about incompatible features
+     */
+    supports?: {
+        /** Can read files at runtime (for dynamic content) */
+        read?: () => boolean;
+        /** Supports streaming responses */
+        streaming?: () => boolean;
+        /** Supports WebSockets */
+        websockets?: () => boolean;
+        /** Supports edge runtime */
+        edge?: () => boolean;
+        /** Supports Node.js runtime */
+        node?: () => boolean;
+    };
+}
+interface AdapterOptions {
+    name: string;
+    adapt: (builder: AdapterBuilder) => Promise<void>;
+    emulate?: FlightAdapter['emulate'];
+    supports?: FlightAdapter['supports'];
+}
+/**
+ * Create a Flight adapter
+ *
+ * @example
+ * ```typescript
+ * import { createAdapter } from '@flightdev/core/adapters';
+ *
+ * export default function myAdapter(options = {}) {
+ *   return createAdapter({
+ *     name: 'my-adapter',
+ *     async adapt(builder) {
+ *       // Transform build output for your platform
+ *     },
+ *   });
+ * }
+ * ```
+ */
+declare function createAdapter(options: AdapterOptions): FlightAdapter;
+
+/**
+ * Storage Adapter Interface
+ *
+ * Implement this to use any storage provider:
+ * S3, Supabase Storage, Cloudflare R2, local filesystem, etc.
+ */
+interface StorageAdapter {
+    name: string;
+    /** Upload a file */
+    upload(path: string, data: Buffer | Uint8Array | string, options?: {
+        contentType?: string;
+        metadata?: Record<string, string>;
+    }): Promise<{
+        url: string;
+        path: string;
+    }>;
+    /** Download a file */
+    download(path: string): Promise<Buffer>;
+    /** Delete a file */
+    delete(path: string): Promise<void>;
+    /** List files with optional prefix */
+    list(prefix?: string): Promise<string[]>;
+    /** Get a signed URL for direct access */
+    getSignedUrl?(path: string, options?: {
+        expiresIn?: number;
+        operation?: 'read' | 'write';
+    }): Promise<string>;
+}
+/**
+ * Auth Adapter Interface
+ *
+ * Implement this to use any auth provider:
+ * Better Auth, Supabase Auth, Lucia, Auth.js, etc.
+ */
+interface AuthAdapter {
+    name: string;
+    /** Get the current user from a request */
+    getUser(request: Request): Promise<AuthUser | null>;
+    /** Verify a session token */
+    verifySession(token: string): Promise<AuthSession | null>;
+    /** Optional middleware for handling auth-specific routes (e.g., /api/auth/*) */
+    middleware?: (req: Request) => Promise<Response | null>;
+}
+interface AuthUser {
+    id: string;
+    email?: string;
+    name?: string;
+    avatar?: string;
+    metadata?: Record<string, unknown>;
+}
+interface AuthSession {
+    user: AuthUser;
+    expiresAt: Date;
+    token: string;
+}
+/**
+ * Email Adapter Interface
+ *
+ * Implement this to use any email provider:
+ * Resend, SendGrid, Postmark, SMTP, etc.
+ */
+interface EmailAdapter {
+    name: string;
+    /** Send an email */
+    send(options: {
+        to: string | string[];
+        subject: string;
+        html?: string;
+        text?: string;
+        from?: string;
+        replyTo?: string;
+        attachments?: Array<{
+            filename: string;
+            content: Buffer | string;
+            contentType?: string;
+        }>;
+    }): Promise<{
+        id: string;
+        success: boolean;
+    }>;
+}
+/**
+ * Queue/Jobs Adapter Interface
+ *
+ * Implement this to use any job queue:
+ * BullMQ, Quirrel, Inngest, custom, etc.
+ */
+interface JobsAdapter {
+    name: string;
+    /** Add a job to the queue */
+    enqueue<T>(jobName: string, data: T, options?: {
+        delay?: number;
+        priority?: number;
+        retries?: number;
+    }): Promise<{
+        id: string;
+    }>;
+    /** Schedule a recurring job */
+    schedule?(jobName: string, cron: string, data?: unknown): Promise<{
+        id: string;
+    }>;
+    /** Cancel a job */
+    cancel?(jobId: string): Promise<void>;
+}
+/**
+ * Database Adapter Interface
+ *
+ * Note: This is intentionally minimal.
+ * For databases, use your preferred ORM/query builder directly.
+ * This interface is for Flight's internal use (sessions, cache, etc.)
+ */
+interface DatabaseAdapter {
+    name: string;
+    /** Raw query execution */
+    query<T = unknown>(sql: string, params?: unknown[]): Promise<T[]>;
+    /** Execute a mutation */
+    execute(sql: string, params?: unknown[]): Promise<{
+        rowsAffected: number;
+    }>;
+    /** Transaction support */
+    transaction?<T>(fn: (tx: DatabaseAdapter) => Promise<T>): Promise<T>;
+}
+
+export { type AdapterBuilder, type AdapterOptions, type AuthAdapter, type AuthSession, type AuthUser, type BuildManifest, type CorsOptions, type DatabaseAdapter, type EmailAdapter, type FlightAdapter, type HandlerHooks, type InferSchema, type JobsAdapter, type RouteManifest, type RouteManifestEntry, type RouteRuleConfig, type RouteRules, type StorageAdapter, type UniversalHandler, type UniversalHandlerOptions, type ValidatedAdapterOptions, type ZodLikeSchema, assertValidOptions, createAdapter, createUniversalHandler, createValidatedAdapter, validateAdapterOptions };

package/dist/adapters/index.js

@@ -0,0 +1,3 @@
+export { assertValidOptions, createAdapter, createUniversalHandler, createValidatedAdapter, validateAdapterOptions } from '../chunk-62HISNA3.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/adapters/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}