@farm.js/core 0.1.0-beta.21 → 0.1.0-beta.23

package/dist/runtime-Q3u74Nbq.d.mts

@@ -0,0 +1,231 @@
+import { FarmCacheInvalidationTarget } from './cache.mjs';
+import { M as MultipartSchema, T as TypedFormData } from './transport-BmbGTXA5.mjs';
+
+type AnySchema = {
+    _output?: any;
+    _input?: any;
+    parse?: (data: unknown) => any;
+};
+type MaybePromise<T> = T | Promise<T>;
+type Simplify<T> = {
+    [TKey in keyof T]: T[TKey];
+} & {};
+type UnionToIntersection<T> = (T extends unknown ? (value: T) => void : never) extends (value: infer TIntersection) => void ? TIntersection : never;
+type InferOutput<T> = T extends {
+    _output: infer O;
+} ? O : T extends {
+    parse: (data: unknown) => infer R;
+} ? R : unknown;
+type InferInput<T> = T extends {
+    _input: infer I;
+} ? I : T extends {
+    parse: (data: infer I) => unknown;
+} ? I : unknown;
+type InferBodyInput<T> = T extends MultipartSchema<AnySchema> ? TypedFormData<InferOutput<T>> : InferOutput<T>;
+type InferHeadersOutput<T> = [T] extends [never] ? Record<string, string> : T extends AnySchema ? InferOutput<T> : Record<string, string>;
+type EndpointErrorSchema = AnySchema & {
+    parse: (data: unknown) => unknown;
+};
+type EndpointErrorDefinitionBase<TStatus extends number> = {
+    status: TStatus;
+    /** Public message safe to expose to API callers. */
+    message?: string;
+};
+type EndpointErrorDefinition<TSchema extends EndpointErrorSchema = EndpointErrorSchema, TStatus extends number = number> = EndpointErrorDefinitionBase<TStatus> & ({
+    /** Schema for the public error payload exposed to API callers. */
+    data: TSchema;
+    schema?: never;
+} | {
+    data?: never;
+    /** @deprecated Use `data` for consistency with server functions. */
+    schema: TSchema;
+});
+type EndpointErrorDefinitions = Record<string, EndpointErrorDefinition<EndpointErrorSchema, number>>;
+type InferEndpointErrorSchema<TDefinition> = TDefinition extends {
+    data: infer TSchema extends AnySchema;
+} ? TSchema : TDefinition extends {
+    schema: infer TSchema extends AnySchema;
+} ? TSchema : never;
+type EndpointErrorContracts<TErrors extends EndpointErrorDefinitions> = {
+    [TCode in keyof TErrors]: {
+        data: InferOutput<InferEndpointErrorSchema<TErrors[TCode]>>;
+        status: TErrors[TCode]["status"];
+    };
+};
+type EndpointErrorHandler<TErrors extends EndpointErrorDefinitions> = <TCode extends keyof TErrors & string>(code: TCode, data: InferInput<InferEndpointErrorSchema<TErrors[TCode]>>) => never;
+/** @deprecated Use `EndpointErrorHandler`. */
+type EndpointFail<TErrors extends EndpointErrorDefinitions> = EndpointErrorHandler<TErrors>;
+declare class EndpointFailure<TCode extends string = string, TData = unknown> extends Error {
+    readonly code: TCode;
+    readonly data: TData;
+    readonly status: number;
+    constructor(code: TCode, data: TData, options: {
+        status: number;
+        message: string;
+    });
+}
+declare function isEndpointFailure(value: unknown): value is EndpointFailure<string, unknown>;
+type EndpointParamValue = string | string[];
+type EndpointParams = Record<string, EndpointParamValue>;
+type EndpointMiddlewareContext<TContext extends object = {}, TBody = unknown, TQuery = unknown, THeaders = Record<string, string>> = {
+    body: TBody;
+    query: TQuery;
+    headers: THeaders;
+    request: Request;
+    /** Context accumulated from middleware that ran earlier in the chain. */
+    context: Readonly<TContext>;
+    params: EndpointParams;
+};
+type EndpointMiddlewareResult<TProvidedContext extends object = object> = TProvidedContext | true | false | Response;
+/** A plain async function. No wrapper or `next()` callback is required. */
+type EndpointMiddleware<TProvidedContext extends object = object, TContext extends object = {}, TBody = unknown, TQuery = unknown, THeaders = Record<string, string>> = (ctx: EndpointMiddlewareContext<TContext, TBody, TQuery, THeaders>) => MaybePromise<EndpointMiddlewareResult<TProvidedContext>>;
+type AnyEndpointMiddleware = (ctx: EndpointMiddlewareContext<any, any, any, any>) => unknown;
+type EndpointInvalidationTarget = FarmCacheInvalidationTarget;
+type EndpointInvalidationContext<TContext extends object = {}, TBody = unknown, TQuery = unknown, THeaders = Record<string, string>> = EndpointMiddlewareContext<TContext, TBody, TQuery, THeaders> & {
+    /** The raw value returned by the endpoint handler. */
+    result: unknown;
+};
+type EndpointInvalidations<TContext extends object = {}, TBody = unknown, TQuery = unknown, THeaders = Record<string, string>> = readonly EndpointInvalidationTarget[] | ((context: EndpointInvalidationContext<TContext, TBody, TQuery, THeaders>) => readonly EndpointInvalidationTarget[] | Promise<readonly EndpointInvalidationTarget[]>);
+type ValidateEndpointMiddlewares<TMiddlewares extends readonly AnyEndpointMiddleware[]> = {
+    readonly [TIndex in keyof TMiddlewares]: TMiddlewares[TIndex] extends AnyEndpointMiddleware ? [Awaited<ReturnType<TMiddlewares[TIndex]>>] extends [EndpointMiddlewareResult<object>] ? TMiddlewares[TIndex] : never : never;
+};
+type ContextFromMiddlewareResult<TResult> = Exclude<TResult, Response | boolean> extends infer TContext ? [TContext] extends [never] ? {} : TContext extends object ? TContext : {} : {};
+type ContextFromMiddleware<TMiddleware> = TMiddleware extends (...args: any[]) => infer TResult ? ContextFromMiddlewareResult<Awaited<TResult>> : {};
+type InferEndpointMiddlewareContext<TMiddlewares extends readonly ((...args: any[]) => any)[], TContext extends object = {}> = TMiddlewares extends readonly [infer TMiddleware, ...infer TRest] ? TMiddleware extends (...args: any[]) => any ? TRest extends readonly ((...args: any[]) => any)[] ? InferEndpointMiddlewareContext<TRest, Simplify<TContext & ContextFromMiddleware<TMiddleware>>> : Simplify<TContext> : Simplify<TContext> : number extends TMiddlewares["length"] ? Simplify<TContext & UnionToIntersection<ContextFromMiddleware<TMiddlewares[number]>>> : Simplify<TContext>;
+type EndpointOptions<TBody extends AnySchema = never, TQuery extends AnySchema = never, THeaders extends AnySchema = never, TMiddlewares extends readonly AnyEndpointMiddleware[] = readonly [], TErrors extends EndpointErrorDefinitions = {}> = {
+    method?: "GET" | "HEAD" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS";
+    body?: TBody;
+    query?: TQuery;
+    headers?: THeaders;
+    middleware?: TMiddlewares;
+    /**
+     * Cache keys, tags, and route paths made stale after a successful handler result.
+     * The resolver receives validated input and middleware context.
+     */
+    invalidates?: EndpointInvalidations<InferEndpointMiddlewareContext<TMiddlewares>, InferOutput<TBody>, InferOutput<TQuery>, InferHeadersOutput<THeaders>>;
+    errors?: TErrors;
+    /** @deprecated Use plain functions in `middleware` for Farm endpoint middleware. */
+    use?: any[];
+};
+type EndpointHandler<TBody extends AnySchema = never, TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any, TContext extends object = {}, TErrors extends EndpointErrorDefinitions = {}> = (ctx: {
+    body: InferOutput<TBody>;
+    query: InferOutput<TQuery>;
+    headers: InferHeadersOutput<THeaders>;
+    request: Request;
+    context: Readonly<TContext>;
+    params: EndpointParams;
+    error: EndpointErrorHandler<TErrors>;
+    /** @deprecated Use `error`. */
+    fail: EndpointFail<TErrors>;
+}) => Promise<TResponse> | TResponse;
+type TypedEndpoint<TBody = never, TQuery = never, TResponse = any, THeaders = Record<string, string>, TErrors = never, TBodyInput = TBody> = {
+    __types: {
+        body: TBody;
+        inputBody: TBodyInput;
+        query: TQuery;
+        headers: THeaders;
+        response: TResponse;
+        errors: TErrors;
+    };
+    __path?: string;
+    __method?: string;
+} & ((options?: {
+    body?: TBody;
+    query?: TQuery;
+}) => Promise<TResponse>);
+type CreatedEndpoint<TBody extends AnySchema, TQuery extends AnySchema, THeaders extends AnySchema, TResponse, TErrors extends EndpointErrorDefinitions = {}> = TypedEndpoint<InferOutput<TBody>, InferOutput<TQuery>, Awaited<TResponse>, InferHeadersOutput<THeaders>, EndpointErrorContracts<TErrors>, InferBodyInput<TBody>>;
+type AnyEndpointOptions = EndpointOptions<AnySchema, AnySchema, AnySchema, readonly AnyEndpointMiddleware[], EndpointErrorDefinitions>;
+type EndpointBodyFromOptions<TOptions> = TOptions extends {
+    body: infer TBody extends AnySchema;
+} ? TBody : never;
+type EndpointQueryFromOptions<TOptions> = TOptions extends {
+    query: infer TQuery extends AnySchema;
+} ? TQuery : never;
+type EndpointHeadersFromOptions<TOptions> = TOptions extends {
+    headers: infer THeaders extends AnySchema;
+} ? THeaders : never;
+type EndpointMiddlewaresFromOptions<TOptions> = TOptions extends {
+    middleware: infer TMiddlewares extends readonly AnyEndpointMiddleware[];
+} ? TMiddlewares : readonly [];
+type EndpointErrorsFromOptions<TOptions> = TOptions extends {
+    errors: infer TErrors extends EndpointErrorDefinitions;
+} ? TErrors : {};
+type MethodlessEndpointOptions = Omit<AnyEndpointOptions, "method">;
+type EndpointHandlerFromOptions<TOptions, TResponse> = EndpointHandler<EndpointBodyFromOptions<TOptions>, EndpointQueryFromOptions<TOptions>, EndpointHeadersFromOptions<TOptions>, TResponse, InferEndpointMiddlewareContext<EndpointMiddlewaresFromOptions<TOptions>>, EndpointErrorsFromOptions<TOptions>>;
+type ValidatedEndpointHandlerFromOptions<TOptions, TResponse> = EndpointHandlerFromOptions<TOptions, TResponse> & (EndpointMiddlewaresFromOptions<TOptions> extends ValidateEndpointMiddlewares<EndpointMiddlewaresFromOptions<TOptions>> ? unknown : never);
+type CreatedEndpointFromOptions<TOptions, TResponse> = CreatedEndpoint<EndpointBodyFromOptions<TOptions>, EndpointQueryFromOptions<TOptions>, EndpointHeadersFromOptions<TOptions>, TResponse, EndpointErrorsFromOptions<TOptions>>;
+/**
+ * Create a Farm.js API endpoint
+ *
+ * Supports two patterns:
+ * 1. File-based routing (path auto-inferred from file location):
+ *    `export const POST = createEndpoint({ method: 'POST', body: schema }, handler)`
+ *    `createEndpoint({ method: 'GET', query: z.object({...}) }, handler)`
+ *
+ * 2. Explicit path (for routes.ts at project root):
+ *    `createEndpoint('/api/hello', { method: 'GET', query: z.object({...}) }, handler)`
+ */
+declare function createEndpoint<const TOptions extends AnyEndpointOptions, TResponse = any>(options: TOptions, handler: ValidatedEndpointHandlerFromOptions<TOptions, TResponse>): CreatedEndpointFromOptions<TOptions, TResponse>;
+declare function createEndpoint<const TOptions extends AnyEndpointOptions, TResponse = any>(path: string, options: TOptions, handler: ValidatedEndpointHandlerFromOptions<TOptions, TResponse>): CreatedEndpointFromOptions<TOptions, TResponse>;
+declare function createEndpoint<TBody extends AnySchema = never, TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any>(options: EndpointOptions<TBody, TQuery, THeaders, readonly []>, handler: EndpointHandler<TBody, TQuery, THeaders, TResponse>): CreatedEndpoint<TBody, TQuery, THeaders, TResponse>;
+declare function createEndpoint<TBody extends AnySchema = never, TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any>(path: string, options: EndpointOptions<TBody, TQuery, THeaders, readonly []>, handler: EndpointHandler<TBody, TQuery, THeaders, TResponse>): CreatedEndpoint<TBody, TQuery, THeaders, TResponse>;
+/**
+ * Convenience method for GET requests
+ */
+declare function GET<T = any>(handler: EndpointHandler<never, never, never, T>): CreatedEndpoint<never, never, never, T>;
+declare function GET<const TOptions extends MethodlessEndpointOptions, TResponse = any>(options: TOptions, handler: ValidatedEndpointHandlerFromOptions<TOptions, TResponse>): CreatedEndpointFromOptions<TOptions, TResponse>;
+declare function GET<TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any>(options: Omit<EndpointOptions<never, TQuery, THeaders, readonly []>, "method">, handler: EndpointHandler<never, TQuery, THeaders, TResponse>): CreatedEndpoint<never, TQuery, THeaders, TResponse>;
+/**
+ * Convenience method for HEAD requests
+ */
+declare function HEAD<T = any>(handler: EndpointHandler<never, never, never, T>): CreatedEndpoint<never, never, never, T>;
+declare function HEAD<const TOptions extends MethodlessEndpointOptions, TResponse = any>(options: TOptions, handler: ValidatedEndpointHandlerFromOptions<TOptions, TResponse>): CreatedEndpointFromOptions<TOptions, TResponse>;
+declare function HEAD<TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any>(options: Omit<EndpointOptions<never, TQuery, THeaders, readonly []>, "method">, handler: EndpointHandler<never, TQuery, THeaders, TResponse>): CreatedEndpoint<never, TQuery, THeaders, TResponse>;
+/**
+ * Convenience method for POST requests
+ */
+declare function POST<T = any>(handler: EndpointHandler<never, never, never, T>): CreatedEndpoint<never, never, never, T>;
+declare function POST<const TOptions extends MethodlessEndpointOptions, TResponse = any>(options: TOptions, handler: ValidatedEndpointHandlerFromOptions<TOptions, TResponse>): CreatedEndpointFromOptions<TOptions, TResponse>;
+declare function POST<TBody extends AnySchema = never, TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any>(options: Omit<EndpointOptions<TBody, TQuery, THeaders, readonly []>, "method">, handler: EndpointHandler<TBody, TQuery, THeaders, TResponse>): CreatedEndpoint<TBody, TQuery, THeaders, TResponse>;
+/**
+ * Convenience method for PUT requests
+ */
+declare function PUT<T = any>(handler: EndpointHandler<never, never, never, T>): CreatedEndpoint<never, never, never, T>;
+declare function PUT<const TOptions extends MethodlessEndpointOptions, TResponse = any>(options: TOptions, handler: ValidatedEndpointHandlerFromOptions<TOptions, TResponse>): CreatedEndpointFromOptions<TOptions, TResponse>;
+declare function PUT<TBody extends AnySchema = never, TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any>(options: Omit<EndpointOptions<TBody, TQuery, THeaders, readonly []>, "method">, handler: EndpointHandler<TBody, TQuery, THeaders, TResponse>): CreatedEndpoint<TBody, TQuery, THeaders, TResponse>;
+/**
+ * Convenience method for DELETE requests
+ */
+declare function DELETE<T = any>(handler: EndpointHandler<never, never, never, T>): CreatedEndpoint<never, never, never, T>;
+declare function DELETE<const TOptions extends MethodlessEndpointOptions, TResponse = any>(options: TOptions, handler: ValidatedEndpointHandlerFromOptions<TOptions, TResponse>): CreatedEndpointFromOptions<TOptions, TResponse>;
+declare function DELETE<TBody extends AnySchema = never, TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any>(options: Omit<EndpointOptions<TBody, TQuery, THeaders, readonly []>, "method">, handler: EndpointHandler<TBody, TQuery, THeaders, TResponse>): CreatedEndpoint<TBody, TQuery, THeaders, TResponse>;
+/**
+ * Convenience method for PATCH requests
+ */
+declare function PATCH<T = any>(handler: EndpointHandler<never, never, never, T>): CreatedEndpoint<never, never, never, T>;
+declare function PATCH<const TOptions extends MethodlessEndpointOptions, TResponse = any>(options: TOptions, handler: ValidatedEndpointHandlerFromOptions<TOptions, TResponse>): CreatedEndpointFromOptions<TOptions, TResponse>;
+declare function PATCH<TBody extends AnySchema = never, TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any>(options: Omit<EndpointOptions<TBody, TQuery, THeaders, readonly []>, "method">, handler: EndpointHandler<TBody, TQuery, THeaders, TResponse>): CreatedEndpoint<TBody, TQuery, THeaders, TResponse>;
+/**
+ * Convenience method for OPTIONS requests
+ */
+declare function OPTIONS<T = any>(handler: EndpointHandler<never, never, never, T>): CreatedEndpoint<never, never, never, T>;
+declare function OPTIONS<const TOptions extends MethodlessEndpointOptions, TResponse = any>(options: TOptions, handler: ValidatedEndpointHandlerFromOptions<TOptions, TResponse>): CreatedEndpointFromOptions<TOptions, TResponse>;
+declare function OPTIONS<TBody extends AnySchema = never, TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any>(options: Omit<EndpointOptions<TBody, TQuery, THeaders, readonly []>, "method">, handler: EndpointHandler<TBody, TQuery, THeaders, TResponse>): CreatedEndpoint<TBody, TQuery, THeaders, TResponse>;
+
+type APIRouteParamValue = string | string[];
+type APIRouteParams = Record<string, APIRouteParamValue>;
+interface APIRouteMatch<T extends {
+    path: string;
+}> {
+    route: T;
+    params: APIRouteParams;
+}
+declare function matchAPIRoute<T extends {
+    path: string;
+}>(routes: Map<string, T>, pathname: string): APIRouteMatch<T> | null;
+declare function invokeAPIRouteEndpoint(endpoint: any, request: Request, params?: APIRouteParams, bodySizeLimit?: number): Promise<Response>;
+declare function normalizeRouteResponse(result: unknown): Response;
+declare function isWebResponse(value: unknown): value is Response;
+declare function createEndpointFailureResponse(failure: EndpointFailure<string, unknown>): Response;
+
+export { type APIRouteMatch as A, PATCH as B, createEndpointFailureResponse as C, DELETE as D, type EndpointErrorSchema as E, GET as G, HEAD as H, type InferEndpointMiddlewareContext as I, OPTIONS as O, POST as P, type TypedEndpoint as T, isWebResponse as a, type APIRouteParams as b, type APIRouteParamValue as c, type EndpointErrorDefinition as d, type EndpointErrorDefinitions as e, type EndpointErrorContracts as f, type EndpointErrorHandler as g, type EndpointFail as h, invokeAPIRouteEndpoint as i, EndpointFailure as j, isEndpointFailure as k, type EndpointParamValue as l, matchAPIRoute as m, normalizeRouteResponse as n, type EndpointParams as o, type EndpointMiddlewareContext as p, type EndpointMiddlewareResult as q, type EndpointMiddleware as r, type AnyEndpointMiddleware as s, type EndpointInvalidationTarget as t, type EndpointInvalidationContext as u, type EndpointInvalidations as v, type EndpointOptions as w, type EndpointHandler as x, createEndpoint as y, PUT as z };

package/dist/runtime-bv63eUiO.d.ts

@@ -0,0 +1,27 @@
+import { F as FarmLocaleResolution } from './resolver-IH4RmPEl.js';
+import { R as ResolvedFarmI18nConfig, F as FarmI18nCatalogs, a as FarmI18nClientSnapshot } from './types-BMxWr97v.js';
+
+declare class FarmI18nRuntime {
+    readonly config: ResolvedFarmI18nConfig;
+    private catalogs;
+    private compiled;
+    private warnedMissing;
+    constructor(config: ResolvedFarmI18nConfig, catalogs?: FarmI18nCatalogs);
+    initialize(): Promise<void>;
+    reload(): Promise<void>;
+    replaceCatalogs(catalogs: FarmI18nCatalogs): void;
+    getCatalogs(): FarmI18nCatalogs;
+    resolveRequest(request: Request, options?: {
+        redirect?: boolean;
+    }): FarmLocaleResolution;
+    translate(locale: string, key: string, values?: Record<string, unknown>): string;
+    translateRich(locale: string, key: string, values?: Record<string, unknown>): unknown;
+    getRawMessage(locale: string, key: string): string;
+    hasMessage(locale: string, key: string): boolean;
+    getClientSnapshot(resolution: FarmLocaleResolution): FarmI18nClientSnapshot;
+    private formatMessage;
+    private resolveMessage;
+}
+declare function createFarmI18nRuntime(config: ResolvedFarmI18nConfig, catalogs?: FarmI18nCatalogs): FarmI18nRuntime;
+
+export { FarmI18nRuntime as F, createFarmI18nRuntime as c };

package/dist/server-action-security.d.mts

@@ -0,0 +1,45 @@
+import { b as SerializedServerFnFailure } from './server-fn-error-DDh14a0V.mjs';
+
+declare const DEFAULT_SERVER_ACTION_BODY_SIZE_LIMIT = 1000000;
+interface FarmServerActionsConfig {
+    /** Additional trusted origins or host patterns, such as https://app.example.com. */
+    allowedOrigins?: readonly string[];
+    /** Maximum encoded request body size in bytes or as a size string such as "1mb". */
+    bodySizeLimit?: number | string;
+}
+interface ResolvedFarmServerActionsConfig {
+    allowedOrigins: readonly string[];
+    bodySizeLimit: number;
+}
+type ServerActionRequestKind = "javascript" | "form";
+interface PreparedServerActionRequest {
+    body: string | FormData;
+    contentType: string;
+}
+type SanitizedServerActionError = {
+    name: "ServerActionError";
+    message: "Server function failed";
+} | SerializedServerFnFailure;
+type ServerActionRequestErrorCode = "BODY_TOO_LARGE" | "INVALID_ACTION_ID" | "INVALID_BODY" | "INVALID_CONTENT_LENGTH" | "INVALID_METHOD" | "INVALID_ORIGIN" | "MISSING_ORIGIN" | "UNSUPPORTED_CONTENT_TYPE";
+declare class ServerActionRequestError extends Error {
+    readonly code: ServerActionRequestErrorCode;
+    readonly status: number;
+    constructor(code: ServerActionRequestErrorCode, status: number, message: string);
+}
+type ServerActionExecutionContext = {
+    request: Request;
+    signal: AbortSignal;
+    invalidations: Set<string>;
+    cacheTasks: Set<Promise<void>>;
+};
+declare function resolveServerActionsConfig(config: FarmServerActionsConfig | undefined): ResolvedFarmServerActionsConfig;
+declare function validateServerActionRequest(request: Request, config: ResolvedFarmServerActionsConfig): void;
+declare function prepareServerActionRequest(request: Request, config: ResolvedFarmServerActionsConfig, kind: ServerActionRequestKind, actionId?: string | null): Promise<PreparedServerActionRequest>;
+declare function createServerActionRequestErrorResponse(error: unknown): Response | null;
+declare function sanitizeServerActionError(error: unknown): SanitizedServerActionError;
+declare function runWithServerActionRequest<T>(request: Request, callback: () => T | Promise<T>): Promise<T>;
+declare function getServerActionExecutionContext(): ServerActionExecutionContext | undefined;
+declare function getServerActionSignal(): AbortSignal;
+declare function getServerActionInvalidations(): readonly string[];
+
+export { DEFAULT_SERVER_ACTION_BODY_SIZE_LIMIT, type FarmServerActionsConfig, type PreparedServerActionRequest, type ResolvedFarmServerActionsConfig, type SanitizedServerActionError, ServerActionRequestError, type ServerActionRequestKind, createServerActionRequestErrorResponse, getServerActionExecutionContext, getServerActionInvalidations, getServerActionSignal, prepareServerActionRequest, resolveServerActionsConfig, runWithServerActionRequest, sanitizeServerActionError, validateServerActionRequest };

package/dist/server-action-security.d.ts

@@ -0,0 +1,45 @@
+import { b as SerializedServerFnFailure } from './server-fn-error-DDh14a0V.js';
+
+declare const DEFAULT_SERVER_ACTION_BODY_SIZE_LIMIT = 1000000;
+interface FarmServerActionsConfig {
+    /** Additional trusted origins or host patterns, such as https://app.example.com. */
+    allowedOrigins?: readonly string[];
+    /** Maximum encoded request body size in bytes or as a size string such as "1mb". */
+    bodySizeLimit?: number | string;
+}
+interface ResolvedFarmServerActionsConfig {
+    allowedOrigins: readonly string[];
+    bodySizeLimit: number;
+}
+type ServerActionRequestKind = "javascript" | "form";
+interface PreparedServerActionRequest {
+    body: string | FormData;
+    contentType: string;
+}
+type SanitizedServerActionError = {
+    name: "ServerActionError";
+    message: "Server function failed";
+} | SerializedServerFnFailure;
+type ServerActionRequestErrorCode = "BODY_TOO_LARGE" | "INVALID_ACTION_ID" | "INVALID_BODY" | "INVALID_CONTENT_LENGTH" | "INVALID_METHOD" | "INVALID_ORIGIN" | "MISSING_ORIGIN" | "UNSUPPORTED_CONTENT_TYPE";
+declare class ServerActionRequestError extends Error {
+    readonly code: ServerActionRequestErrorCode;
+    readonly status: number;
+    constructor(code: ServerActionRequestErrorCode, status: number, message: string);
+}
+type ServerActionExecutionContext = {
+    request: Request;
+    signal: AbortSignal;
+    invalidations: Set<string>;
+    cacheTasks: Set<Promise<void>>;
+};
+declare function resolveServerActionsConfig(config: FarmServerActionsConfig | undefined): ResolvedFarmServerActionsConfig;
+declare function validateServerActionRequest(request: Request, config: ResolvedFarmServerActionsConfig): void;
+declare function prepareServerActionRequest(request: Request, config: ResolvedFarmServerActionsConfig, kind: ServerActionRequestKind, actionId?: string | null): Promise<PreparedServerActionRequest>;
+declare function createServerActionRequestErrorResponse(error: unknown): Response | null;
+declare function sanitizeServerActionError(error: unknown): SanitizedServerActionError;
+declare function runWithServerActionRequest<T>(request: Request, callback: () => T | Promise<T>): Promise<T>;
+declare function getServerActionExecutionContext(): ServerActionExecutionContext | undefined;
+declare function getServerActionSignal(): AbortSignal;
+declare function getServerActionInvalidations(): readonly string[];
+
+export { DEFAULT_SERVER_ACTION_BODY_SIZE_LIMIT, type FarmServerActionsConfig, type PreparedServerActionRequest, type ResolvedFarmServerActionsConfig, type SanitizedServerActionError, ServerActionRequestError, type ServerActionRequestKind, createServerActionRequestErrorResponse, getServerActionExecutionContext, getServerActionInvalidations, getServerActionSignal, prepareServerActionRequest, resolveServerActionsConfig, runWithServerActionRequest, sanitizeServerActionError, validateServerActionRequest };

package/dist/server-fn-client.d.mts

@@ -0,0 +1,33 @@
+import { ServerFn } from './server-fn.mjs';
+import './cache.mjs';
+import './server-fn-error-DDh14a0V.mjs';
+
+type ServerFnActionStatus = "idle" | "pending" | "success" | "error";
+type ServerFnSubmit<TInput, TResult> = [unknown] extends [TInput] ? (input?: TInput | FormData) => Promise<TResult> : (input: TInput | FormData) => Promise<TResult>;
+type ServerFnOptimisticContext<TInput, TResult> = {
+    input: TInput | FormData | undefined;
+    formData?: FormData;
+    current: TResult | null;
+};
+type UseServerFnOptions<TResult, TError extends Error = Error, TInput = unknown> = {
+    initialResult?: TResult | null;
+    resetOnSubmit?: boolean;
+    throwOnFormError?: boolean;
+    optimistic?: (context: ServerFnOptimisticContext<TInput, TResult>) => TResult | null | undefined;
+    rollbackOnError?: boolean;
+    onSuccess?: (result: TResult) => void;
+    onError?: (error: TError) => void;
+    onSettled?: (result: TResult | null, error: TError | null) => void;
+};
+type UseServerFnReturn<TInput, TResult, TError extends Error = Error> = {
+    pending: boolean;
+    status: ServerFnActionStatus;
+    result: TResult | null;
+    error: TError | null;
+    submit: ServerFnSubmit<TInput, TResult>;
+    formAction: (formData: FormData) => Promise<void>;
+    reset: () => void;
+};
+declare function useServerFn<TInput, TResult, TError extends Error = Error>(serverFn: ServerFn<TInput, TResult, TError>, options?: UseServerFnOptions<TResult, TError, TInput>): UseServerFnReturn<TInput, TResult, TError>;
+
+export { type ServerFnActionStatus, type ServerFnOptimisticContext, type ServerFnSubmit, type UseServerFnOptions, type UseServerFnReturn, useServerFn };

package/dist/server-fn-client.d.ts

@@ -0,0 +1,33 @@
+import { ServerFn } from './server-fn.js';
+import './cache.js';
+import './server-fn-error-DDh14a0V.js';
+
+type ServerFnActionStatus = "idle" | "pending" | "success" | "error";
+type ServerFnSubmit<TInput, TResult> = [unknown] extends [TInput] ? (input?: TInput | FormData) => Promise<TResult> : (input: TInput | FormData) => Promise<TResult>;
+type ServerFnOptimisticContext<TInput, TResult> = {
+    input: TInput | FormData | undefined;
+    formData?: FormData;
+    current: TResult | null;
+};
+type UseServerFnOptions<TResult, TError extends Error = Error, TInput = unknown> = {
+    initialResult?: TResult | null;
+    resetOnSubmit?: boolean;
+    throwOnFormError?: boolean;
+    optimistic?: (context: ServerFnOptimisticContext<TInput, TResult>) => TResult | null | undefined;
+    rollbackOnError?: boolean;
+    onSuccess?: (result: TResult) => void;
+    onError?: (error: TError) => void;
+    onSettled?: (result: TResult | null, error: TError | null) => void;
+};
+type UseServerFnReturn<TInput, TResult, TError extends Error = Error> = {
+    pending: boolean;
+    status: ServerFnActionStatus;
+    result: TResult | null;
+    error: TError | null;
+    submit: ServerFnSubmit<TInput, TResult>;
+    formAction: (formData: FormData) => Promise<void>;
+    reset: () => void;
+};
+declare function useServerFn<TInput, TResult, TError extends Error = Error>(serverFn: ServerFn<TInput, TResult, TError>, options?: UseServerFnOptions<TResult, TError, TInput>): UseServerFnReturn<TInput, TResult, TError>;
+
+export { type ServerFnActionStatus, type ServerFnOptimisticContext, type ServerFnSubmit, type UseServerFnOptions, type UseServerFnReturn, useServerFn };

package/dist/server-fn-error-DDh14a0V.d.mts

@@ -0,0 +1,26 @@
+declare const FARM_SERVER_FN_FAILURE_SYMBOL: unique symbol;
+type SerializedServerFnFailure = {
+    name: "ServerFnFailure";
+    message: string;
+    code: string;
+    status: number;
+    data: unknown;
+};
+declare class ServerFnFailure<TCode extends string = string, TData = unknown, TStatus extends number = number> extends Error {
+    readonly name: "ServerFnFailure";
+    readonly code: TCode;
+    readonly data: TData;
+    readonly status: TStatus;
+    constructor(code: TCode, data: TData, options: {
+        status: TStatus;
+        message: string;
+    });
+}
+declare class ServerActionError extends Error {
+    readonly name: "ServerActionError";
+    constructor(message?: string);
+}
+declare function isServerFnFailure(value: unknown): value is ServerFnFailure;
+declare function createServerFnTransportError(value: unknown): ServerFnFailure | ServerActionError;
+
+export { FARM_SERVER_FN_FAILURE_SYMBOL as F, ServerFnFailure as S, ServerActionError as a, type SerializedServerFnFailure as b, createServerFnTransportError as c, isServerFnFailure as i };

package/dist/server-fn-error-DDh14a0V.d.ts

@@ -0,0 +1,26 @@
+declare const FARM_SERVER_FN_FAILURE_SYMBOL: unique symbol;
+type SerializedServerFnFailure = {
+    name: "ServerFnFailure";
+    message: string;
+    code: string;
+    status: number;
+    data: unknown;
+};
+declare class ServerFnFailure<TCode extends string = string, TData = unknown, TStatus extends number = number> extends Error {
+    readonly name: "ServerFnFailure";
+    readonly code: TCode;
+    readonly data: TData;
+    readonly status: TStatus;
+    constructor(code: TCode, data: TData, options: {
+        status: TStatus;
+        message: string;
+    });
+}
+declare class ServerActionError extends Error {
+    readonly name: "ServerActionError";
+    constructor(message?: string);
+}
+declare function isServerFnFailure(value: unknown): value is ServerFnFailure;
+declare function createServerFnTransportError(value: unknown): ServerFnFailure | ServerActionError;
+
+export { FARM_SERVER_FN_FAILURE_SYMBOL as F, ServerFnFailure as S, ServerActionError as a, type SerializedServerFnFailure as b, createServerFnTransportError as c, isServerFnFailure as i };

package/dist/server-fn.d.mts

@@ -0,0 +1,121 @@
+import { FarmCacheInvalidationTarget } from './cache.mjs';
+import { S as ServerFnFailure, a as ServerActionError } from './server-fn-error-DDh14a0V.mjs';
+export { F as FARM_SERVER_FN_FAILURE_SYMBOL, b as SerializedServerFnFailure, c as createServerFnTransportError, i as isServerFnFailure } from './server-fn-error-DDh14a0V.mjs';
+
+type MaybePromise<T> = T | Promise<T>;
+type ServerFnSchema = {
+    _input?: any;
+    _output?: any;
+    parse?: (data: unknown) => any;
+    parseAsync?: (data: unknown) => Promise<any>;
+    safeParse?: (data: unknown) => any;
+    safeParseAsync?: (data: unknown) => Promise<any>;
+};
+type InferServerFnSchemaInput<T> = T extends {
+    _input: infer I;
+} ? I : unknown;
+type InferServerFnSchemaOutput<T> = T extends {
+    _output: infer O;
+} ? O : T extends {
+    parse: (data: unknown) => infer R;
+} ? R : unknown;
+type ServerFnErrorSchema = ServerFnSchema & ({
+    parse: (data: unknown) => unknown;
+} | {
+    safeParse: (data: unknown) => unknown;
+});
+type ServerFnErrorDefinition<TSchema extends ServerFnErrorSchema = ServerFnErrorSchema, TStatus extends number = number> = {
+    status: TStatus;
+    /** Schema for the public error payload exposed to callers. */
+    data: TSchema;
+    /** Public message safe to expose to callers. */
+    message?: string;
+};
+type ServerFnErrorDefinitions = Record<string, ServerFnErrorDefinition<ServerFnErrorSchema, number>>;
+type ServerFnDeclaredError<TErrors extends ServerFnErrorDefinitions> = {
+    [TCode in keyof TErrors]: ServerFnFailure<TCode & string, InferServerFnSchemaOutput<TErrors[TCode]["data"]>, TErrors[TCode]["status"]>;
+}[keyof TErrors];
+type ServerFnError<TErrors extends ServerFnErrorDefinitions> = keyof TErrors extends never ? Error : ServerActionError | ServerFnDeclaredError<TErrors>;
+type ServerFnErrorHandler<TErrors extends ServerFnErrorDefinitions> = <TCode extends keyof TErrors & string>(code: TCode, data: InferServerFnSchemaInput<TErrors[TCode]["data"]>) => never;
+type ServerFnFormInput = FormData;
+type Simplify<T> = {
+    [TKey in keyof T]: T[TKey];
+} & {};
+type AssignContext<TCurrent extends object, TNext extends object> = Simplify<Omit<TCurrent, keyof TNext> & TNext>;
+type MiddlewareContext<TMiddleware> = TMiddleware extends ServerFnMiddleware<infer TContext> ? TContext : {};
+type ServerFnMiddlewareContext<TMiddlewares extends readonly AnyServerFnMiddleware[], TContext extends object = {}> = TMiddlewares extends readonly [infer TMiddleware, ...infer TRest] ? TMiddleware extends AnyServerFnMiddleware ? TRest extends readonly AnyServerFnMiddleware[] ? ServerFnMiddlewareContext<TRest, AssignContext<TContext, MiddlewareContext<TMiddleware>>> : TContext : TContext : number extends TMiddlewares["length"] ? Simplify<TContext & MiddlewareContext<TMiddlewares[number]>> : Simplify<TContext>;
+declare const SERVER_FN_MIDDLEWARE_CONTEXT: unique symbol;
+type ServerFnMiddlewareContinuation<TContext extends object = {}> = {
+    readonly [SERVER_FN_MIDDLEWARE_CONTEXT]: TContext;
+};
+type ServerFnMiddlewareNext = <TContext extends object = {}>(options?: {
+    context?: TContext;
+}) => Promise<ServerFnMiddlewareContinuation<TContext>>;
+type ServerFnContext<TInput, TContext extends object = {}> = {
+    input: TInput;
+    rawInput: unknown;
+    formData?: FormData;
+    /** The action request when invoked across the network. Undefined for direct server calls. */
+    request?: Request;
+    /** Aborts when the underlying action request is cancelled. */
+    signal: AbortSignal;
+    /** Context produced by this server function's middleware chain. */
+    context: Readonly<TContext>;
+};
+type ServerFnHandlerContext<TInput, TContext extends object = {}, TErrors extends ServerFnErrorDefinitions = {}> = ServerFnContext<TInput, TContext> & {
+    /** Return a declared, validated error from this server function. */
+    error: ServerFnErrorHandler<TErrors>;
+};
+type ServerFnHandler<TInput, TResult, TContext extends object = {}, TErrors extends ServerFnErrorDefinitions = {}> = (ctx: ServerFnHandlerContext<TInput, TContext, TErrors>) => MaybePromise<TResult>;
+type ServerFnInvalidationContext<TInput, TResult, TContext extends object = {}> = ServerFnContext<TInput, TContext> & {
+    /** Parsed value returned by the successful server function. */
+    result: TResult;
+};
+type ServerFnInvalidations<TInput, TResult, TContext extends object = {}> = readonly FarmCacheInvalidationTarget[] | ((context: ServerFnInvalidationContext<TInput, TResult, TContext>) => readonly FarmCacheInvalidationTarget[] | Promise<readonly FarmCacheInvalidationTarget[]>);
+type ServerFnMiddlewareHandlerContext<TContext extends object = {}> = ServerFnContext<unknown, TContext> & {
+    next: ServerFnMiddlewareNext;
+};
+type ServerFnMiddlewareHandler<TContext extends object = {}, TProvidedContext extends object = {}> = (ctx: ServerFnMiddlewareHandlerContext<TContext>) => MaybePromise<ServerFnMiddlewareContinuation<TProvidedContext>>;
+type ServerFnMiddleware<TContext extends object = {}> = {
+    readonly __farmServerFnMiddleware: true;
+    readonly __farmServerFnMiddlewareContext?: TContext;
+    readonly middleware: readonly AnyServerFnMiddleware[];
+    readonly handler: ServerFnMiddlewareHandler<any, any>;
+};
+type AnyServerFnMiddleware = ServerFnMiddleware<any>;
+type ServerFnMiddlewareOptions<TMiddlewares extends readonly AnyServerFnMiddleware[], TProvidedContext extends object> = {
+    middleware?: TMiddlewares;
+    handler: ServerFnMiddlewareHandler<ServerFnMiddlewareContext<TMiddlewares>, TProvidedContext>;
+};
+type ServerFnOptions<TSchema extends ServerFnSchema | undefined, TResult, TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly [], TErrors extends ServerFnErrorDefinitions = {}> = {
+    input?: TSchema;
+    output?: undefined;
+    middleware?: TMiddlewares;
+    errors?: TErrors;
+    invalidates?: ServerFnInvalidations<TSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TSchema> : unknown, Awaited<TResult>, ServerFnMiddlewareContext<TMiddlewares>>;
+    handler: ServerFnHandler<TSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TSchema> : unknown, TResult, ServerFnMiddlewareContext<TMiddlewares>, TErrors>;
+};
+type ServerFnOutputOptions<TInputSchema extends ServerFnSchema | undefined, TOutputSchema extends ServerFnSchema, TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly [], TErrors extends ServerFnErrorDefinitions = {}> = {
+    input?: TInputSchema;
+    output: TOutputSchema;
+    middleware?: TMiddlewares;
+    errors?: TErrors;
+    invalidates?: ServerFnInvalidations<TInputSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TInputSchema> : unknown, Awaited<InferServerFnSchemaOutput<TOutputSchema>>, ServerFnMiddlewareContext<TMiddlewares>>;
+    handler: ServerFnHandler<TInputSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TInputSchema> : unknown, unknown, ServerFnMiddlewareContext<TMiddlewares>, TErrors>;
+};
+type ServerFn<TInput, TResult, TError extends Error = Error> = ([unknown] extends [TInput] ? (input?: TInput | FormData) => Promise<TResult> : (input: TInput | FormData) => Promise<TResult>) & {
+    readonly __farmServerFn: true;
+    readonly __farmServerFnInput?: unknown;
+    readonly __farmServerFnOutput?: unknown;
+    readonly __farmServerFnError: TError;
+};
+type InferServerFnError<TServerFn> = TServerFn extends ServerFn<any, any, infer TError> ? TError : Error;
+declare const FARM_SERVER_FN_SYMBOL: unique symbol;
+declare function createServerMiddleware<const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly [], TProvidedContext extends object = {}>(options: ServerFnMiddlewareOptions<TMiddlewares, TProvidedContext>): ServerFnMiddleware<AssignContext<ServerFnMiddlewareContext<TMiddlewares>, TProvidedContext>>;
+declare function createServerFn<TInputSchema extends ServerFnSchema, TOutputSchema extends ServerFnSchema, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly [], const TErrors extends ServerFnErrorDefinitions = {}>(options: ServerFnOutputOptions<TInputSchema, TOutputSchema, TMiddlewares, TErrors>): ServerFn<InferServerFnSchemaInput<TInputSchema>, Awaited<InferServerFnSchemaOutput<TOutputSchema>>, ServerFnError<TErrors>>;
+declare function createServerFn<TOutputSchema extends ServerFnSchema, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly [], const TErrors extends ServerFnErrorDefinitions = {}>(options: ServerFnOutputOptions<undefined, TOutputSchema, TMiddlewares, TErrors>): ServerFn<unknown, Awaited<InferServerFnSchemaOutput<TOutputSchema>>, ServerFnError<TErrors>>;
+declare function createServerFn<TSchema extends ServerFnSchema, TResult, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly [], const TErrors extends ServerFnErrorDefinitions = {}>(options: ServerFnOptions<TSchema, TResult, TMiddlewares, TErrors>): ServerFn<InferServerFnSchemaInput<TSchema>, Awaited<TResult>, ServerFnError<TErrors>>;
+declare function createServerFn<TResult, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly [], const TErrors extends ServerFnErrorDefinitions = {}>(options: ServerFnOptions<undefined, TResult, TMiddlewares, TErrors>): ServerFn<unknown, Awaited<TResult>, ServerFnError<TErrors>>;
+declare function _parseServerFnSchema(schema: ServerFnSchema | undefined, value: unknown, contract: "input" | "output", owner?: string): Promise<any>;
+
+export { type AnyServerFnMiddleware, FARM_SERVER_FN_SYMBOL, type InferServerFnError, type InferServerFnSchemaInput, type InferServerFnSchemaOutput, ServerActionError, type ServerFn, type ServerFnContext, type ServerFnDeclaredError, type ServerFnError, type ServerFnErrorDefinition, type ServerFnErrorDefinitions, type ServerFnErrorHandler, type ServerFnErrorSchema, ServerFnFailure, type ServerFnFormInput, type ServerFnHandler, type ServerFnHandlerContext, type ServerFnInvalidationContext, type ServerFnInvalidations, type ServerFnMiddleware, type ServerFnMiddlewareContext, type ServerFnMiddlewareContinuation, type ServerFnMiddlewareHandler, type ServerFnMiddlewareHandlerContext, type ServerFnMiddlewareNext, type ServerFnMiddlewareOptions, type ServerFnOptions, type ServerFnOutputOptions, type ServerFnSchema, _parseServerFnSchema, createServerFn, createServerMiddleware };