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

package/dist/server-fn.d.ts

@@ -0,0 +1,121 @@
+import { FarmCacheInvalidationTarget } from './cache.js';
+import { S as ServerFnFailure, a as ServerActionError } from './server-fn-error-DDh14a0V.js';
+export { F as FARM_SERVER_FN_FAILURE_SYMBOL, b as SerializedServerFnFailure, c as createServerFnTransportError, i as isServerFnFailure } from './server-fn-error-DDh14a0V.js';
+
+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 };

package/dist/server-plugins.d.mts

@@ -0,0 +1,58 @@
+import { bi as RedirectConfig, x as FarmRequest, y as FarmResponse, aG as FarmPluginContext, $ as FarmPlugin, bj as HeaderConfig, bk as RewriteConfig } from './client-plugins-CCilIb_G.mjs';
+export { aI as FarmPluginLifecycle, aJ as FarmRequestPluginContext, aK as FarmRequestStore } from './client-plugins-CCilIb_G.mjs';
+import './plugin-BJDf43dc.mjs';
+import 'react';
+import 'http';
+import './types-D1A6-XvH.mjs';
+import 'db0';
+import 'unstorage';
+import './integration-api-CHT2OKAf.mjs';
+import '@farming-labs/orm';
+import './types-DTzm4TCl.mjs';
+import '@farming-labs/docs';
+import './markdown.mjs';
+import './observability.mjs';
+import 'vite';
+import './workflows-CusFV6mn.mjs';
+import './cron.mjs';
+import './env.mjs';
+import './server-action-security.mjs';
+import './server-fn-error-DDh14a0V.mjs';
+import './image-config-Duob7wER.mjs';
+import './types-BMxWr97v.mjs';
+import './cache.mjs';
+import './types-CsR8fpgF.mjs';
+import './route-runtime-DoOHzCAD.mjs';
+import './font.mjs';
+
+declare function createRedirectsPlugin(redirects: RedirectConfig[], { beforeRequest: overrideBeforeRequest, afterResponse: overrideAfterResponse, }?: {
+    beforeRequest?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+    afterResponse?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+}): FarmPlugin;
+
+declare function createHeadersPlugin(headers: HeaderConfig[], { beforeRequest: overrideBeforeRequest, afterResponse: overrideAfterResponse, }?: {
+    beforeRequest?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+    afterResponse?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+}): FarmPlugin;
+
+declare function createRewritesPlugin(rewrites: RewriteConfig[], { beforeRequest: overrideBeforeRequest, afterResponse: overrideAfterResponse, }?: {
+    beforeRequest?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+    afterResponse?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+}): FarmPlugin;
+
+declare function createEnvPlugin(env: Record<string, string>, { beforeRequest: overrideBeforeRequest, afterResponse: overrideAfterResponse, }?: {
+    beforeRequest?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+    afterResponse?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+}): FarmPlugin;
+
+declare function createCompressionPlugin({ beforeRequest: overrideBeforeRequest, afterResponse: overrideAfterResponse, }?: {
+    beforeRequest?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+    afterResponse?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+}): FarmPlugin;
+
+declare function createLoggerPlugin({ beforeRequest, afterResponse, }?: {
+    beforeRequest?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+    afterResponse?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+}): FarmPlugin;
+
+export { FarmPlugin, FarmPluginContext, HeaderConfig, RedirectConfig, RewriteConfig, createCompressionPlugin, createEnvPlugin, createHeadersPlugin, createLoggerPlugin, createRedirectsPlugin, createRewritesPlugin };

package/dist/server-plugins.d.ts

@@ -0,0 +1,58 @@
+import { bi as RedirectConfig, x as FarmRequest, y as FarmResponse, aG as FarmPluginContext, $ as FarmPlugin, bj as HeaderConfig, bk as RewriteConfig } from './client-plugins-DuuleQKk.js';
+export { aI as FarmPluginLifecycle, aJ as FarmRequestPluginContext, aK as FarmRequestStore } from './client-plugins-DuuleQKk.js';
+import './plugin-BJDf43dc.js';
+import 'react';
+import 'http';
+import './types-D1A6-XvH.js';
+import 'db0';
+import 'unstorage';
+import './integration-api-CHT2OKAf.js';
+import '@farming-labs/orm';
+import './types-DTzm4TCl.js';
+import '@farming-labs/docs';
+import './markdown.js';
+import './observability.js';
+import 'vite';
+import './workflows-CusFV6mn.js';
+import './cron.js';
+import './env.js';
+import './server-action-security.js';
+import './server-fn-error-DDh14a0V.js';
+import './image-config-Duob7wER.js';
+import './types-BMxWr97v.js';
+import './cache.js';
+import './types-CsR8fpgF.js';
+import './route-runtime-DoOHzCAD.js';
+import './font.js';
+
+declare function createRedirectsPlugin(redirects: RedirectConfig[], { beforeRequest: overrideBeforeRequest, afterResponse: overrideAfterResponse, }?: {
+    beforeRequest?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+    afterResponse?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+}): FarmPlugin;
+
+declare function createHeadersPlugin(headers: HeaderConfig[], { beforeRequest: overrideBeforeRequest, afterResponse: overrideAfterResponse, }?: {
+    beforeRequest?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+    afterResponse?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+}): FarmPlugin;
+
+declare function createRewritesPlugin(rewrites: RewriteConfig[], { beforeRequest: overrideBeforeRequest, afterResponse: overrideAfterResponse, }?: {
+    beforeRequest?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+    afterResponse?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+}): FarmPlugin;
+
+declare function createEnvPlugin(env: Record<string, string>, { beforeRequest: overrideBeforeRequest, afterResponse: overrideAfterResponse, }?: {
+    beforeRequest?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+    afterResponse?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+}): FarmPlugin;
+
+declare function createCompressionPlugin({ beforeRequest: overrideBeforeRequest, afterResponse: overrideAfterResponse, }?: {
+    beforeRequest?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+    afterResponse?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+}): FarmPlugin;
+
+declare function createLoggerPlugin({ beforeRequest, afterResponse, }?: {
+    beforeRequest?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+    afterResponse?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+}): FarmPlugin;
+
+export { FarmPlugin, FarmPluginContext, HeaderConfig, RedirectConfig, RewriteConfig, createCompressionPlugin, createEnvPlugin, createHeadersPlugin, createLoggerPlugin, createRedirectsPlugin, createRewritesPlugin };

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

@@ -0,0 +1,51 @@
+import { a as FarmClientCacheStatus } from './client-cache-D-EZ7XVW.mjs';
+import { ServerQuery } from './server-query.mjs';
+import './cache.mjs';
+import './server-fn.mjs';
+import './server-fn-error-DDh14a0V.mjs';
+
+declare const FARM_SERVER_QUERY_RESULT_VERSION: 1;
+type FarmServerQueryResult<TData> = {
+    __farmServerQuery: {
+        version: typeof FARM_SERVER_QUERY_RESULT_VERSION;
+        key: string;
+        staleTime: number | false;
+        updatedAt: number;
+    };
+    data: TData;
+};
+
+type ServerQueryFetchOptions = {
+    /** Used only when a non-Farm transport returns plain data. Farm transports use the declaration. */
+    staleTime?: number | false;
+    /** Return stale data immediately while refreshing it in the background. Default true. */
+    swr?: boolean;
+    /** Always wait for a new result. */
+    force?: boolean;
+};
+type UseServerQueryOptions = ServerQueryFetchOptions & {
+    enabled?: boolean;
+    refetchOnWindowFocus?: boolean;
+    refetchOnReconnect?: boolean;
+};
+type UseServerQueryResult<TData> = {
+    data: TData | undefined;
+    error: Error | null;
+    status: FarmClientCacheStatus;
+    pending: boolean;
+    fetching: boolean;
+    stale: boolean;
+    refetch: () => Promise<TData>;
+};
+type FarmServerQueryActionInvocation = {
+    actionId: string;
+    args: readonly unknown[];
+    provisionalKey?: string;
+};
+declare function beginFarmServerQueryAction(actionId: string, args: readonly unknown[]): FarmServerQueryActionInvocation;
+declare function completeFarmServerQueryAction<TData>(invocation: FarmServerQueryActionInvocation, value: TData | FarmServerQueryResult<TData>): TData;
+declare function fetchServerQuery<TInput, TData>(query: ServerQuery<TInput, TData>, input: TInput, options?: ServerQueryFetchOptions): Promise<TData>;
+declare function prefetchServerQuery<TInput, TData>(query: ServerQuery<TInput, TData>, input: TInput, options?: Omit<ServerQueryFetchOptions, "force">): Promise<TData>;
+declare function useServerQuery<TInput, TData>(query: ServerQuery<TInput, TData>, input: TInput, options?: UseServerQueryOptions): UseServerQueryResult<TData>;
+
+export { type FarmServerQueryActionInvocation, type ServerQueryFetchOptions, type UseServerQueryOptions, type UseServerQueryResult, beginFarmServerQueryAction, completeFarmServerQueryAction, fetchServerQuery, prefetchServerQuery, useServerQuery };

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

@@ -0,0 +1,51 @@
+import { a as FarmClientCacheStatus } from './client-cache-CIlyBlmx.js';
+import { ServerQuery } from './server-query.js';
+import './cache.js';
+import './server-fn.js';
+import './server-fn-error-DDh14a0V.js';
+
+declare const FARM_SERVER_QUERY_RESULT_VERSION: 1;
+type FarmServerQueryResult<TData> = {
+    __farmServerQuery: {
+        version: typeof FARM_SERVER_QUERY_RESULT_VERSION;
+        key: string;
+        staleTime: number | false;
+        updatedAt: number;
+    };
+    data: TData;
+};
+
+type ServerQueryFetchOptions = {
+    /** Used only when a non-Farm transport returns plain data. Farm transports use the declaration. */
+    staleTime?: number | false;
+    /** Return stale data immediately while refreshing it in the background. Default true. */
+    swr?: boolean;
+    /** Always wait for a new result. */
+    force?: boolean;
+};
+type UseServerQueryOptions = ServerQueryFetchOptions & {
+    enabled?: boolean;
+    refetchOnWindowFocus?: boolean;
+    refetchOnReconnect?: boolean;
+};
+type UseServerQueryResult<TData> = {
+    data: TData | undefined;
+    error: Error | null;
+    status: FarmClientCacheStatus;
+    pending: boolean;
+    fetching: boolean;
+    stale: boolean;
+    refetch: () => Promise<TData>;
+};
+type FarmServerQueryActionInvocation = {
+    actionId: string;
+    args: readonly unknown[];
+    provisionalKey?: string;
+};
+declare function beginFarmServerQueryAction(actionId: string, args: readonly unknown[]): FarmServerQueryActionInvocation;
+declare function completeFarmServerQueryAction<TData>(invocation: FarmServerQueryActionInvocation, value: TData | FarmServerQueryResult<TData>): TData;
+declare function fetchServerQuery<TInput, TData>(query: ServerQuery<TInput, TData>, input: TInput, options?: ServerQueryFetchOptions): Promise<TData>;
+declare function prefetchServerQuery<TInput, TData>(query: ServerQuery<TInput, TData>, input: TInput, options?: Omit<ServerQueryFetchOptions, "force">): Promise<TData>;
+declare function useServerQuery<TInput, TData>(query: ServerQuery<TInput, TData>, input: TInput, options?: UseServerQueryOptions): UseServerQueryResult<TData>;
+
+export { type FarmServerQueryActionInvocation, type ServerQueryFetchOptions, type UseServerQueryOptions, type UseServerQueryResult, beginFarmServerQueryAction, completeFarmServerQueryAction, fetchServerQuery, prefetchServerQuery, useServerQuery };

package/dist/server-query.d.mts

@@ -0,0 +1,37 @@
+import { RouteDataCacheKey } from './cache.mjs';
+import { ServerFnContext, ServerFnSchema, AnyServerFnMiddleware, InferServerFnSchemaOutput, ServerFnMiddlewareContext, ServerFnHandler, InferServerFnSchemaInput } from './server-fn.mjs';
+import './server-fn-error-DDh14a0V.mjs';
+
+type MaybePromise<T> = T | Promise<T>;
+type ServerQueryStaleTime = number | false | `${number}${"ms" | "s" | "m" | "h"}`;
+type ServerQueryKey<TInput, TContext extends object = {}> = (context: ServerFnContext<TInput, TContext>) => MaybePromise<RouteDataCacheKey>;
+type ServerQueryOptions<TSchema extends ServerFnSchema | undefined, TResult, TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []> = {
+    input?: TSchema;
+    output?: undefined;
+    middleware?: TMiddlewares;
+    key: ServerQueryKey<TSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TSchema> : unknown, ServerFnMiddlewareContext<TMiddlewares>>;
+    /** Milliseconds, a duration string such as "30s", or false for no expiry. */
+    staleTime?: ServerQueryStaleTime;
+    handler: ServerFnHandler<TSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TSchema> : unknown, TResult, ServerFnMiddlewareContext<TMiddlewares>>;
+};
+type ServerQueryOutputOptions<TInputSchema extends ServerFnSchema | undefined, TOutputSchema extends ServerFnSchema, TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []> = {
+    input?: TInputSchema;
+    output: TOutputSchema;
+    middleware?: TMiddlewares;
+    key: ServerQueryKey<TInputSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TInputSchema> : unknown, ServerFnMiddlewareContext<TMiddlewares>>;
+    /** Milliseconds, a duration string such as "30s", or false for no expiry. */
+    staleTime?: ServerQueryStaleTime;
+    handler: ServerFnHandler<TInputSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TInputSchema> : unknown, unknown, ServerFnMiddlewareContext<TMiddlewares>>;
+};
+type ServerQuery<TInput, TResult> = ([unknown] extends [TInput] ? (input?: TInput) => Promise<TResult> : (input: TInput) => Promise<TResult>) & {
+    readonly __farmServerQuery: true;
+    readonly __farmServerQueryInput?: unknown;
+    readonly __farmServerQueryOutput?: unknown;
+};
+declare const FARM_SERVER_QUERY_SYMBOL: unique symbol;
+declare function createServerQuery<TInputSchema extends ServerFnSchema, TOutputSchema extends ServerFnSchema, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []>(options: ServerQueryOutputOptions<TInputSchema, TOutputSchema, TMiddlewares>): ServerQuery<InferServerFnSchemaInput<TInputSchema>, Awaited<InferServerFnSchemaOutput<TOutputSchema>>>;
+declare function createServerQuery<TOutputSchema extends ServerFnSchema, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []>(options: ServerQueryOutputOptions<undefined, TOutputSchema, TMiddlewares>): ServerQuery<unknown, Awaited<InferServerFnSchemaOutput<TOutputSchema>>>;
+declare function createServerQuery<TSchema extends ServerFnSchema, TResult, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []>(options: ServerQueryOptions<TSchema, TResult, TMiddlewares>): ServerQuery<InferServerFnSchemaInput<TSchema>, Awaited<TResult>>;
+declare function createServerQuery<TResult, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []>(options: ServerQueryOptions<undefined, TResult, TMiddlewares>): ServerQuery<unknown, Awaited<TResult>>;
+
+export { FARM_SERVER_QUERY_SYMBOL, type ServerQuery, type ServerQueryKey, type ServerQueryOptions, type ServerQueryOutputOptions, type ServerQueryStaleTime, createServerQuery };

package/dist/server-query.d.ts

@@ -0,0 +1,37 @@
+import { RouteDataCacheKey } from './cache.js';
+import { ServerFnContext, ServerFnSchema, AnyServerFnMiddleware, InferServerFnSchemaOutput, ServerFnMiddlewareContext, ServerFnHandler, InferServerFnSchemaInput } from './server-fn.js';
+import './server-fn-error-DDh14a0V.js';
+
+type MaybePromise<T> = T | Promise<T>;
+type ServerQueryStaleTime = number | false | `${number}${"ms" | "s" | "m" | "h"}`;
+type ServerQueryKey<TInput, TContext extends object = {}> = (context: ServerFnContext<TInput, TContext>) => MaybePromise<RouteDataCacheKey>;
+type ServerQueryOptions<TSchema extends ServerFnSchema | undefined, TResult, TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []> = {
+    input?: TSchema;
+    output?: undefined;
+    middleware?: TMiddlewares;
+    key: ServerQueryKey<TSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TSchema> : unknown, ServerFnMiddlewareContext<TMiddlewares>>;
+    /** Milliseconds, a duration string such as "30s", or false for no expiry. */
+    staleTime?: ServerQueryStaleTime;
+    handler: ServerFnHandler<TSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TSchema> : unknown, TResult, ServerFnMiddlewareContext<TMiddlewares>>;
+};
+type ServerQueryOutputOptions<TInputSchema extends ServerFnSchema | undefined, TOutputSchema extends ServerFnSchema, TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []> = {
+    input?: TInputSchema;
+    output: TOutputSchema;
+    middleware?: TMiddlewares;
+    key: ServerQueryKey<TInputSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TInputSchema> : unknown, ServerFnMiddlewareContext<TMiddlewares>>;
+    /** Milliseconds, a duration string such as "30s", or false for no expiry. */
+    staleTime?: ServerQueryStaleTime;
+    handler: ServerFnHandler<TInputSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TInputSchema> : unknown, unknown, ServerFnMiddlewareContext<TMiddlewares>>;
+};
+type ServerQuery<TInput, TResult> = ([unknown] extends [TInput] ? (input?: TInput) => Promise<TResult> : (input: TInput) => Promise<TResult>) & {
+    readonly __farmServerQuery: true;
+    readonly __farmServerQueryInput?: unknown;
+    readonly __farmServerQueryOutput?: unknown;
+};
+declare const FARM_SERVER_QUERY_SYMBOL: unique symbol;
+declare function createServerQuery<TInputSchema extends ServerFnSchema, TOutputSchema extends ServerFnSchema, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []>(options: ServerQueryOutputOptions<TInputSchema, TOutputSchema, TMiddlewares>): ServerQuery<InferServerFnSchemaInput<TInputSchema>, Awaited<InferServerFnSchemaOutput<TOutputSchema>>>;
+declare function createServerQuery<TOutputSchema extends ServerFnSchema, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []>(options: ServerQueryOutputOptions<undefined, TOutputSchema, TMiddlewares>): ServerQuery<unknown, Awaited<InferServerFnSchemaOutput<TOutputSchema>>>;
+declare function createServerQuery<TSchema extends ServerFnSchema, TResult, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []>(options: ServerQueryOptions<TSchema, TResult, TMiddlewares>): ServerQuery<InferServerFnSchemaInput<TSchema>, Awaited<TResult>>;
+declare function createServerQuery<TResult, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []>(options: ServerQueryOptions<undefined, TResult, TMiddlewares>): ServerQuery<unknown, Awaited<TResult>>;
+
+export { FARM_SERVER_QUERY_SYMBOL, type ServerQuery, type ServerQueryKey, type ServerQueryOptions, type ServerQueryOutputOptions, type ServerQueryStaleTime, createServerQuery };