@farm.js/core 0.1.0-beta.10 → 0.1.0-beta.11

package/dist/middleware.d.ts

@@ -0,0 +1,164 @@
+import { cs as MiddlewareChain, cw as RateLimitStorage, cx as RateLimitStatus, cn as MiddlewareContext, Y as FarmMiddlewareConfig, co as MiddlewareFunction, d2 as MiddlewareConfig, M as MiddlewareProps } from './client-plugins-Bc5jHcNr.js';
+export { ct as CookieJar, cu as CookieOptions, cz as MiddlewareResult, cr as MiddlewareStore, cy as NextFunction, cv as RateLimitConfig, X as ReadonlyMiddlewareStore, cp as RequestMiddleware, cq as RequestMiddlewareContext } from './client-plugins-Bc5jHcNr.js';
+import { IncomingMessage, ServerResponse } from 'http';
+import { ViteDevServer, Plugin } from 'vite';
+import { R as ResolvedFarmI18nConfig } from './types-BMxWr97v.js';
+export { _ as _runWithMiddlewareContext, b as _runWithMiddlewareData, a as applyProductionMiddlewareHeaders, c as createProductionMiddlewareRunner, g as getMiddlewareContext, d as getMiddlewareData, e as getMiddlewareValue } from './production-runtime-9KG7GuvW.js';
+import './plugin-BJDf43dc.js';
+import 'react';
+import './types-D1A6-XvH.js';
+import 'db0';
+import 'unstorage';
+import './integration-api-CHT2OKAf.js';
+import '@farming-labs/orm';
+import './types-C9N-nk5R.js';
+import '@farming-labs/docs';
+import './markdown.js';
+import './observability.js';
+import './workflows.js';
+import './cron.js';
+import './env.js';
+import './server-action-security.js';
+import './image-config-Duob7wER.js';
+import './cache.js';
+import './route-runtime-DoOHzCAD.js';
+
+/**
+ * Middleware Chain Builder
+ */
+
+/**
+ * Get rate limit status for a key
+ * @example
+ * const status = await getRateLimitStatus('user:123', 100, storage);
+ */
+declare function getRateLimitStatus(key: string, limit: number, storage?: RateLimitStorage): Promise<RateLimitStatus>;
+declare function middleware(basePath?: string): MiddlewareChain;
+
+/**
+ * Middleware Context Implementation
+ */
+
+/**
+ * Create a middleware context from request/response
+ */
+declare function createContext(req: IncomingMessage, res: ServerResponse, viteServer?: ViteDevServer, parent?: MiddlewareContext["parent"]): MiddlewareContext;
+
+/**
+ * Middleware Manager
+ *
+ * Discovers and executes middleware files in the file system
+ */
+
+interface DiscoveredMiddleware {
+    path: string;
+    filePath: string;
+    handlers: MiddlewareFunction[];
+    config?: MiddlewareConfig;
+    source?: "config" | "file";
+}
+/**
+ * Middleware Manager - discovers and executes middleware
+ */
+declare class MiddlewareManager {
+    private middleware;
+    private configMiddleware;
+    private globalConfig?;
+    private viteServer?;
+    private appDirs;
+    private i18n?;
+    constructor(appDir: string | readonly string[], viteServer?: ViteDevServer, config?: FarmMiddlewareConfig, i18n?: ResolvedFarmI18nConfig);
+    configure(config?: FarmMiddlewareConfig): void;
+    /**
+     * Discover all middleware.ts files
+     */
+    discover(): Promise<void>;
+    /**
+     * Recursively discover middleware files
+     */
+    private discoverInDirectory;
+    /**
+     * Find middleware file in directory
+     */
+    private findMiddlewareFile;
+    /**
+     * Load a middleware file
+     */
+    private loadMiddleware;
+    /**
+     * Execute middleware for a request
+     */
+    execute(req: IncomingMessage, res: ServerResponse): Promise<boolean>;
+    /**
+     * Check if pathname matches middleware config
+     */
+    private matchesConfig;
+    /**
+     * Match a pattern against pathname
+     */
+    private matchPattern;
+    /**
+     * Reload middleware (for HMR)
+     */
+    reload(): Promise<void>;
+    getMiddlewares(): DiscoveredMiddleware[];
+    hasMiddleware(): boolean;
+    private matchRoutePath;
+    private toMatcherList;
+    private getConfigHandlers;
+    private toMiddlewareConfig;
+    private compilePathPattern;
+    private parseColonParam;
+    private escapeRegex;
+}
+
+/**
+ * Middleware helper utilities for pages
+ */
+
+/**
+ * Unwrap middleware data from PageProps
+ *
+ * @example
+ * ```tsx
+ * export default async function Page(props: PageProps) {
+ *   const { user, stats } = await unwrapMiddleware(props.middleware, {
+ *     user: null,
+ *     stats: { views: 0, clicks: 0 }
+ *   });
+ *
+ *   return <div>Welcome {user?.name}</div>;
+ * }
+ * ```
+ */
+declare function unwrapMiddleware<T extends Record<string, any>>(middleware: MiddlewareProps | undefined, defaults?: Partial<T>): Partial<T>;
+/**
+ * Get a single value from middleware with a default
+ *
+ * @example
+ * ```tsx
+ * export default async function Page(props: PageProps) {
+ *   const user = await getMiddlewareValue(props.middleware, 'user', null);
+ *   return <div>Welcome {user?.name || 'Guest'}</div>;
+ * }
+ * ```
+ */
+declare function getFromMiddleware<T = any>(middleware: MiddlewareProps | undefined, key: string, defaultValue?: T): T | undefined;
+/**
+ * Check if middleware data exists
+ */
+declare function hasMiddlewareData(middleware: MiddlewareProps | undefined): boolean;
+
+/**
+ * Standalone Vite middleware support used by Farm's RSC and API plugins.
+ */
+
+interface FarmMiddlewarePluginOptions {
+    /** Source directory (default: `src`). */
+    srcDir?: string;
+    /** Enable debug logging. */
+    debug?: boolean;
+}
+declare function farmMiddlewarePlugin(options?: FarmMiddlewarePluginOptions): Plugin;
+
+export { FarmMiddlewareConfig, type FarmMiddlewarePluginOptions, MiddlewareChain, MiddlewareConfig, MiddlewareContext, MiddlewareFunction, MiddlewareManager, RateLimitStatus, RateLimitStorage, createContext, farmMiddlewarePlugin, getFromMiddleware, getRateLimitStatus, hasMiddlewareData, middleware, unwrapMiddleware };

package/dist/navigation-errors-Dvwpzaer.d.mts

@@ -0,0 +1,13 @@
+type FarmRedirectStatus = 301 | 302 | 303 | 307 | 308;
+interface FarmRedirectSignal {
+    url: string;
+    status: FarmRedirectStatus;
+}
+declare function redirect(url: string, status?: FarmRedirectStatus): never;
+declare function permanentRedirect(url: string): never;
+declare function notFound(): never;
+declare function isFarmRedirectError(error: unknown): boolean;
+declare function getFarmRedirectError(error: unknown): FarmRedirectSignal | null;
+declare function isFarmNotFoundError(error: unknown): boolean;
+
+export { type FarmRedirectSignal as F, isFarmRedirectError as a, type FarmRedirectStatus as b, getFarmRedirectError as g, isFarmNotFoundError as i, notFound as n, permanentRedirect as p, redirect as r };

package/dist/navigation-errors-Dvwpzaer.d.ts

@@ -0,0 +1,13 @@
+type FarmRedirectStatus = 301 | 302 | 303 | 307 | 308;
+interface FarmRedirectSignal {
+    url: string;
+    status: FarmRedirectStatus;
+}
+declare function redirect(url: string, status?: FarmRedirectStatus): never;
+declare function permanentRedirect(url: string): never;
+declare function notFound(): never;
+declare function isFarmRedirectError(error: unknown): boolean;
+declare function getFarmRedirectError(error: unknown): FarmRedirectSignal | null;
+declare function isFarmNotFoundError(error: unknown): boolean;
+
+export { type FarmRedirectSignal as F, isFarmRedirectError as a, type FarmRedirectStatus as b, getFarmRedirectError as g, isFarmNotFoundError as i, notFound as n, permanentRedirect as p, redirect as r };

package/dist/navigation.d.mts

@@ -0,0 +1,14 @@
+export { F as FarmRedirectSignal, b as FarmRedirectStatus, g as getFarmRedirectError, i as isFarmNotFoundError, a as isFarmRedirectError, n as notFound, p as permanentRedirect, r as redirect } from './navigation-errors-Dvwpzaer.mjs';
+
+declare function useRouter(): {
+    push: (href: string) => void;
+    replace: (href: string) => void;
+    back: () => void;
+    forward: () => void;
+    refresh(): void;
+    prefetch(_href: string): Promise<void>;
+};
+declare function usePathname(): string;
+declare function useSearchParams(): URLSearchParams;
+
+export { usePathname, useRouter, useSearchParams };

package/dist/navigation.d.ts

@@ -0,0 +1,14 @@
+export { F as FarmRedirectSignal, b as FarmRedirectStatus, g as getFarmRedirectError, i as isFarmNotFoundError, a as isFarmRedirectError, n as notFound, p as permanentRedirect, r as redirect } from './navigation-errors-Dvwpzaer.js';
+
+declare function useRouter(): {
+    push: (href: string) => void;
+    replace: (href: string) => void;
+    back: () => void;
+    forward: () => void;
+    refresh(): void;
+    prefetch(_href: string): Promise<void>;
+};
+declare function usePathname(): string;
+declare function useSearchParams(): URLSearchParams;
+
+export { usePathname, useRouter, useSearchParams };

package/dist/observability.d.mts

@@ -0,0 +1,335 @@
+type FarmEventLevel = "debug" | "info" | "warn" | "error";
+interface FarmEventBase {
+    type: string;
+    timestamp: number;
+    level: FarmEventLevel;
+    requestId?: string;
+    route?: string;
+    pathname?: string;
+}
+type FarmServerEvent = (FarmEventBase & {
+    type: "server.start";
+    mode: "dev" | "preview" | "production";
+    port?: number;
+}) | (FarmEventBase & {
+    type: "server.ready";
+    url?: string;
+}) | (FarmEventBase & {
+    type: "server.shutdown";
+    reason?: string;
+});
+type FarmRouteEvent = (FarmEventBase & {
+    type: "route.discovered";
+    route: string;
+    filePath: string;
+}) | (FarmEventBase & {
+    type: "route.matched";
+    pathname: string;
+    route: string;
+    params?: Record<string, string>;
+}) | (FarmEventBase & {
+    type: "route.notFound";
+    pathname: string;
+}) | (FarmEventBase & {
+    type: "route.redirect";
+    from: string;
+    to: string;
+    status?: number;
+}) | (FarmEventBase & {
+    type: "route.rewrite";
+    from: string;
+    to: string;
+});
+type FarmRenderEvent = (FarmEventBase & {
+    type: "render.start";
+    route: string;
+    pathname?: string;
+}) | (FarmEventBase & {
+    type: "render.complete";
+    route: string;
+    durationMs: number;
+    status?: number;
+}) | (FarmEventBase & {
+    type: "render.error";
+    route?: string;
+    error: unknown;
+}) | (FarmEventBase & {
+    type: "render.stream.start";
+    route: string;
+}) | (FarmEventBase & {
+    type: "render.stream.shellReady";
+    route: string;
+    durationMs: number;
+}) | (FarmEventBase & {
+    type: "render.stream.complete";
+    route: string;
+    durationMs: number;
+});
+type FarmCacheEvent = (FarmEventBase & {
+    type: "cache.hit";
+    key: string;
+    route?: string;
+    tags?: readonly string[];
+    revalidate?: number | false;
+    stale?: boolean;
+}) | (FarmEventBase & {
+    type: "cache.miss";
+    key: string;
+    route?: string;
+    reason?: string;
+}) | (FarmEventBase & {
+    type: "cache.set";
+    key: string;
+    route?: string;
+    tags?: readonly string[];
+    revalidate?: number | false;
+}) | (FarmEventBase & {
+    type: "cache.dedupe";
+    key: string;
+}) | (FarmEventBase & {
+    type: "cache.bypass";
+    key?: string;
+    route?: string;
+    reason: string;
+}) | (FarmEventBase & {
+    type: "cache.stale";
+    key: string;
+    route?: string;
+    tags?: readonly string[];
+    revalidate?: number | false;
+}) | (FarmEventBase & {
+    type: "cache.revalidatePath";
+    path: string;
+    count: number;
+}) | (FarmEventBase & {
+    type: "cache.revalidateTag";
+    tag: string;
+    profile?: unknown;
+    count: number;
+}) | (FarmEventBase & {
+    type: "cache.updateTag";
+    tag: string;
+    count: number;
+}) | (FarmEventBase & {
+    type: "cache.invalidated";
+    key?: string;
+    route?: string;
+    tag?: string;
+    reason?: string;
+    count?: number;
+}) | (FarmEventBase & {
+    type: "cache.delete";
+    key: string;
+    deleted: boolean;
+}) | (FarmEventBase & {
+    type: "cache.clear";
+    count: number;
+}) | (FarmEventBase & {
+    type: "cache.error";
+    key?: string;
+    operation: "get" | "set" | "delete" | "revalidate";
+    error: unknown;
+});
+type FarmPPREvent = (FarmEventBase & {
+    type: "ppr.shell.hit";
+    route: string;
+    key: string;
+}) | (FarmEventBase & {
+    type: "ppr.shell.miss";
+    route: string;
+    key: string;
+}) | (FarmEventBase & {
+    type: "ppr.shell.cached";
+    route: string;
+    key: string;
+    revalidate?: number;
+}) | (FarmEventBase & {
+    type: "ppr.shell.bypass";
+    route: string;
+    reason: string;
+}) | (FarmEventBase & {
+    type: "ppr.shell.invalidated";
+    route: string;
+    reason?: string;
+    count?: number;
+}) | (FarmEventBase & {
+    type: "ppr.suspense.holeDetected";
+    route: string;
+}) | (FarmEventBase & {
+    type: "ppr.refresh.start";
+    route: string;
+}) | (FarmEventBase & {
+    type: "ppr.refresh.complete";
+    route: string;
+    durationMs: number;
+}) | (FarmEventBase & {
+    type: "ppr.refresh.error";
+    route: string;
+    error: unknown;
+});
+type FarmAPIEvent = (FarmEventBase & {
+    type: "api.request.start";
+    route: string;
+    method: string;
+}) | (FarmEventBase & {
+    type: "api.request.complete";
+    route: string;
+    method: string;
+    status: number;
+    durationMs: number;
+}) | (FarmEventBase & {
+    type: "api.validation.failed";
+    route: string;
+    method: string;
+    issues?: unknown;
+}) | (FarmEventBase & {
+    type: "api.error";
+    route: string;
+    method: string;
+    error: unknown;
+});
+type FarmIntegrationEvent = (FarmEventBase & {
+    type: "integration.registered";
+    name: string;
+}) | (FarmEventBase & {
+    type: "integration.config.validated";
+    name: string;
+}) | (FarmEventBase & {
+    type: "integration.ready";
+    name: string;
+}) | (FarmEventBase & {
+    type: "integration.disposed";
+    name: string;
+}) | (FarmEventBase & {
+    type: "integration.api.call.start";
+    integration: string;
+    operation: string;
+}) | (FarmEventBase & {
+    type: "integration.api.call.complete";
+    integration: string;
+    operation: string;
+    durationMs: number;
+}) | (FarmEventBase & {
+    type: "integration.api.call.error";
+    integration: string;
+    operation: string;
+    error: unknown;
+}) | (FarmEventBase & {
+    type: "integration.webhook.received";
+    integration: string;
+    event?: string;
+}) | (FarmEventBase & {
+    type: "integration.webhook.verified";
+    integration: string;
+    event?: string;
+}) | (FarmEventBase & {
+    type: "integration.webhook.failed";
+    integration: string;
+    reason: string;
+});
+type FarmMiddlewareEvent = (FarmEventBase & {
+    type: "middleware.start";
+    route?: string;
+    name?: string;
+}) | (FarmEventBase & {
+    type: "middleware.complete";
+    route?: string;
+    name?: string;
+    durationMs: number;
+}) | (FarmEventBase & {
+    type: "middleware.shortCircuit";
+    route?: string;
+    name?: string;
+    status?: number;
+}) | (FarmEventBase & {
+    type: "middleware.error";
+    route?: string;
+    name?: string;
+    error: unknown;
+});
+type FarmStorageEvent = (FarmEventBase & {
+    type: "storage.query.start";
+    integration?: string;
+    operation: string;
+}) | (FarmEventBase & {
+    type: "storage.query.complete";
+    integration?: string;
+    operation: string;
+    durationMs: number;
+}) | (FarmEventBase & {
+    type: "storage.query.error";
+    integration?: string;
+    operation: string;
+    error: unknown;
+}) | (FarmEventBase & {
+    type: "storage.schema.ready";
+    integration?: string;
+}) | (FarmEventBase & {
+    type: "storage.schema.error";
+    integration?: string;
+    error: unknown;
+});
+type FarmBuildEvent = (FarmEventBase & {
+    type: "build.start";
+    target?: string;
+}) | (FarmEventBase & {
+    type: "build.complete";
+    target?: string;
+    durationMs: number;
+}) | (FarmEventBase & {
+    type: "build.error";
+    target?: string;
+    error: unknown;
+}) | (FarmEventBase & {
+    type: "routes.generated";
+    pageCount: number;
+    apiCount?: number;
+}) | (FarmEventBase & {
+    type: "types.generated";
+    filePath: string;
+}) | (FarmEventBase & {
+    type: "manifest.generated";
+    routeCount: number;
+});
+type FarmPluginEvent = (FarmEventBase & {
+    type: "plugin.hook.start";
+    plugin: string;
+    hook: string;
+}) | (FarmEventBase & {
+    type: "plugin.hook.complete";
+    plugin: string;
+    hook: string;
+    durationMs: number;
+}) | (FarmEventBase & {
+    type: "plugin.hook.error";
+    plugin: string;
+    hook: string;
+    error: unknown;
+});
+type FarmErrorEvent = FarmEventBase & {
+    type: "error";
+    source: string;
+    error: unknown;
+    route?: string;
+};
+type FarmEvent = FarmServerEvent | FarmRouteEvent | FarmRenderEvent | FarmCacheEvent | FarmPPREvent | FarmAPIEvent | FarmIntegrationEvent | FarmMiddlewareEvent | FarmStorageEvent | FarmBuildEvent | FarmPluginEvent | FarmErrorEvent;
+type FarmEventType = FarmEvent["type"];
+type FarmEventHandler = (event: FarmEvent) => void | Promise<void>;
+type FarmEventInput = FarmEvent extends infer T ? T extends FarmEvent ? Omit<T, "timestamp" | "level"> & Partial<Pick<T, "timestamp" | "level">> : never : never;
+type FarmObservabilityUserConfig = boolean | {
+    logs?: boolean;
+    onEvent?: FarmEventHandler | readonly FarmEventHandler[];
+    events?: readonly FarmEventType[];
+};
+interface FarmResolvedObservabilityConfig {
+    logs: boolean;
+    handlers: FarmEventHandler[];
+    events?: Set<FarmEventType>;
+}
+declare function configureFarmObservability(config: FarmObservabilityUserConfig | undefined): void;
+declare function normalizeFarmObservabilityConfig(config: FarmObservabilityUserConfig | undefined): FarmResolvedObservabilityConfig;
+declare function onFarmEvent(handler: FarmEventHandler): () => void;
+declare function resetFarmObservability(): void;
+declare function emitFarmEvent(input: FarmEventInput): FarmEvent;
+
+export { type FarmAPIEvent, type FarmBuildEvent, type FarmCacheEvent, type FarmErrorEvent, type FarmEvent, type FarmEventBase, type FarmEventHandler, type FarmEventInput, type FarmEventLevel, type FarmEventType, type FarmIntegrationEvent, type FarmMiddlewareEvent, type FarmObservabilityUserConfig, type FarmPPREvent, type FarmPluginEvent, type FarmRenderEvent, type FarmResolvedObservabilityConfig, type FarmRouteEvent, type FarmServerEvent, type FarmStorageEvent, configureFarmObservability, emitFarmEvent, normalizeFarmObservabilityConfig, onFarmEvent, resetFarmObservability };