use-server-action 1.1.3 → 2.0.0

package/README.md

@@ -16,26 +16,30 @@ npm install use-server-action
 // app/actions.ts
 "use server";
 
-import { serverAction, success, error } from "use-server-action/server";
+import { createAction, createContextMiddleware } from "use-server-action/server";
 
-export const createUser = serverAction(async (name: string) => {
-    if (!name.trim()) {
-        throw new Error("Name is required");
-    }
+// Simple action
+export const createUser = createAction<{ name: string }>()
+    .handle(async (ctx, input) => {
+        const user = await db.user.create({ data: { name: input.name } });
+        return { ok: true, data: user };
+    });
 
-    const user = await db.user.create({ data: { name } });
-    return user;
+// With authentication middleware
+const withAuth = createContextMiddleware(async (next, ctx, ...args) => {
+    const user = await getUser();
+    if (!user) {
+        return { ok: false, message: "Unauthorized", code: "UNAUTHORIZED" };
+    }
+    return next({ ...ctx, user }, ...args);
 });
 
-// Or handle errors manually for more control:
-export const deleteUserAction = async (id: string) => {
-    try {
-        await db.user.delete({ where: { id } });
-        return success({ deleted: true });
-    } catch (e) {
-        return error("Failed to delete user", "DELETE_FAILED");
-    }
-};
+export const deleteUser = createAction<{ id: string }>()
+    .use(withAuth)
+    .handle(async (ctx, input) => {
+        await db.user.delete({ where: { id: input.id, ownerId: ctx.user.id } });
+        return { ok: true, data: { deleted: true } };
+    });
 ```
 
 ### 2. Use in a client component
@@ -47,26 +51,14 @@ import { useServerAction } from "use-server-action";
 import { createUser } from "./actions";
 
 export function CreateUserForm() {
-    const {
-        execute,
-        data,
-        error,
-        isPending,
-        isSuccess,
-        isError,
-        reset,
-    } = useServerAction({
+    const { execute, data, error, isPending, isSuccess, isError } = useServerAction({
         action: createUser,
-        onSuccess: (user) => {
-            console.log("User created:", user);
-        },
-        onError: (message, code) => {
-            console.error(`Error [${code}]:`, message);
-        },
+        onSuccess: (user) => console.log("User created:", user),
+        onError: (message, code) => console.error(`Error [${code}]:`, message),
     });
 
     return (
-        <form action={(formData) => execute(formData.get("name") as string)}>
+        <form action={(formData) => execute({ name: formData.get("name") as string })}>
             <input name="name" placeholder="Name" disabled={isPending} />
             <button type="submit" disabled={isPending}>
                 {isPending ? "Creating..." : "Create User"}
@@ -78,6 +70,14 @@ export function CreateUserForm() {
 }
 ```
 
+## Features
+
+- **Type-safe** - Full TypeScript support with inferred types for context and inputs
+- **Middleware support** - Chain middleware with `createAction().use(middleware)`
+- **Context accumulation** - Middleware can add typed context for downstream handlers
+- **Automatic error handling** - Thrown errors are caught and returned as error results
+- **Zod validation** - Built-in `withZodValidation` middleware for input validation
+
 ## Documentation
 
 You can view the documentation [here](https://use-server-action.jackh.sh)

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { S as ServerActionResult } from './server-action-HthxxP-Y.mjs';
-export { b as ServerActionError, c as ServerActionFn, a as ServerActionSuccess } from './server-action-HthxxP-Y.mjs';
+import { S as ServerActionResult } from './server-action-Cm80HhlX.mjs';
+export { b as ServerActionError, c as ServerActionFn, a as ServerActionSuccess } from './server-action-Cm80HhlX.mjs';
 
 type UseServerActionInput<P extends unknown[], T> = {
     action: (...args: P) => Promise<ServerActionResult<T>>;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { S as ServerActionResult } from './server-action-HthxxP-Y.js';
-export { b as ServerActionError, c as ServerActionFn, a as ServerActionSuccess } from './server-action-HthxxP-Y.js';
+import { S as ServerActionResult } from './server-action-Cm80HhlX.js';
+export { b as ServerActionError, c as ServerActionFn, a as ServerActionSuccess } from './server-action-Cm80HhlX.js';
 
 type UseServerActionInput<P extends unknown[], T> = {
     action: (...args: P) => Promise<ServerActionResult<T>>;

package/dist/{server-action-HthxxP-Y.d.mts → server-action-Cm80HhlX.d.mts}

@@ -17,6 +17,24 @@ type ServerActionOptions = {
 /**
  * Wraps an async function to return a standardized ServerActionResult.
  * Catches any thrown errors and converts them to error results.
+ *
+ * @deprecated Use `createAction().input(schema).handle(fn)` instead.
+ * The new API provides better type inference and built-in validation.
+ *
+ * @example
+ * ```ts
+ * // Old way (deprecated):
+ * const myAction = serverAction(async (input: MyInput) => {
+ *     return await doSomething(input);
+ * });
+ *
+ * // New way:
+ * const myAction = createAction()
+ *     .input(mySchema)
+ *     .handle(async (ctx, input) => {
+ *         return { ok: true, data: await doSomething(input) };
+ *     });
+ * ```
  */
 declare function serverAction<P extends unknown[], T>(fn: (...args: P) => Promise<T>, options?: ServerActionOptions): ServerActionFn<P, T>;
 /**

package/dist/{server-action-HthxxP-Y.d.ts → server-action-Cm80HhlX.d.ts}

@@ -17,6 +17,24 @@ type ServerActionOptions = {
 /**
  * Wraps an async function to return a standardized ServerActionResult.
  * Catches any thrown errors and converts them to error results.
+ *
+ * @deprecated Use `createAction().input(schema).handle(fn)` instead.
+ * The new API provides better type inference and built-in validation.
+ *
+ * @example
+ * ```ts
+ * // Old way (deprecated):
+ * const myAction = serverAction(async (input: MyInput) => {
+ *     return await doSomething(input);
+ * });
+ *
+ * // New way:
+ * const myAction = createAction()
+ *     .input(mySchema)
+ *     .handle(async (ctx, input) => {
+ *         return { ok: true, data: await doSomething(input) };
+ *     });
+ * ```
  */
 declare function serverAction<P extends unknown[], T>(fn: (...args: P) => Promise<T>, options?: ServerActionOptions): ServerActionFn<P, T>;
 /**

package/dist/server.d.mts

@@ -1,11 +1,191 @@
-import { S as ServerActionResult } from './server-action-HthxxP-Y.mjs';
-export { b as ServerActionError, c as ServerActionFn, a as ServerActionSuccess, e as error, f as isError, i as isSuccess, s as serverAction, d as success, u as unwrap, g as unwrapOr } from './server-action-HthxxP-Y.mjs';
+import { S as ServerActionResult } from './server-action-Cm80HhlX.mjs';
+export { b as ServerActionError, c as ServerActionFn, a as ServerActionSuccess, e as error, f as isError, i as isSuccess, s as serverAction, d as success, u as unwrap, g as unwrapOr } from './server-action-Cm80HhlX.mjs';
 
+/**
+ * Base context type - all contexts extend from this
+ */
+type BaseContext = Record<string, unknown>;
 /**
  * A middleware function that wraps a server action.
  * Receives the next function in the chain and the parameters passed to the action.
  */
 type Middleware<P extends unknown[], T> = (next: (...params: P) => Promise<ServerActionResult<T>>, ...params: P) => Promise<ServerActionResult<T>>;
+/**
+ * A context-aware middleware that can receive context from previous middleware
+ * and add new context for downstream middleware.
+ *
+ * @template P - The parameter types for the action
+ * @template T - The return type of the action
+ * @template CtxIn - The context type this middleware expects to receive
+ * @template CtxOut - The context type this middleware adds (merged with CtxIn for next)
+ */
+type ContextMiddleware<P extends unknown[], T, CtxIn extends BaseContext = BaseContext, CtxOut extends BaseContext = BaseContext> = (next: (ctx: CtxIn & CtxOut, ...params: P) => Promise<ServerActionResult<T>>, ctx: CtxIn, ...params: P) => Promise<ServerActionResult<T>>;
+/**
+ * A Zod-like schema interface for validation.
+ * Works with Zod, Valibot, or any schema library with a compatible safeParse method.
+ */
+type ValidationSchema<T> = {
+    safeParse(data: unknown): {
+        success: true;
+        data: T;
+    } | {
+        success: false;
+        error: {
+            message?: string;
+            errors?: Array<{
+                message: string;
+            }>;
+        };
+    };
+};
+type WithValidationOptions = {
+    /** Error code to return on validation failure. Defaults to "VALIDATION_ERROR" */
+    code?: string;
+    /** Custom error message formatter */
+    formatError?: (error: {
+        message?: string;
+        errors?: Array<{
+            message: string;
+        }>;
+    }) => string;
+};
+
+/**
+ * Creates a type-safe context-aware middleware.
+ *
+ * @example
+ * ```ts
+ * type User = { id: string; name: string };
+ *
+ * const withAuth = createContextMiddleware<
+ *     [string],           // Parameters
+ *     SomeReturnType,     // Return type
+ *     {},                 // Input context (none required)
+ *     { user: User }      // Output context (adds user)
+ * >(async (next, ctx, input) => {
+ *     const user = await authenticate();
+ *     if (!user) {
+ *         return { ok: false, message: "Unauthorized", code: "UNAUTHORIZED" };
+ *     }
+ *     // Pass the new context with user added
+ *     return next({ ...ctx, user }, input);
+ * });
+ * ```
+ */
+declare function createContextMiddleware<P extends unknown[], T, CtxIn extends BaseContext = BaseContext, CtxOut extends BaseContext = BaseContext>(handler: ContextMiddleware<P, T, CtxIn, CtxOut>): ContextMiddleware<P, T, CtxIn, CtxOut>;
+
+/**
+ * A builder for creating server actions with type-safe context accumulation.
+ *
+ * @template TInput - The input parameters as a tuple type
+ * @template TContext - The accumulated context type from all middleware
+ */
+declare class ActionBuilder<TInput extends unknown[] = unknown[], TContext extends BaseContext = {}> {
+    private middlewares;
+    private constructor();
+    /**
+     * Create a new ActionBuilder instance
+     */
+    static create<TInput extends unknown[]>(): ActionBuilder<TInput, {}>;
+    /**
+     * Add a context-aware middleware to the chain.
+     * The middleware receives the accumulated context and can add new context.
+     *
+     * @example
+     * ```ts
+     * const withUser = createContextMiddleware(async (next, ctx, ...args) => {
+     *     const user = await getUser();
+     *     if (!user) {
+     *         return { ok: false, message: "Unauthorized", code: "UNAUTHORIZED" };
+     *     }
+     *     return next({ ...ctx, user }, ...args);
+     * });
+     *
+     * const action = createAction<[{ name: string }]>()
+     *     .use(withUser)
+     *     .handle(async (ctx, input) => {
+     *         // ctx.user is fully typed!
+     *     });
+     * ```
+     */
+    use<CtxOut extends BaseContext>(middleware: ContextMiddleware<TInput, any, TContext, CtxOut>): ActionBuilder<TInput, TContext & CtxOut>;
+    /**
+     * Add a regular (non-context) middleware to the chain.
+     * The middleware can transform input/output but doesn't modify context.
+     *
+     * @example
+     * ```ts
+     * const withLogging = createMiddleware(async (next, ...args) => {
+     *     console.log("Args:", args);
+     *     const result = await next(...args);
+     *     console.log("Result:", result);
+     *     return result;
+     * });
+     *
+     * const action = createAction<[string]>()
+     *     .use(withLogging)
+     *     .handle(async (ctx, input) => { ... });
+     * ```
+     */
+    use(middleware: Middleware<TInput, any>): ActionBuilder<TInput, TContext>;
+    /**
+     * Define the action handler. This finalizes the builder and returns the executable action.
+     * The handler receives the accumulated context and input parameters.
+     *
+     * @example
+     * ```ts
+     * const action = createAction<[{ name: string; email: string }]>()
+     *     .use(withUser)
+     *     .handle(async (ctx, input) => {
+     *         // ctx and input are fully typed
+     *         return { ok: true, data: result };
+     *     });
+     *
+     * // Call the action
+     * const result = await action({ name: "John", email: "john@example.com" });
+     * ```
+     */
+    handle<TOutput>(handler: (ctx: TContext, ...args: TInput) => Promise<ServerActionResult<TOutput>>): (...args: TInput) => Promise<ServerActionResult<TOutput>>;
+}
+/**
+ * Converts a type to a tuple of arguments.
+ * - `void` becomes `[]` (no args)
+ * - Single type `T` becomes `[T]`
+ * - Tuple type `[A, B]` stays as `[A, B]`
+ */
+type ToArgs<T> = [T] extends [void] ? [] : T extends unknown[] ? T : [T];
+/**
+ * Creates a new action builder with type-safe context accumulation.
+ *
+ * @example
+ * ```ts
+ * // Single input parameter
+ * const createUser = createAction<{ name: string; email: string }>()
+ *     .use(withUser)
+ *     .handle(async (ctx, input) => {
+ *         await db.users.create({ ...input, createdBy: ctx.user.id });
+ *         return { ok: true, data: { success: true } };
+ *     });
+ *
+ * // Multiple input parameters (use tuple)
+ * const updateUser = createAction<[string, { name: string }]>()
+ *     .use(withUser)
+ *     .handle(async (ctx, id, data) => {
+ *         await db.users.update(id, data);
+ *         return { ok: true, data: { success: true } };
+ *     });
+ *
+ * // With validation middleware
+ * const createPost = createAction<z.infer<typeof postSchema>>()
+ *     .use(withZodValidation(postSchema))
+ *     .use(withUser)
+ *     .handle(async (ctx, input) => {
+ *         return { ok: true, data: await db.posts.create(input) };
+ *     });
+ * ```
+ */
+declare function createAction<TInput = void>(): ActionBuilder<ToArgs<TInput>, {}>;
+
 /**
  * Creates a type-safe middleware function.
  *
@@ -24,77 +204,80 @@ declare function createMiddleware<P extends unknown[], T>(handler: Middleware<P,
  * Applies middleware to a server action.
  * Middleware is executed in order (first middleware wraps second, etc).
  *
+ * @deprecated Use `createAction().input(schema).use(middleware).handle(fn)` instead.
+ * This provides better type inference and a more composable API.
+ *
  * @example
  * ```ts
+ * // Old way (deprecated):
  * const protectedAction = applyMiddleware(
  *     myServerAction,
  *     [withAuth, withLogging, withValidation]
  * );
+ *
+ * // New way:
+ * const protectedAction = createAction()
+ *     .input(schema)
+ *     .use(withAuth)
+ *     .use(withLogging)
+ *     .handle(async (ctx, input) => { ... });
  * ```
  */
 declare function applyMiddleware<P extends unknown[], T>(action: (...params: P) => Promise<ServerActionResult<T>>, middleware: Middleware<P, T>[]): (...params: P) => Promise<ServerActionResult<T>>;
 /**
  * Composes multiple middleware into a single middleware.
  *
+ * @deprecated Use `createAction().use(mw1).use(mw2).handle(fn)` instead.
+ * The builder pattern provides better type inference for chained middleware.
+ *
  * @example
  * ```ts
+ * // Old way (deprecated):
  * const combined = composeMiddleware(withAuth, withLogging, withValidation);
  * const protectedAction = applyMiddleware(myAction, [combined]);
+ *
+ * // New way:
+ * const protectedAction = createAction()
+ *     .input(schema)
+ *     .use(withAuth)
+ *     .use(withLogging)
+ *     .handle(async (ctx, input) => { ... });
  * ```
  */
 declare function composeMiddleware<P extends unknown[], T>(...middleware: Middleware<P, T>[]): Middleware<P, T>;
-/**
- * A Zod-like schema interface for validation.
- * Works with Zod, Valibot, or any schema library with a compatible safeParse method.
- */
-type ValidationSchema<T> = {
-    safeParse(data: unknown): {
-        success: true;
-        data: T;
-    } | {
-        success: false;
-        error: {
-            message?: string;
-            errors?: Array<{
-                message: string;
-            }>;
-        };
-    };
-};
-type WithValidationOptions = {
-    /** Error code to return on validation failure. Defaults to "VALIDATION_ERROR" */
-    code?: string;
-    /** Custom error message formatter */
-    formatError?: (error: {
-        message?: string;
-        errors?: Array<{
-            message: string;
-        }>;
-    }) => string;
-};
 /**
  * Creates a middleware that validates the first parameter against a schema.
  * Works with Zod, Valibot, or any library with a compatible safeParse method.
  *
+ * @deprecated Use `createAction().input(schema).handle(fn)` instead.
+ * The `.input()` method provides automatic type inference from the schema.
+ *
  * @example
  * ```ts
  * import { z } from "zod";
- * import { withValidation, applyMiddleware } from "use-server-action/server";
  *
- * const CreateUserSchema = z.object({
+ * const schema = z.object({
  *     name: z.string().min(1),
  *     email: z.string().email(),
  * });
  *
+ * // Old way (deprecated):
  * const createUser = applyMiddleware(
- *     serverAction(async (input: z.infer<typeof CreateUserSchema>) => {
+ *     serverAction(async (input: z.infer<typeof schema>) => {
  *         return await db.user.create({ data: input });
  *     }),
- *     [withValidation(CreateUserSchema)]
+ *     [withZodValidation(schema)]
  * );
+ *
+ * // New way:
+ * const createUser = createAction()
+ *     .input(schema)  // Type is inferred automatically!
+ *     .handle(async (ctx, input) => {
+ *         return { ok: true, data: await db.user.create({ data: input }) };
+ *     });
  * ```
  */
-declare function withValidation<TInput, T>(schema: ValidationSchema<TInput>, options?: WithValidationOptions): Middleware<[TInput], T>;
+declare function withZodValidation<TInput, T>(schema: ValidationSchema<TInput>, options?: WithValidationOptions): Middleware<[TInput], T>;
 /**
  * Creates a middleware that logs action calls and results.
  */
@@ -104,4 +287,4 @@ declare function withLogging<P extends unknown[], T>(logger?: {
     onError?: (message: string, code: string | undefined, params: P) => void;
 }): Middleware<P, T>;
 
-export { type Middleware, ServerActionResult, type ValidationSchema, type WithValidationOptions, applyMiddleware, composeMiddleware, createMiddleware, withLogging, withValidation };
+export { type BaseContext, type ContextMiddleware, type Middleware, ServerActionResult, type ValidationSchema, type WithValidationOptions, applyMiddleware, composeMiddleware, createAction, createContextMiddleware, createMiddleware, withLogging, withZodValidation };

package/dist/server.d.ts

@@ -1,11 +1,191 @@
-import { S as ServerActionResult } from './server-action-HthxxP-Y.js';
-export { b as ServerActionError, c as ServerActionFn, a as ServerActionSuccess, e as error, f as isError, i as isSuccess, s as serverAction, d as success, u as unwrap, g as unwrapOr } from './server-action-HthxxP-Y.js';
+import { S as ServerActionResult } from './server-action-Cm80HhlX.js';
+export { b as ServerActionError, c as ServerActionFn, a as ServerActionSuccess, e as error, f as isError, i as isSuccess, s as serverAction, d as success, u as unwrap, g as unwrapOr } from './server-action-Cm80HhlX.js';
 
+/**
+ * Base context type - all contexts extend from this
+ */
+type BaseContext = Record<string, unknown>;
 /**
  * A middleware function that wraps a server action.
  * Receives the next function in the chain and the parameters passed to the action.
  */
 type Middleware<P extends unknown[], T> = (next: (...params: P) => Promise<ServerActionResult<T>>, ...params: P) => Promise<ServerActionResult<T>>;
+/**
+ * A context-aware middleware that can receive context from previous middleware
+ * and add new context for downstream middleware.
+ *
+ * @template P - The parameter types for the action
+ * @template T - The return type of the action
+ * @template CtxIn - The context type this middleware expects to receive
+ * @template CtxOut - The context type this middleware adds (merged with CtxIn for next)
+ */
+type ContextMiddleware<P extends unknown[], T, CtxIn extends BaseContext = BaseContext, CtxOut extends BaseContext = BaseContext> = (next: (ctx: CtxIn & CtxOut, ...params: P) => Promise<ServerActionResult<T>>, ctx: CtxIn, ...params: P) => Promise<ServerActionResult<T>>;
+/**
+ * A Zod-like schema interface for validation.
+ * Works with Zod, Valibot, or any schema library with a compatible safeParse method.
+ */
+type ValidationSchema<T> = {
+    safeParse(data: unknown): {
+        success: true;
+        data: T;
+    } | {
+        success: false;
+        error: {
+            message?: string;
+            errors?: Array<{
+                message: string;
+            }>;
+        };
+    };
+};
+type WithValidationOptions = {
+    /** Error code to return on validation failure. Defaults to "VALIDATION_ERROR" */
+    code?: string;
+    /** Custom error message formatter */
+    formatError?: (error: {
+        message?: string;
+        errors?: Array<{
+            message: string;
+        }>;
+    }) => string;
+};
+
+/**
+ * Creates a type-safe context-aware middleware.
+ *
+ * @example
+ * ```ts
+ * type User = { id: string; name: string };
+ *
+ * const withAuth = createContextMiddleware<
+ *     [string],           // Parameters
+ *     SomeReturnType,     // Return type
+ *     {},                 // Input context (none required)
+ *     { user: User }      // Output context (adds user)
+ * >(async (next, ctx, input) => {
+ *     const user = await authenticate();
+ *     if (!user) {
+ *         return { ok: false, message: "Unauthorized", code: "UNAUTHORIZED" };
+ *     }
+ *     // Pass the new context with user added
+ *     return next({ ...ctx, user }, input);
+ * });
+ * ```
+ */
+declare function createContextMiddleware<P extends unknown[], T, CtxIn extends BaseContext = BaseContext, CtxOut extends BaseContext = BaseContext>(handler: ContextMiddleware<P, T, CtxIn, CtxOut>): ContextMiddleware<P, T, CtxIn, CtxOut>;
+
+/**
+ * A builder for creating server actions with type-safe context accumulation.
+ *
+ * @template TInput - The input parameters as a tuple type
+ * @template TContext - The accumulated context type from all middleware
+ */
+declare class ActionBuilder<TInput extends unknown[] = unknown[], TContext extends BaseContext = {}> {
+    private middlewares;
+    private constructor();
+    /**
+     * Create a new ActionBuilder instance
+     */
+    static create<TInput extends unknown[]>(): ActionBuilder<TInput, {}>;
+    /**
+     * Add a context-aware middleware to the chain.
+     * The middleware receives the accumulated context and can add new context.
+     *
+     * @example
+     * ```ts
+     * const withUser = createContextMiddleware(async (next, ctx, ...args) => {
+     *     const user = await getUser();
+     *     if (!user) {
+     *         return { ok: false, message: "Unauthorized", code: "UNAUTHORIZED" };
+     *     }
+     *     return next({ ...ctx, user }, ...args);
+     * });
+     *
+     * const action = createAction<[{ name: string }]>()
+     *     .use(withUser)
+     *     .handle(async (ctx, input) => {
+     *         // ctx.user is fully typed!
+     *     });
+     * ```
+     */
+    use<CtxOut extends BaseContext>(middleware: ContextMiddleware<TInput, any, TContext, CtxOut>): ActionBuilder<TInput, TContext & CtxOut>;
+    /**
+     * Add a regular (non-context) middleware to the chain.
+     * The middleware can transform input/output but doesn't modify context.
+     *
+     * @example
+     * ```ts
+     * const withLogging = createMiddleware(async (next, ...args) => {
+     *     console.log("Args:", args);
+     *     const result = await next(...args);
+     *     console.log("Result:", result);
+     *     return result;
+     * });
+     *
+     * const action = createAction<[string]>()
+     *     .use(withLogging)
+     *     .handle(async (ctx, input) => { ... });
+     * ```
+     */
+    use(middleware: Middleware<TInput, any>): ActionBuilder<TInput, TContext>;
+    /**
+     * Define the action handler. This finalizes the builder and returns the executable action.
+     * The handler receives the accumulated context and input parameters.
+     *
+     * @example
+     * ```ts
+     * const action = createAction<[{ name: string; email: string }]>()
+     *     .use(withUser)
+     *     .handle(async (ctx, input) => {
+     *         // ctx and input are fully typed
+     *         return { ok: true, data: result };
+     *     });
+     *
+     * // Call the action
+     * const result = await action({ name: "John", email: "john@example.com" });
+     * ```
+     */
+    handle<TOutput>(handler: (ctx: TContext, ...args: TInput) => Promise<ServerActionResult<TOutput>>): (...args: TInput) => Promise<ServerActionResult<TOutput>>;
+}
+/**
+ * Converts a type to a tuple of arguments.
+ * - `void` becomes `[]` (no args)
+ * - Single type `T` becomes `[T]`
+ * - Tuple type `[A, B]` stays as `[A, B]`
+ */
+type ToArgs<T> = [T] extends [void] ? [] : T extends unknown[] ? T : [T];
+/**
+ * Creates a new action builder with type-safe context accumulation.
+ *
+ * @example
+ * ```ts
+ * // Single input parameter
+ * const createUser = createAction<{ name: string; email: string }>()
+ *     .use(withUser)
+ *     .handle(async (ctx, input) => {
+ *         await db.users.create({ ...input, createdBy: ctx.user.id });
+ *         return { ok: true, data: { success: true } };
+ *     });
+ *
+ * // Multiple input parameters (use tuple)
+ * const updateUser = createAction<[string, { name: string }]>()
+ *     .use(withUser)
+ *     .handle(async (ctx, id, data) => {
+ *         await db.users.update(id, data);
+ *         return { ok: true, data: { success: true } };
+ *     });
+ *
+ * // With validation middleware
+ * const createPost = createAction<z.infer<typeof postSchema>>()
+ *     .use(withZodValidation(postSchema))
+ *     .use(withUser)
+ *     .handle(async (ctx, input) => {
+ *         return { ok: true, data: await db.posts.create(input) };
+ *     });
+ * ```
+ */
+declare function createAction<TInput = void>(): ActionBuilder<ToArgs<TInput>, {}>;
+
 /**
  * Creates a type-safe middleware function.
  *
@@ -24,77 +204,80 @@ declare function createMiddleware<P extends unknown[], T>(handler: Middleware<P,
  * Applies middleware to a server action.
  * Middleware is executed in order (first middleware wraps second, etc).
  *
+ * @deprecated Use `createAction().input(schema).use(middleware).handle(fn)` instead.
+ * This provides better type inference and a more composable API.
+ *
  * @example
  * ```ts
+ * // Old way (deprecated):
  * const protectedAction = applyMiddleware(
  *     myServerAction,
  *     [withAuth, withLogging, withValidation]
  * );
+ *
+ * // New way:
+ * const protectedAction = createAction()
+ *     .input(schema)
+ *     .use(withAuth)
+ *     .use(withLogging)
+ *     .handle(async (ctx, input) => { ... });
  * ```
  */
 declare function applyMiddleware<P extends unknown[], T>(action: (...params: P) => Promise<ServerActionResult<T>>, middleware: Middleware<P, T>[]): (...params: P) => Promise<ServerActionResult<T>>;
 /**
  * Composes multiple middleware into a single middleware.
  *
+ * @deprecated Use `createAction().use(mw1).use(mw2).handle(fn)` instead.
+ * The builder pattern provides better type inference for chained middleware.
+ *
  * @example
  * ```ts
+ * // Old way (deprecated):
  * const combined = composeMiddleware(withAuth, withLogging, withValidation);
  * const protectedAction = applyMiddleware(myAction, [combined]);
+ *
+ * // New way:
+ * const protectedAction = createAction()
+ *     .input(schema)
+ *     .use(withAuth)
+ *     .use(withLogging)
+ *     .handle(async (ctx, input) => { ... });
  * ```
  */
 declare function composeMiddleware<P extends unknown[], T>(...middleware: Middleware<P, T>[]): Middleware<P, T>;
-/**
- * A Zod-like schema interface for validation.
- * Works with Zod, Valibot, or any schema library with a compatible safeParse method.
- */
-type ValidationSchema<T> = {
-    safeParse(data: unknown): {
-        success: true;
-        data: T;
-    } | {
-        success: false;
-        error: {
-            message?: string;
-            errors?: Array<{
-                message: string;
-            }>;
-        };
-    };
-};
-type WithValidationOptions = {
-    /** Error code to return on validation failure. Defaults to "VALIDATION_ERROR" */
-    code?: string;
-    /** Custom error message formatter */
-    formatError?: (error: {
-        message?: string;
-        errors?: Array<{
-            message: string;
-        }>;
-    }) => string;
-};
 /**
  * Creates a middleware that validates the first parameter against a schema.
  * Works with Zod, Valibot, or any library with a compatible safeParse method.
  *
+ * @deprecated Use `createAction().input(schema).handle(fn)` instead.
+ * The `.input()` method provides automatic type inference from the schema.
+ *
  * @example
  * ```ts
  * import { z } from "zod";
- * import { withValidation, applyMiddleware } from "use-server-action/server";
  *
- * const CreateUserSchema = z.object({
+ * const schema = z.object({
  *     name: z.string().min(1),
  *     email: z.string().email(),
  * });
  *
+ * // Old way (deprecated):
  * const createUser = applyMiddleware(
- *     serverAction(async (input: z.infer<typeof CreateUserSchema>) => {
+ *     serverAction(async (input: z.infer<typeof schema>) => {
  *         return await db.user.create({ data: input });
  *     }),
- *     [withValidation(CreateUserSchema)]
+ *     [withZodValidation(schema)]
  * );
+ *
+ * // New way:
+ * const createUser = createAction()
+ *     .input(schema)  // Type is inferred automatically!
+ *     .handle(async (ctx, input) => {
+ *         return { ok: true, data: await db.user.create({ data: input }) };
+ *     });
  * ```
  */
-declare function withValidation<TInput, T>(schema: ValidationSchema<TInput>, options?: WithValidationOptions): Middleware<[TInput], T>;
+declare function withZodValidation<TInput, T>(schema: ValidationSchema<TInput>, options?: WithValidationOptions): Middleware<[TInput], T>;
 /**
  * Creates a middleware that logs action calls and results.
  */
@@ -104,4 +287,4 @@ declare function withLogging<P extends unknown[], T>(logger?: {
     onError?: (message: string, code: string | undefined, params: P) => void;
 }): Middleware<P, T>;
 
-export { type Middleware, ServerActionResult, type ValidationSchema, type WithValidationOptions, applyMiddleware, composeMiddleware, createMiddleware, withLogging, withValidation };
+export { type BaseContext, type ContextMiddleware, type Middleware, ServerActionResult, type ValidationSchema, type WithValidationOptions, applyMiddleware, composeMiddleware, createAction, createContextMiddleware, createMiddleware, withLogging, withZodValidation };

package/dist/server.js

@@ -1,4 +1,5 @@
 "use strict";
+"use server";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -22,6 +23,8 @@ var server_exports = {};
 __export(server_exports, {
   applyMiddleware: () => applyMiddleware,
   composeMiddleware: () => composeMiddleware,
+  createAction: () => createAction,
+  createContextMiddleware: () => createContextMiddleware,
   createMiddleware: () => createMiddleware,
   error: () => error,
   isError: () => isError,
@@ -31,7 +34,7 @@ __export(server_exports, {
   unwrap: () => unwrap,
   unwrapOr: () => unwrapOr,
   withLogging: () => withLogging,
-  withValidation: () => withValidation
+  withZodValidation: () => withZodValidation
 });
 module.exports = __toCommonJS(server_exports);
 
@@ -75,7 +78,90 @@ function unwrapOr(result, defaultValue) {
   return defaultValue;
 }
 
-// src/server/middleware.ts
+// src/server/context-middleware.ts
+var CONTEXT_MIDDLEWARE = /* @__PURE__ */ Symbol("contextMiddleware");
+function isContextMiddleware(fn) {
+  return typeof fn === "function" && fn[CONTEXT_MIDDLEWARE] === true;
+}
+function createContextMiddleware(handler) {
+  handler[CONTEXT_MIDDLEWARE] = true;
+  return handler;
+}
+
+// src/server/action-builder.ts
+var ActionBuilder = class _ActionBuilder {
+  constructor(middlewares = []) {
+    this.middlewares = [];
+    this.middlewares = middlewares;
+  }
+  /**
+   * Create a new ActionBuilder instance
+   */
+  static create() {
+    return new _ActionBuilder();
+  }
+  use(middleware) {
+    return new _ActionBuilder([
+      ...this.middlewares,
+      middleware
+    ]);
+  }
+  /**
+   * Define the action handler. This finalizes the builder and returns the executable action.
+   * The handler receives the accumulated context and input parameters.
+   *
+   * @example
+   * ```ts
+   * const action = createAction<[{ name: string; email: string }]>()
+   *     .use(withUser)
+   *     .handle(async (ctx, input) => {
+   *         // ctx and input are fully typed
+   *         return { ok: true, data: result };
+   *     });
+   *
+   * // Call the action
+   * const result = await action({ name: "John", email: "john@example.com" });
+   * ```
+   */
+  handle(handler) {
+    const middlewares = [...this.middlewares];
+    return async (...args) => {
+      const finalHandler = async (ctx, ...a) => {
+        return handler(ctx, ...a);
+      };
+      const chain = middlewares.reduceRight((next, mw) => {
+        if (isContextMiddleware(mw)) {
+          return async (ctx, ...a) => {
+            return mw(
+              async (newCtx, ...params) => next(newCtx, ...params),
+              ctx,
+              ...a
+            );
+          };
+        } else {
+          return async (ctx, ...a) => {
+            return mw(
+              async (...params) => next(ctx, ...params),
+              ...a
+            );
+          };
+        }
+      }, finalHandler);
+      try {
+        return await chain({}, ...args);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        const code = err instanceof Error ? err.name : "UNKNOWN_ERROR";
+        return { ok: false, message, code };
+      }
+    };
+  }
+};
+function createAction() {
+  return ActionBuilder.create();
+}
+
+// src/server/middleware-utils.ts
 function createMiddleware(handler) {
   return handler;
 }
@@ -94,7 +180,7 @@ function composeMiddleware(...middleware) {
     return chain(...params);
   };
 }
-function withValidation(schema, options = {}) {
+function withZodValidation(schema, options = {}) {
   const { code = "VALIDATION_ERROR", formatError } = options;
   return async (next, input) => {
     const result = schema.safeParse(input);
@@ -121,6 +207,8 @@ function withLogging(logger = {}) {
 0 && (module.exports = {
   applyMiddleware,
   composeMiddleware,
+  createAction,
+  createContextMiddleware,
   createMiddleware,
   error,
   isError,
@@ -130,6 +218,6 @@ function withLogging(logger = {}) {
   unwrap,
   unwrapOr,
   withLogging,
-  withValidation
+  withZodValidation
 });
 //# sourceMappingURL=server.js.map

package/dist/server.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/server/index.ts","../src/server/server-action.ts","../src/server/middleware.ts"],"sourcesContent":["export {\n    serverAction,\n    success,\n    error,\n    isSuccess,\n    isError,\n    unwrap,\n    unwrapOr,\n} from \"./server-action\";\nexport type {\n    ServerActionResult,\n    ServerActionSuccess,\n    ServerActionError,\n    ServerActionFn,\n} from \"./server-action\";\n\nexport {\n    createMiddleware,\n    applyMiddleware,\n    composeMiddleware,\n    withValidation,\n    withLogging,\n} from \"./middleware\";\nexport type {\n    Middleware,\n    ValidationSchema,\n    WithValidationOptions,\n} from \"./middleware\";\n","\"use server\";\n\nexport type ServerActionSuccess<T> = {\n    ok: true;\n    data: T;\n};\n\nexport type ServerActionError = {\n    ok: false;\n    message: string;\n    code?: string;\n};\n\nexport type ServerActionResult<T> = ServerActionSuccess<T> | ServerActionError;\n\nexport function success<T>(data: T): ServerActionSuccess<T> {\n    return { ok: true, data };\n}\n\nexport function error(message: string, code?: string): ServerActionError {\n    return { ok: false, message, code };\n}\n\nexport type ServerActionFn<P extends unknown[], T> = (\n    ...args: P\n) => Promise<ServerActionResult<T>>;\n\ntype ServerActionOptions = {\n    onError?: (error: unknown) => void;\n};\n\n/**\n * Wraps an async function to return a standardized ServerActionResult.\n * Catches any thrown errors and converts them to error results.\n */\nexport function serverAction<P extends unknown[], T>(\n    fn: (...args: P) => Promise<T>,\n    options?: ServerActionOptions,\n): ServerActionFn<P, T> {\n    return async (...args: P): Promise<ServerActionResult<T>> => {\n        try {\n            const data = await fn(...args);\n            return success(data);\n        } catch (err) {\n            options?.onError?.(err);\n\n            if (err instanceof Error) {\n                return error(err.message, err.name);\n            }\n\n            return error(\"An unexpected error occurred\", \"UNKNOWN_ERROR\");\n        }\n    };\n}\n\n/**\n * Type guard to check if a result is successful\n */\nexport function isSuccess<T>(\n    result: ServerActionResult<T>,\n): result is ServerActionSuccess<T> {\n    return result.ok === true;\n}\n\n/**\n * Type guard to check if a result is an error\n */\nexport function isError<T>(\n    result: ServerActionResult<T>,\n): result is ServerActionError {\n    return result.ok === false;\n}\n\n/**\n * Unwraps a successful result or throws the error message\n */\nexport function unwrap<T>(result: ServerActionResult<T>): T {\n    if (result.ok) {\n        return result.data;\n    }\n    throw new Error(result.message);\n}\n\n/**\n * Unwraps a successful result or returns a default value\n */\nexport function unwrapOr<T>(result: ServerActionResult<T>, defaultValue: T): T {\n    if (result.ok) {\n        return result.data;\n    }\n    return defaultValue;\n}\n","\"use server\";\n\nimport type { ServerActionResult } from \"./server-action\";\n\n/**\n * A middleware function that wraps a server action.\n * Receives the next function in the chain and the parameters passed to the action.\n */\nexport type Middleware<P extends unknown[], T> = (\n    next: (...params: P) => Promise<ServerActionResult<T>>,\n    ...params: P\n) => Promise<ServerActionResult<T>>;\n\n/**\n * Creates a type-safe middleware function.\n *\n * @example\n * ```ts\n * const withLogging = createMiddleware(async (next, ...params) => {\n *     console.log(\"Calling action with:\", params);\n *     const result = await next(...params);\n *     console.log(\"Result:\", result);\n *     return result;\n * });\n * ```\n */\nexport function createMiddleware<P extends unknown[], T>(\n    handler: Middleware<P, T>,\n): Middleware<P, T> {\n    return handler;\n}\n\n/**\n * Applies middleware to a server action.\n * Middleware is executed in order (first middleware wraps second, etc).\n *\n * @example\n * ```ts\n * const protectedAction = applyMiddleware(\n *     myServerAction,\n *     [withAuth, withLogging, withValidation]\n * );\n * ```\n */\nexport function applyMiddleware<P extends unknown[], T>(\n    action: (...params: P) => Promise<ServerActionResult<T>>,\n    middleware: Middleware<P, T>[],\n): (...params: P) => Promise<ServerActionResult<T>> {\n    return middleware.reduceRight(\n        (next, mw) =>\n            (...params: P) =>\n                mw(next, ...params),\n        action,\n    );\n}\n\n/**\n * Composes multiple middleware into a single middleware.\n *\n * @example\n * ```ts\n * const combined = composeMiddleware(withAuth, withLogging, withValidation);\n * const protectedAction = applyMiddleware(myAction, [combined]);\n * ```\n */\nexport function composeMiddleware<P extends unknown[], T>(\n    ...middleware: Middleware<P, T>[]\n): Middleware<P, T> {\n    return (next, ...params) => {\n        const chain = middleware.reduceRight(\n            (nextFn, mw) =>\n                (...p: P) =>\n                    mw(nextFn, ...p),\n            next,\n        );\n        return chain(...params);\n    };\n}\n\n/**\n * A Zod-like schema interface for validation.\n * Works with Zod, Valibot, or any schema library with a compatible safeParse method.\n */\nexport type ValidationSchema<T> = {\n    safeParse(data: unknown):\n        | { success: true; data: T }\n        | { success: false; error: { message?: string; errors?: Array<{ message: string }> } };\n};\n\nexport type WithValidationOptions = {\n    /** Error code to return on validation failure. Defaults to \"VALIDATION_ERROR\" */\n    code?: string;\n    /** Custom error message formatter */\n    formatError?: (error: {\n        message?: string;\n        errors?: Array<{ message: string }>;\n    }) => string;\n};\n\n/**\n * Creates a middleware that validates the first parameter against a schema.\n * Works with Zod, Valibot, or any library with a compatible safeParse method.\n *\n * @example\n * ```ts\n * import { z } from \"zod\";\n * import { withValidation, applyMiddleware } from \"use-server-action/server\";\n *\n * const CreateUserSchema = z.object({\n *     name: z.string().min(1),\n *     email: z.string().email(),\n * });\n *\n * const createUser = applyMiddleware(\n *     serverAction(async (input: z.infer<typeof CreateUserSchema>) => {\n *         return await db.user.create({ data: input });\n *     }),\n *     [withValidation(CreateUserSchema)]\n * );\n * ```\n */\nexport function withValidation<TInput, T>(\n    schema: ValidationSchema<TInput>,\n    options: WithValidationOptions = {},\n): Middleware<[TInput], T> {\n    const { code = \"VALIDATION_ERROR\", formatError } = options;\n\n    return async (next, input) => {\n        const result = schema.safeParse(input);\n\n        if (!result.success) {\n            const message = formatError\n                ? formatError(result.error)\n                : result.error.errors?.[0]?.message ??\n                  result.error.message ??\n                  \"Validation failed\";\n\n            return { ok: false, message, code };\n        }\n\n        return next(result.data);\n    };\n}\n\n/**\n * Creates a middleware that logs action calls and results.\n */\nexport function withLogging<P extends unknown[], T>(\n    logger: {\n        onCall?: (params: P) => void;\n        onSuccess?: (data: T, params: P) => void;\n        onError?: (\n            message: string,\n            code: string | undefined,\n            params: P,\n        ) => void;\n    } = {},\n): Middleware<P, T> {\n    return async (next, ...params) => {\n        logger.onCall?.(params);\n        const result = await next(...params);\n        if (result.ok) {\n            logger.onSuccess?.(result.data, params);\n        } else {\n            logger.onError?.(result.message, result.code, params);\n        }\n        return result;\n    };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACeO,SAAS,QAAW,MAAiC;AACxD,SAAO,EAAE,IAAI,MAAM,KAAK;AAC5B;AAEO,SAAS,MAAM,SAAiB,MAAkC;AACrE,SAAO,EAAE,IAAI,OAAO,SAAS,KAAK;AACtC;AAcO,SAAS,aACZ,IACA,SACoB;AACpB,SAAO,UAAU,SAA4C;AACzD,QAAI;AACA,YAAM,OAAO,MAAM,GAAG,GAAG,IAAI;AAC7B,aAAO,QAAQ,IAAI;AAAA,IACvB,SAAS,KAAK;AACV,eAAS,UAAU,GAAG;AAEtB,UAAI,eAAe,OAAO;AACtB,eAAO,MAAM,IAAI,SAAS,IAAI,IAAI;AAAA,MACtC;AAEA,aAAO,MAAM,gCAAgC,eAAe;AAAA,IAChE;AAAA,EACJ;AACJ;AAKO,SAAS,UACZ,QACgC;AAChC,SAAO,OAAO,OAAO;AACzB;AAKO,SAAS,QACZ,QAC2B;AAC3B,SAAO,OAAO,OAAO;AACzB;AAKO,SAAS,OAAU,QAAkC;AACxD,MAAI,OAAO,IAAI;AACX,WAAO,OAAO;AAAA,EAClB;AACA,QAAM,IAAI,MAAM,OAAO,OAAO;AAClC;AAKO,SAAS,SAAY,QAA+B,cAAoB;AAC3E,MAAI,OAAO,IAAI;AACX,WAAO,OAAO;AAAA,EAClB;AACA,SAAO;AACX;;;ACjEO,SAAS,iBACZ,SACgB;AAChB,SAAO;AACX;AAcO,SAAS,gBACZ,QACA,YACgD;AAChD,SAAO,WAAW;AAAA,IACd,CAAC,MAAM,OACH,IAAI,WACA,GAAG,MAAM,GAAG,MAAM;AAAA,IAC1B;AAAA,EACJ;AACJ;AAWO,SAAS,qBACT,YACa;AAChB,SAAO,CAAC,SAAS,WAAW;AACxB,UAAM,QAAQ,WAAW;AAAA,MACrB,CAAC,QAAQ,OACL,IAAI,MACA,GAAG,QAAQ,GAAG,CAAC;AAAA,MACvB;AAAA,IACJ;AACA,WAAO,MAAM,GAAG,MAAM;AAAA,EAC1B;AACJ;AA4CO,SAAS,eACZ,QACA,UAAiC,CAAC,GACX;AACvB,QAAM,EAAE,OAAO,oBAAoB,YAAY,IAAI;AAEnD,SAAO,OAAO,MAAM,UAAU;AAC1B,UAAM,SAAS,OAAO,UAAU,KAAK;AAErC,QAAI,CAAC,OAAO,SAAS;AACjB,YAAM,UAAU,cACV,YAAY,OAAO,KAAK,IACxB,OAAO,MAAM,SAAS,CAAC,GAAG,WAC1B,OAAO,MAAM,WACb;AAEN,aAAO,EAAE,IAAI,OAAO,SAAS,KAAK;AAAA,IACtC;AAEA,WAAO,KAAK,OAAO,IAAI;AAAA,EAC3B;AACJ;AAKO,SAAS,YACZ,SAQI,CAAC,GACW;AAChB,SAAO,OAAO,SAAS,WAAW;AAC9B,WAAO,SAAS,MAAM;AACtB,UAAM,SAAS,MAAM,KAAK,GAAG,MAAM;AACnC,QAAI,OAAO,IAAI;AACX,aAAO,YAAY,OAAO,MAAM,MAAM;AAAA,IAC1C,OAAO;AACH,aAAO,UAAU,OAAO,SAAS,OAAO,MAAM,MAAM;AAAA,IACxD;AACA,WAAO;AAAA,EACX;AACJ;","names":[]}
+{"version":3,"sources":["../src/server/index.ts","../src/server/server-action.ts","../src/server/context-middleware.ts","../src/server/action-builder.ts","../src/server/middleware-utils.ts"],"sourcesContent":["\"use server\";\n\n// Server action utilities\nexport {\n    serverAction,\n    success,\n    error,\n    isSuccess,\n    isError,\n    unwrap,\n    unwrapOr,\n} from \"./server-action\";\nexport type {\n    ServerActionResult,\n    ServerActionSuccess,\n    ServerActionError,\n    ServerActionFn,\n} from \"./server-action\";\n\n// Types\nexport type {\n    BaseContext,\n    ContextMiddleware,\n    Middleware,\n    ValidationSchema,\n    WithValidationOptions,\n} from \"./types\";\n\n// Context middleware\nexport { createContextMiddleware } from \"./context-middleware\";\n\n// Action builder\nexport { createAction } from \"./action-builder\";\n\n// Middleware utilities\nexport {\n    createMiddleware,\n    applyMiddleware,\n    composeMiddleware,\n    withZodValidation,\n    withLogging,\n} from \"./middleware-utils\";\n","\"use server\";\n\nexport type ServerActionSuccess<T> = {\n    ok: true;\n    data: T;\n};\n\nexport type ServerActionError = {\n    ok: false;\n    message: string;\n    code?: string;\n};\n\nexport type ServerActionResult<T> = ServerActionSuccess<T> | ServerActionError;\n\nexport function success<T>(data: T): ServerActionSuccess<T> {\n    return { ok: true, data };\n}\n\nexport function error(message: string, code?: string): ServerActionError {\n    return { ok: false, message, code };\n}\n\nexport type ServerActionFn<P extends unknown[], T> = (\n    ...args: P\n) => Promise<ServerActionResult<T>>;\n\ntype ServerActionOptions = {\n    onError?: (error: unknown) => void;\n};\n\n/**\n * Wraps an async function to return a standardized ServerActionResult.\n * Catches any thrown errors and converts them to error results.\n *\n * @deprecated Use `createAction().input(schema).handle(fn)` instead.\n * The new API provides better type inference and built-in validation.\n *\n * @example\n * ```ts\n * // Old way (deprecated):\n * const myAction = serverAction(async (input: MyInput) => {\n *     return await doSomething(input);\n * });\n *\n * // New way:\n * const myAction = createAction()\n *     .input(mySchema)\n *     .handle(async (ctx, input) => {\n *         return { ok: true, data: await doSomething(input) };\n *     });\n * ```\n */\nexport function serverAction<P extends unknown[], T>(\n    fn: (...args: P) => Promise<T>,\n    options?: ServerActionOptions,\n): ServerActionFn<P, T> {\n    return async (...args: P): Promise<ServerActionResult<T>> => {\n        try {\n            const data = await fn(...args);\n            return success(data);\n        } catch (err) {\n            options?.onError?.(err);\n\n            if (err instanceof Error) {\n                return error(err.message, err.name);\n            }\n\n            return error(\"An unexpected error occurred\", \"UNKNOWN_ERROR\");\n        }\n    };\n}\n\n/**\n * Type guard to check if a result is successful\n */\nexport function isSuccess<T>(\n    result: ServerActionResult<T>,\n): result is ServerActionSuccess<T> {\n    return result.ok === true;\n}\n\n/**\n * Type guard to check if a result is an error\n */\nexport function isError<T>(\n    result: ServerActionResult<T>,\n): result is ServerActionError {\n    return result.ok === false;\n}\n\n/**\n * Unwraps a successful result or throws the error message\n */\nexport function unwrap<T>(result: ServerActionResult<T>): T {\n    if (result.ok) {\n        return result.data;\n    }\n    throw new Error(result.message);\n}\n\n/**\n * Unwraps a successful result or returns a default value\n */\nexport function unwrapOr<T>(result: ServerActionResult<T>, defaultValue: T): T {\n    if (result.ok) {\n        return result.data;\n    }\n    return defaultValue;\n}\n","\"use server\";\n\nimport type { BaseContext, ContextMiddleware } from \"./types\";\n\n/**\n * Symbol to identify context-aware middleware at runtime\n */\nexport const CONTEXT_MIDDLEWARE = Symbol(\"contextMiddleware\");\n\n/**\n * Check if a middleware is context-aware\n */\nexport function isContextMiddleware(fn: unknown): boolean {\n    return typeof fn === \"function\" && (fn as any)[CONTEXT_MIDDLEWARE] === true;\n}\n\n/**\n * Creates a type-safe context-aware middleware.\n *\n * @example\n * ```ts\n * type User = { id: string; name: string };\n *\n * const withAuth = createContextMiddleware<\n *     [string],           // Parameters\n *     SomeReturnType,     // Return type\n *     {},                 // Input context (none required)\n *     { user: User }      // Output context (adds user)\n * >(async (next, ctx, input) => {\n *     const user = await authenticate();\n *     if (!user) {\n *         return { ok: false, message: \"Unauthorized\", code: \"UNAUTHORIZED\" };\n *     }\n *     // Pass the new context with user added\n *     return next({ ...ctx, user }, input);\n * });\n * ```\n */\nexport function createContextMiddleware<\n    P extends unknown[],\n    T,\n    CtxIn extends BaseContext = BaseContext,\n    CtxOut extends BaseContext = BaseContext,\n>(\n    handler: ContextMiddleware<P, T, CtxIn, CtxOut>,\n): ContextMiddleware<P, T, CtxIn, CtxOut> {\n    (handler as any)[CONTEXT_MIDDLEWARE] = true;\n    return handler;\n}\n","\"use server\";\n\nimport type { ServerActionResult } from \"./server-action\";\nimport type {\n    BaseContext,\n    ContextMiddleware,\n    Middleware,\n} from \"./types\";\nimport { isContextMiddleware } from \"./context-middleware\";\n\n/**\n * A builder for creating server actions with type-safe context accumulation.\n *\n * @template TInput - The input parameters as a tuple type\n * @template TContext - The accumulated context type from all middleware\n */\nclass ActionBuilder<\n    TInput extends unknown[] = unknown[],\n    TContext extends BaseContext = {},\n> {\n    private middlewares: Array<\n        ContextMiddleware<any, any, any, any> | Middleware<any, any>\n    > = [];\n\n    private constructor(\n        middlewares: Array<\n            ContextMiddleware<any, any, any, any> | Middleware<any, any>\n        > = [],\n    ) {\n        this.middlewares = middlewares;\n    }\n\n    /**\n     * Create a new ActionBuilder instance\n     */\n    static create<TInput extends unknown[]>(): ActionBuilder<TInput, {}> {\n        return new ActionBuilder<TInput, {}>();\n    }\n\n    /**\n     * Add a context-aware middleware to the chain.\n     * The middleware receives the accumulated context and can add new context.\n     *\n     * @example\n     * ```ts\n     * const withUser = createContextMiddleware(async (next, ctx, ...args) => {\n     *     const user = await getUser();\n     *     if (!user) {\n     *         return { ok: false, message: \"Unauthorized\", code: \"UNAUTHORIZED\" };\n     *     }\n     *     return next({ ...ctx, user }, ...args);\n     * });\n     *\n     * const action = createAction<[{ name: string }]>()\n     *     .use(withUser)\n     *     .handle(async (ctx, input) => {\n     *         // ctx.user is fully typed!\n     *     });\n     * ```\n     */\n    use<CtxOut extends BaseContext>(\n        middleware: ContextMiddleware<TInput, any, TContext, CtxOut>,\n    ): ActionBuilder<TInput, TContext & CtxOut>;\n\n    /**\n     * Add a regular (non-context) middleware to the chain.\n     * The middleware can transform input/output but doesn't modify context.\n     *\n     * @example\n     * ```ts\n     * const withLogging = createMiddleware(async (next, ...args) => {\n     *     console.log(\"Args:\", args);\n     *     const result = await next(...args);\n     *     console.log(\"Result:\", result);\n     *     return result;\n     * });\n     *\n     * const action = createAction<[string]>()\n     *     .use(withLogging)\n     *     .handle(async (ctx, input) => { ... });\n     * ```\n     */\n    use(middleware: Middleware<TInput, any>): ActionBuilder<TInput, TContext>;\n\n    use(middleware: any): any {\n        return new ActionBuilder<TInput, TContext>([\n            ...this.middlewares,\n            middleware,\n        ]);\n    }\n\n    /**\n     * Define the action handler. This finalizes the builder and returns the executable action.\n     * The handler receives the accumulated context and input parameters.\n     *\n     * @example\n     * ```ts\n     * const action = createAction<[{ name: string; email: string }]>()\n     *     .use(withUser)\n     *     .handle(async (ctx, input) => {\n     *         // ctx and input are fully typed\n     *         return { ok: true, data: result };\n     *     });\n     *\n     * // Call the action\n     * const result = await action({ name: \"John\", email: \"john@example.com\" });\n     * ```\n     */\n    handle<TOutput>(\n        handler: (\n            ctx: TContext,\n            ...args: TInput\n        ) => Promise<ServerActionResult<TOutput>>,\n    ): (...args: TInput) => Promise<ServerActionResult<TOutput>> {\n        const middlewares = [...this.middlewares];\n\n        return async (...args: TInput): Promise<ServerActionResult<TOutput>> => {\n            // Build the middleware chain\n            type CtxNextFn = (\n                ctx: BaseContext,\n                ...args: TInput\n            ) => Promise<ServerActionResult<TOutput>>;\n\n            const finalHandler: CtxNextFn = async (ctx, ...a) => {\n                return handler(ctx as TContext, ...a);\n            };\n\n            // Build chain from right to left (last middleware wraps closest to handler)\n            const chain = middlewares.reduceRight<CtxNextFn>((next, mw) => {\n                if (isContextMiddleware(mw)) {\n                    // Context middleware: (next, ctx, ...params) => ...\n                    return async (ctx, ...a) => {\n                        return (mw as ContextMiddleware<TInput, TOutput, any, any>)(\n                            async (newCtx, ...params) => next(newCtx, ...(params as TInput)),\n                            ctx,\n                            ...a,\n                        );\n                    };\n                } else {\n                    // Regular middleware: (next, ...params) => ...\n                    // Pass context through unchanged\n                    return async (ctx, ...a) => {\n                        return (mw as Middleware<TInput, TOutput>)(\n                            async (...params) => next(ctx, ...(params as TInput)),\n                            ...a,\n                        );\n                    };\n                }\n            }, finalHandler);\n\n            // Start with empty context\n            try {\n                return await chain({}, ...args);\n            } catch (err) {\n                const message =\n                    err instanceof Error ? err.message : \"Unknown error\";\n                const code =\n                    err instanceof Error ? err.name : \"UNKNOWN_ERROR\";\n                return { ok: false, message, code };\n            }\n        };\n    }\n}\n\n/**\n * Converts a type to a tuple of arguments.\n * - `void` becomes `[]` (no args)\n * - Single type `T` becomes `[T]`\n * - Tuple type `[A, B]` stays as `[A, B]`\n */\ntype ToArgs<T> = [T] extends [void] ? [] : T extends unknown[] ? T : [T];\n\n/**\n * Creates a new action builder with type-safe context accumulation.\n *\n * @example\n * ```ts\n * // Single input parameter\n * const createUser = createAction<{ name: string; email: string }>()\n *     .use(withUser)\n *     .handle(async (ctx, input) => {\n *         await db.users.create({ ...input, createdBy: ctx.user.id });\n *         return { ok: true, data: { success: true } };\n *     });\n *\n * // Multiple input parameters (use tuple)\n * const updateUser = createAction<[string, { name: string }]>()\n *     .use(withUser)\n *     .handle(async (ctx, id, data) => {\n *         await db.users.update(id, data);\n *         return { ok: true, data: { success: true } };\n *     });\n *\n * // With validation middleware\n * const createPost = createAction<z.infer<typeof postSchema>>()\n *     .use(withZodValidation(postSchema))\n *     .use(withUser)\n *     .handle(async (ctx, input) => {\n *         return { ok: true, data: await db.posts.create(input) };\n *     });\n * ```\n */\nexport function createAction<TInput = void>(): ActionBuilder<ToArgs<TInput>, {}> {\n    return ActionBuilder.create<ToArgs<TInput>>();\n}\n","\"use server\";\n\nimport type { ServerActionResult } from \"./server-action\";\nimport type { Middleware, ValidationSchema, WithValidationOptions } from \"./types\";\n\n/**\n * Creates a type-safe middleware function.\n *\n * @example\n * ```ts\n * const withLogging = createMiddleware(async (next, ...params) => {\n *     console.log(\"Calling action with:\", params);\n *     const result = await next(...params);\n *     console.log(\"Result:\", result);\n *     return result;\n * });\n * ```\n */\nexport function createMiddleware<P extends unknown[], T>(\n    handler: Middleware<P, T>,\n): Middleware<P, T> {\n    return handler;\n}\n\n/**\n * Applies middleware to a server action.\n * Middleware is executed in order (first middleware wraps second, etc).\n *\n * @deprecated Use `createAction().input(schema).use(middleware).handle(fn)` instead.\n * This provides better type inference and a more composable API.\n *\n * @example\n * ```ts\n * // Old way (deprecated):\n * const protectedAction = applyMiddleware(\n *     myServerAction,\n *     [withAuth, withLogging, withValidation]\n * );\n *\n * // New way:\n * const protectedAction = createAction()\n *     .input(schema)\n *     .use(withAuth)\n *     .use(withLogging)\n *     .handle(async (ctx, input) => { ... });\n * ```\n */\nexport function applyMiddleware<P extends unknown[], T>(\n    action: (...params: P) => Promise<ServerActionResult<T>>,\n    middleware: Middleware<P, T>[],\n): (...params: P) => Promise<ServerActionResult<T>> {\n    return middleware.reduceRight(\n        (next, mw) =>\n            (...params: P) =>\n                mw(next, ...params),\n        action,\n    );\n}\n\n/**\n * Composes multiple middleware into a single middleware.\n *\n * @deprecated Use `createAction().use(mw1).use(mw2).handle(fn)` instead.\n * The builder pattern provides better type inference for chained middleware.\n *\n * @example\n * ```ts\n * // Old way (deprecated):\n * const combined = composeMiddleware(withAuth, withLogging, withValidation);\n * const protectedAction = applyMiddleware(myAction, [combined]);\n *\n * // New way:\n * const protectedAction = createAction()\n *     .input(schema)\n *     .use(withAuth)\n *     .use(withLogging)\n *     .handle(async (ctx, input) => { ... });\n * ```\n */\nexport function composeMiddleware<P extends unknown[], T>(\n    ...middleware: Middleware<P, T>[]\n): Middleware<P, T> {\n    return (next, ...params) => {\n        const chain = middleware.reduceRight(\n            (nextFn, mw) =>\n                (...p: P) =>\n                    mw(nextFn, ...p),\n            next,\n        );\n        return chain(...params);\n    };\n}\n\n/**\n * Creates a middleware that validates the first parameter against a schema.\n * Works with Zod, Valibot, or any library with a compatible safeParse method.\n *\n * @deprecated Use `createAction().input(schema).handle(fn)` instead.\n * The `.input()` method provides automatic type inference from the schema.\n *\n * @example\n * ```ts\n * import { z } from \"zod\";\n *\n * const schema = z.object({\n *     name: z.string().min(1),\n *     email: z.string().email(),\n * });\n *\n * // Old way (deprecated):\n * const createUser = applyMiddleware(\n *     serverAction(async (input: z.infer<typeof schema>) => {\n *         return await db.user.create({ data: input });\n *     }),\n *     [withZodValidation(schema)]\n * );\n *\n * // New way:\n * const createUser = createAction()\n *     .input(schema)  // Type is inferred automatically!\n *     .handle(async (ctx, input) => {\n *         return { ok: true, data: await db.user.create({ data: input }) };\n *     });\n * ```\n */\nexport function withZodValidation<TInput, T>(\n    schema: ValidationSchema<TInput>,\n    options: WithValidationOptions = {},\n): Middleware<[TInput], T> {\n    const { code = \"VALIDATION_ERROR\", formatError } = options;\n\n    return async (next, input) => {\n        const result = schema.safeParse(input);\n\n        if (!result.success) {\n            const message = formatError\n                ? formatError(result.error)\n                : (result.error.errors?.[0]?.message ??\n                  result.error.message ??\n                  \"Validation failed\");\n\n            return { ok: false, message, code };\n        }\n\n        return next(result.data);\n    };\n}\n\n/**\n * Creates a middleware that logs action calls and results.\n */\nexport function withLogging<P extends unknown[], T>(\n    logger: {\n        onCall?: (params: P) => void;\n        onSuccess?: (data: T, params: P) => void;\n        onError?: (\n            message: string,\n            code: string | undefined,\n            params: P,\n        ) => void;\n    } = {},\n): Middleware<P, T> {\n    return async (next, ...params) => {\n        logger.onCall?.(params);\n        const result = await next(...params);\n        if (result.ok) {\n            logger.onSuccess?.(result.data, params);\n        } else {\n            logger.onError?.(result.message, result.code, params);\n        }\n        return result;\n    };\n}\n"],"mappings":"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","names":[]}

package/dist/server.mjs

@@ -1,3 +1,5 @@
+"use server";
+
 // src/server/server-action.ts
 function success(data) {
   return { ok: true, data };
@@ -38,7 +40,90 @@ function unwrapOr(result, defaultValue) {
   return defaultValue;
 }
 
-// src/server/middleware.ts
+// src/server/context-middleware.ts
+var CONTEXT_MIDDLEWARE = /* @__PURE__ */ Symbol("contextMiddleware");
+function isContextMiddleware(fn) {
+  return typeof fn === "function" && fn[CONTEXT_MIDDLEWARE] === true;
+}
+function createContextMiddleware(handler) {
+  handler[CONTEXT_MIDDLEWARE] = true;
+  return handler;
+}
+
+// src/server/action-builder.ts
+var ActionBuilder = class _ActionBuilder {
+  constructor(middlewares = []) {
+    this.middlewares = [];
+    this.middlewares = middlewares;
+  }
+  /**
+   * Create a new ActionBuilder instance
+   */
+  static create() {
+    return new _ActionBuilder();
+  }
+  use(middleware) {
+    return new _ActionBuilder([
+      ...this.middlewares,
+      middleware
+    ]);
+  }
+  /**
+   * Define the action handler. This finalizes the builder and returns the executable action.
+   * The handler receives the accumulated context and input parameters.
+   *
+   * @example
+   * ```ts
+   * const action = createAction<[{ name: string; email: string }]>()
+   *     .use(withUser)
+   *     .handle(async (ctx, input) => {
+   *         // ctx and input are fully typed
+   *         return { ok: true, data: result };
+   *     });
+   *
+   * // Call the action
+   * const result = await action({ name: "John", email: "john@example.com" });
+   * ```
+   */
+  handle(handler) {
+    const middlewares = [...this.middlewares];
+    return async (...args) => {
+      const finalHandler = async (ctx, ...a) => {
+        return handler(ctx, ...a);
+      };
+      const chain = middlewares.reduceRight((next, mw) => {
+        if (isContextMiddleware(mw)) {
+          return async (ctx, ...a) => {
+            return mw(
+              async (newCtx, ...params) => next(newCtx, ...params),
+              ctx,
+              ...a
+            );
+          };
+        } else {
+          return async (ctx, ...a) => {
+            return mw(
+              async (...params) => next(ctx, ...params),
+              ...a
+            );
+          };
+        }
+      }, finalHandler);
+      try {
+        return await chain({}, ...args);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        const code = err instanceof Error ? err.name : "UNKNOWN_ERROR";
+        return { ok: false, message, code };
+      }
+    };
+  }
+};
+function createAction() {
+  return ActionBuilder.create();
+}
+
+// src/server/middleware-utils.ts
 function createMiddleware(handler) {
   return handler;
 }
@@ -57,7 +142,7 @@ function composeMiddleware(...middleware) {
     return chain(...params);
   };
 }
-function withValidation(schema, options = {}) {
+function withZodValidation(schema, options = {}) {
   const { code = "VALIDATION_ERROR", formatError } = options;
   return async (next, input) => {
     const result = schema.safeParse(input);
@@ -83,6 +168,8 @@ function withLogging(logger = {}) {
 export {
   applyMiddleware,
   composeMiddleware,
+  createAction,
+  createContextMiddleware,
   createMiddleware,
   error,
   isError,
@@ -92,6 +179,6 @@ export {
   unwrap,
   unwrapOr,
   withLogging,
-  withValidation
+  withZodValidation
 };
 //# sourceMappingURL=server.mjs.map

package/dist/server.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/server/server-action.ts","../src/server/middleware.ts"],"sourcesContent":["\"use server\";\n\nexport type ServerActionSuccess<T> = {\n    ok: true;\n    data: T;\n};\n\nexport type ServerActionError = {\n    ok: false;\n    message: string;\n    code?: string;\n};\n\nexport type ServerActionResult<T> = ServerActionSuccess<T> | ServerActionError;\n\nexport function success<T>(data: T): ServerActionSuccess<T> {\n    return { ok: true, data };\n}\n\nexport function error(message: string, code?: string): ServerActionError {\n    return { ok: false, message, code };\n}\n\nexport type ServerActionFn<P extends unknown[], T> = (\n    ...args: P\n) => Promise<ServerActionResult<T>>;\n\ntype ServerActionOptions = {\n    onError?: (error: unknown) => void;\n};\n\n/**\n * Wraps an async function to return a standardized ServerActionResult.\n * Catches any thrown errors and converts them to error results.\n */\nexport function serverAction<P extends unknown[], T>(\n    fn: (...args: P) => Promise<T>,\n    options?: ServerActionOptions,\n): ServerActionFn<P, T> {\n    return async (...args: P): Promise<ServerActionResult<T>> => {\n        try {\n            const data = await fn(...args);\n            return success(data);\n        } catch (err) {\n            options?.onError?.(err);\n\n            if (err instanceof Error) {\n                return error(err.message, err.name);\n            }\n\n            return error(\"An unexpected error occurred\", \"UNKNOWN_ERROR\");\n        }\n    };\n}\n\n/**\n * Type guard to check if a result is successful\n */\nexport function isSuccess<T>(\n    result: ServerActionResult<T>,\n): result is ServerActionSuccess<T> {\n    return result.ok === true;\n}\n\n/**\n * Type guard to check if a result is an error\n */\nexport function isError<T>(\n    result: ServerActionResult<T>,\n): result is ServerActionError {\n    return result.ok === false;\n}\n\n/**\n * Unwraps a successful result or throws the error message\n */\nexport function unwrap<T>(result: ServerActionResult<T>): T {\n    if (result.ok) {\n        return result.data;\n    }\n    throw new Error(result.message);\n}\n\n/**\n * Unwraps a successful result or returns a default value\n */\nexport function unwrapOr<T>(result: ServerActionResult<T>, defaultValue: T): T {\n    if (result.ok) {\n        return result.data;\n    }\n    return defaultValue;\n}\n","\"use server\";\n\nimport type { ServerActionResult } from \"./server-action\";\n\n/**\n * A middleware function that wraps a server action.\n * Receives the next function in the chain and the parameters passed to the action.\n */\nexport type Middleware<P extends unknown[], T> = (\n    next: (...params: P) => Promise<ServerActionResult<T>>,\n    ...params: P\n) => Promise<ServerActionResult<T>>;\n\n/**\n * Creates a type-safe middleware function.\n *\n * @example\n * ```ts\n * const withLogging = createMiddleware(async (next, ...params) => {\n *     console.log(\"Calling action with:\", params);\n *     const result = await next(...params);\n *     console.log(\"Result:\", result);\n *     return result;\n * });\n * ```\n */\nexport function createMiddleware<P extends unknown[], T>(\n    handler: Middleware<P, T>,\n): Middleware<P, T> {\n    return handler;\n}\n\n/**\n * Applies middleware to a server action.\n * Middleware is executed in order (first middleware wraps second, etc).\n *\n * @example\n * ```ts\n * const protectedAction = applyMiddleware(\n *     myServerAction,\n *     [withAuth, withLogging, withValidation]\n * );\n * ```\n */\nexport function applyMiddleware<P extends unknown[], T>(\n    action: (...params: P) => Promise<ServerActionResult<T>>,\n    middleware: Middleware<P, T>[],\n): (...params: P) => Promise<ServerActionResult<T>> {\n    return middleware.reduceRight(\n        (next, mw) =>\n            (...params: P) =>\n                mw(next, ...params),\n        action,\n    );\n}\n\n/**\n * Composes multiple middleware into a single middleware.\n *\n * @example\n * ```ts\n * const combined = composeMiddleware(withAuth, withLogging, withValidation);\n * const protectedAction = applyMiddleware(myAction, [combined]);\n * ```\n */\nexport function composeMiddleware<P extends unknown[], T>(\n    ...middleware: Middleware<P, T>[]\n): Middleware<P, T> {\n    return (next, ...params) => {\n        const chain = middleware.reduceRight(\n            (nextFn, mw) =>\n                (...p: P) =>\n                    mw(nextFn, ...p),\n            next,\n        );\n        return chain(...params);\n    };\n}\n\n/**\n * A Zod-like schema interface for validation.\n * Works with Zod, Valibot, or any schema library with a compatible safeParse method.\n */\nexport type ValidationSchema<T> = {\n    safeParse(data: unknown):\n        | { success: true; data: T }\n        | { success: false; error: { message?: string; errors?: Array<{ message: string }> } };\n};\n\nexport type WithValidationOptions = {\n    /** Error code to return on validation failure. Defaults to \"VALIDATION_ERROR\" */\n    code?: string;\n    /** Custom error message formatter */\n    formatError?: (error: {\n        message?: string;\n        errors?: Array<{ message: string }>;\n    }) => string;\n};\n\n/**\n * Creates a middleware that validates the first parameter against a schema.\n * Works with Zod, Valibot, or any library with a compatible safeParse method.\n *\n * @example\n * ```ts\n * import { z } from \"zod\";\n * import { withValidation, applyMiddleware } from \"use-server-action/server\";\n *\n * const CreateUserSchema = z.object({\n *     name: z.string().min(1),\n *     email: z.string().email(),\n * });\n *\n * const createUser = applyMiddleware(\n *     serverAction(async (input: z.infer<typeof CreateUserSchema>) => {\n *         return await db.user.create({ data: input });\n *     }),\n *     [withValidation(CreateUserSchema)]\n * );\n * ```\n */\nexport function withValidation<TInput, T>(\n    schema: ValidationSchema<TInput>,\n    options: WithValidationOptions = {},\n): Middleware<[TInput], T> {\n    const { code = \"VALIDATION_ERROR\", formatError } = options;\n\n    return async (next, input) => {\n        const result = schema.safeParse(input);\n\n        if (!result.success) {\n            const message = formatError\n                ? formatError(result.error)\n                : result.error.errors?.[0]?.message ??\n                  result.error.message ??\n                  \"Validation failed\";\n\n            return { ok: false, message, code };\n        }\n\n        return next(result.data);\n    };\n}\n\n/**\n * Creates a middleware that logs action calls and results.\n */\nexport function withLogging<P extends unknown[], T>(\n    logger: {\n        onCall?: (params: P) => void;\n        onSuccess?: (data: T, params: P) => void;\n        onError?: (\n            message: string,\n            code: string | undefined,\n            params: P,\n        ) => void;\n    } = {},\n): Middleware<P, T> {\n    return async (next, ...params) => {\n        logger.onCall?.(params);\n        const result = await next(...params);\n        if (result.ok) {\n            logger.onSuccess?.(result.data, params);\n        } else {\n            logger.onError?.(result.message, result.code, params);\n        }\n        return result;\n    };\n}\n"],"mappings":";AAeO,SAAS,QAAW,MAAiC;AACxD,SAAO,EAAE,IAAI,MAAM,KAAK;AAC5B;AAEO,SAAS,MAAM,SAAiB,MAAkC;AACrE,SAAO,EAAE,IAAI,OAAO,SAAS,KAAK;AACtC;AAcO,SAAS,aACZ,IACA,SACoB;AACpB,SAAO,UAAU,SAA4C;AACzD,QAAI;AACA,YAAM,OAAO,MAAM,GAAG,GAAG,IAAI;AAC7B,aAAO,QAAQ,IAAI;AAAA,IACvB,SAAS,KAAK;AACV,eAAS,UAAU,GAAG;AAEtB,UAAI,eAAe,OAAO;AACtB,eAAO,MAAM,IAAI,SAAS,IAAI,IAAI;AAAA,MACtC;AAEA,aAAO,MAAM,gCAAgC,eAAe;AAAA,IAChE;AAAA,EACJ;AACJ;AAKO,SAAS,UACZ,QACgC;AAChC,SAAO,OAAO,OAAO;AACzB;AAKO,SAAS,QACZ,QAC2B;AAC3B,SAAO,OAAO,OAAO;AACzB;AAKO,SAAS,OAAU,QAAkC;AACxD,MAAI,OAAO,IAAI;AACX,WAAO,OAAO;AAAA,EAClB;AACA,QAAM,IAAI,MAAM,OAAO,OAAO;AAClC;AAKO,SAAS,SAAY,QAA+B,cAAoB;AAC3E,MAAI,OAAO,IAAI;AACX,WAAO,OAAO;AAAA,EAClB;AACA,SAAO;AACX;;;ACjEO,SAAS,iBACZ,SACgB;AAChB,SAAO;AACX;AAcO,SAAS,gBACZ,QACA,YACgD;AAChD,SAAO,WAAW;AAAA,IACd,CAAC,MAAM,OACH,IAAI,WACA,GAAG,MAAM,GAAG,MAAM;AAAA,IAC1B;AAAA,EACJ;AACJ;AAWO,SAAS,qBACT,YACa;AAChB,SAAO,CAAC,SAAS,WAAW;AACxB,UAAM,QAAQ,WAAW;AAAA,MACrB,CAAC,QAAQ,OACL,IAAI,MACA,GAAG,QAAQ,GAAG,CAAC;AAAA,MACvB;AAAA,IACJ;AACA,WAAO,MAAM,GAAG,MAAM;AAAA,EAC1B;AACJ;AA4CO,SAAS,eACZ,QACA,UAAiC,CAAC,GACX;AACvB,QAAM,EAAE,OAAO,oBAAoB,YAAY,IAAI;AAEnD,SAAO,OAAO,MAAM,UAAU;AAC1B,UAAM,SAAS,OAAO,UAAU,KAAK;AAErC,QAAI,CAAC,OAAO,SAAS;AACjB,YAAM,UAAU,cACV,YAAY,OAAO,KAAK,IACxB,OAAO,MAAM,SAAS,CAAC,GAAG,WAC1B,OAAO,MAAM,WACb;AAEN,aAAO,EAAE,IAAI,OAAO,SAAS,KAAK;AAAA,IACtC;AAEA,WAAO,KAAK,OAAO,IAAI;AAAA,EAC3B;AACJ;AAKO,SAAS,YACZ,SAQI,CAAC,GACW;AAChB,SAAO,OAAO,SAAS,WAAW;AAC9B,WAAO,SAAS,MAAM;AACtB,UAAM,SAAS,MAAM,KAAK,GAAG,MAAM;AACnC,QAAI,OAAO,IAAI;AACX,aAAO,YAAY,OAAO,MAAM,MAAM;AAAA,IAC1C,OAAO;AACH,aAAO,UAAU,OAAO,SAAS,OAAO,MAAM,MAAM;AAAA,IACxD;AACA,WAAO;AAAA,EACX;AACJ;","names":[]}
+{"version":3,"sources":["../src/server/server-action.ts","../src/server/context-middleware.ts","../src/server/action-builder.ts","../src/server/middleware-utils.ts"],"sourcesContent":["\"use server\";\n\nexport type ServerActionSuccess<T> = {\n    ok: true;\n    data: T;\n};\n\nexport type ServerActionError = {\n    ok: false;\n    message: string;\n    code?: string;\n};\n\nexport type ServerActionResult<T> = ServerActionSuccess<T> | ServerActionError;\n\nexport function success<T>(data: T): ServerActionSuccess<T> {\n    return { ok: true, data };\n}\n\nexport function error(message: string, code?: string): ServerActionError {\n    return { ok: false, message, code };\n}\n\nexport type ServerActionFn<P extends unknown[], T> = (\n    ...args: P\n) => Promise<ServerActionResult<T>>;\n\ntype ServerActionOptions = {\n    onError?: (error: unknown) => void;\n};\n\n/**\n * Wraps an async function to return a standardized ServerActionResult.\n * Catches any thrown errors and converts them to error results.\n *\n * @deprecated Use `createAction().input(schema).handle(fn)` instead.\n * The new API provides better type inference and built-in validation.\n *\n * @example\n * ```ts\n * // Old way (deprecated):\n * const myAction = serverAction(async (input: MyInput) => {\n *     return await doSomething(input);\n * });\n *\n * // New way:\n * const myAction = createAction()\n *     .input(mySchema)\n *     .handle(async (ctx, input) => {\n *         return { ok: true, data: await doSomething(input) };\n *     });\n * ```\n */\nexport function serverAction<P extends unknown[], T>(\n    fn: (...args: P) => Promise<T>,\n    options?: ServerActionOptions,\n): ServerActionFn<P, T> {\n    return async (...args: P): Promise<ServerActionResult<T>> => {\n        try {\n            const data = await fn(...args);\n            return success(data);\n        } catch (err) {\n            options?.onError?.(err);\n\n            if (err instanceof Error) {\n                return error(err.message, err.name);\n            }\n\n            return error(\"An unexpected error occurred\", \"UNKNOWN_ERROR\");\n        }\n    };\n}\n\n/**\n * Type guard to check if a result is successful\n */\nexport function isSuccess<T>(\n    result: ServerActionResult<T>,\n): result is ServerActionSuccess<T> {\n    return result.ok === true;\n}\n\n/**\n * Type guard to check if a result is an error\n */\nexport function isError<T>(\n    result: ServerActionResult<T>,\n): result is ServerActionError {\n    return result.ok === false;\n}\n\n/**\n * Unwraps a successful result or throws the error message\n */\nexport function unwrap<T>(result: ServerActionResult<T>): T {\n    if (result.ok) {\n        return result.data;\n    }\n    throw new Error(result.message);\n}\n\n/**\n * Unwraps a successful result or returns a default value\n */\nexport function unwrapOr<T>(result: ServerActionResult<T>, defaultValue: T): T {\n    if (result.ok) {\n        return result.data;\n    }\n    return defaultValue;\n}\n","\"use server\";\n\nimport type { BaseContext, ContextMiddleware } from \"./types\";\n\n/**\n * Symbol to identify context-aware middleware at runtime\n */\nexport const CONTEXT_MIDDLEWARE = Symbol(\"contextMiddleware\");\n\n/**\n * Check if a middleware is context-aware\n */\nexport function isContextMiddleware(fn: unknown): boolean {\n    return typeof fn === \"function\" && (fn as any)[CONTEXT_MIDDLEWARE] === true;\n}\n\n/**\n * Creates a type-safe context-aware middleware.\n *\n * @example\n * ```ts\n * type User = { id: string; name: string };\n *\n * const withAuth = createContextMiddleware<\n *     [string],           // Parameters\n *     SomeReturnType,     // Return type\n *     {},                 // Input context (none required)\n *     { user: User }      // Output context (adds user)\n * >(async (next, ctx, input) => {\n *     const user = await authenticate();\n *     if (!user) {\n *         return { ok: false, message: \"Unauthorized\", code: \"UNAUTHORIZED\" };\n *     }\n *     // Pass the new context with user added\n *     return next({ ...ctx, user }, input);\n * });\n * ```\n */\nexport function createContextMiddleware<\n    P extends unknown[],\n    T,\n    CtxIn extends BaseContext = BaseContext,\n    CtxOut extends BaseContext = BaseContext,\n>(\n    handler: ContextMiddleware<P, T, CtxIn, CtxOut>,\n): ContextMiddleware<P, T, CtxIn, CtxOut> {\n    (handler as any)[CONTEXT_MIDDLEWARE] = true;\n    return handler;\n}\n","\"use server\";\n\nimport type { ServerActionResult } from \"./server-action\";\nimport type {\n    BaseContext,\n    ContextMiddleware,\n    Middleware,\n} from \"./types\";\nimport { isContextMiddleware } from \"./context-middleware\";\n\n/**\n * A builder for creating server actions with type-safe context accumulation.\n *\n * @template TInput - The input parameters as a tuple type\n * @template TContext - The accumulated context type from all middleware\n */\nclass ActionBuilder<\n    TInput extends unknown[] = unknown[],\n    TContext extends BaseContext = {},\n> {\n    private middlewares: Array<\n        ContextMiddleware<any, any, any, any> | Middleware<any, any>\n    > = [];\n\n    private constructor(\n        middlewares: Array<\n            ContextMiddleware<any, any, any, any> | Middleware<any, any>\n        > = [],\n    ) {\n        this.middlewares = middlewares;\n    }\n\n    /**\n     * Create a new ActionBuilder instance\n     */\n    static create<TInput extends unknown[]>(): ActionBuilder<TInput, {}> {\n        return new ActionBuilder<TInput, {}>();\n    }\n\n    /**\n     * Add a context-aware middleware to the chain.\n     * The middleware receives the accumulated context and can add new context.\n     *\n     * @example\n     * ```ts\n     * const withUser = createContextMiddleware(async (next, ctx, ...args) => {\n     *     const user = await getUser();\n     *     if (!user) {\n     *         return { ok: false, message: \"Unauthorized\", code: \"UNAUTHORIZED\" };\n     *     }\n     *     return next({ ...ctx, user }, ...args);\n     * });\n     *\n     * const action = createAction<[{ name: string }]>()\n     *     .use(withUser)\n     *     .handle(async (ctx, input) => {\n     *         // ctx.user is fully typed!\n     *     });\n     * ```\n     */\n    use<CtxOut extends BaseContext>(\n        middleware: ContextMiddleware<TInput, any, TContext, CtxOut>,\n    ): ActionBuilder<TInput, TContext & CtxOut>;\n\n    /**\n     * Add a regular (non-context) middleware to the chain.\n     * The middleware can transform input/output but doesn't modify context.\n     *\n     * @example\n     * ```ts\n     * const withLogging = createMiddleware(async (next, ...args) => {\n     *     console.log(\"Args:\", args);\n     *     const result = await next(...args);\n     *     console.log(\"Result:\", result);\n     *     return result;\n     * });\n     *\n     * const action = createAction<[string]>()\n     *     .use(withLogging)\n     *     .handle(async (ctx, input) => { ... });\n     * ```\n     */\n    use(middleware: Middleware<TInput, any>): ActionBuilder<TInput, TContext>;\n\n    use(middleware: any): any {\n        return new ActionBuilder<TInput, TContext>([\n            ...this.middlewares,\n            middleware,\n        ]);\n    }\n\n    /**\n     * Define the action handler. This finalizes the builder and returns the executable action.\n     * The handler receives the accumulated context and input parameters.\n     *\n     * @example\n     * ```ts\n     * const action = createAction<[{ name: string; email: string }]>()\n     *     .use(withUser)\n     *     .handle(async (ctx, input) => {\n     *         // ctx and input are fully typed\n     *         return { ok: true, data: result };\n     *     });\n     *\n     * // Call the action\n     * const result = await action({ name: \"John\", email: \"john@example.com\" });\n     * ```\n     */\n    handle<TOutput>(\n        handler: (\n            ctx: TContext,\n            ...args: TInput\n        ) => Promise<ServerActionResult<TOutput>>,\n    ): (...args: TInput) => Promise<ServerActionResult<TOutput>> {\n        const middlewares = [...this.middlewares];\n\n        return async (...args: TInput): Promise<ServerActionResult<TOutput>> => {\n            // Build the middleware chain\n            type CtxNextFn = (\n                ctx: BaseContext,\n                ...args: TInput\n            ) => Promise<ServerActionResult<TOutput>>;\n\n            const finalHandler: CtxNextFn = async (ctx, ...a) => {\n                return handler(ctx as TContext, ...a);\n            };\n\n            // Build chain from right to left (last middleware wraps closest to handler)\n            const chain = middlewares.reduceRight<CtxNextFn>((next, mw) => {\n                if (isContextMiddleware(mw)) {\n                    // Context middleware: (next, ctx, ...params) => ...\n                    return async (ctx, ...a) => {\n                        return (mw as ContextMiddleware<TInput, TOutput, any, any>)(\n                            async (newCtx, ...params) => next(newCtx, ...(params as TInput)),\n                            ctx,\n                            ...a,\n                        );\n                    };\n                } else {\n                    // Regular middleware: (next, ...params) => ...\n                    // Pass context through unchanged\n                    return async (ctx, ...a) => {\n                        return (mw as Middleware<TInput, TOutput>)(\n                            async (...params) => next(ctx, ...(params as TInput)),\n                            ...a,\n                        );\n                    };\n                }\n            }, finalHandler);\n\n            // Start with empty context\n            try {\n                return await chain({}, ...args);\n            } catch (err) {\n                const message =\n                    err instanceof Error ? err.message : \"Unknown error\";\n                const code =\n                    err instanceof Error ? err.name : \"UNKNOWN_ERROR\";\n                return { ok: false, message, code };\n            }\n        };\n    }\n}\n\n/**\n * Converts a type to a tuple of arguments.\n * - `void` becomes `[]` (no args)\n * - Single type `T` becomes `[T]`\n * - Tuple type `[A, B]` stays as `[A, B]`\n */\ntype ToArgs<T> = [T] extends [void] ? [] : T extends unknown[] ? T : [T];\n\n/**\n * Creates a new action builder with type-safe context accumulation.\n *\n * @example\n * ```ts\n * // Single input parameter\n * const createUser = createAction<{ name: string; email: string }>()\n *     .use(withUser)\n *     .handle(async (ctx, input) => {\n *         await db.users.create({ ...input, createdBy: ctx.user.id });\n *         return { ok: true, data: { success: true } };\n *     });\n *\n * // Multiple input parameters (use tuple)\n * const updateUser = createAction<[string, { name: string }]>()\n *     .use(withUser)\n *     .handle(async (ctx, id, data) => {\n *         await db.users.update(id, data);\n *         return { ok: true, data: { success: true } };\n *     });\n *\n * // With validation middleware\n * const createPost = createAction<z.infer<typeof postSchema>>()\n *     .use(withZodValidation(postSchema))\n *     .use(withUser)\n *     .handle(async (ctx, input) => {\n *         return { ok: true, data: await db.posts.create(input) };\n *     });\n * ```\n */\nexport function createAction<TInput = void>(): ActionBuilder<ToArgs<TInput>, {}> {\n    return ActionBuilder.create<ToArgs<TInput>>();\n}\n","\"use server\";\n\nimport type { ServerActionResult } from \"./server-action\";\nimport type { Middleware, ValidationSchema, WithValidationOptions } from \"./types\";\n\n/**\n * Creates a type-safe middleware function.\n *\n * @example\n * ```ts\n * const withLogging = createMiddleware(async (next, ...params) => {\n *     console.log(\"Calling action with:\", params);\n *     const result = await next(...params);\n *     console.log(\"Result:\", result);\n *     return result;\n * });\n * ```\n */\nexport function createMiddleware<P extends unknown[], T>(\n    handler: Middleware<P, T>,\n): Middleware<P, T> {\n    return handler;\n}\n\n/**\n * Applies middleware to a server action.\n * Middleware is executed in order (first middleware wraps second, etc).\n *\n * @deprecated Use `createAction().input(schema).use(middleware).handle(fn)` instead.\n * This provides better type inference and a more composable API.\n *\n * @example\n * ```ts\n * // Old way (deprecated):\n * const protectedAction = applyMiddleware(\n *     myServerAction,\n *     [withAuth, withLogging, withValidation]\n * );\n *\n * // New way:\n * const protectedAction = createAction()\n *     .input(schema)\n *     .use(withAuth)\n *     .use(withLogging)\n *     .handle(async (ctx, input) => { ... });\n * ```\n */\nexport function applyMiddleware<P extends unknown[], T>(\n    action: (...params: P) => Promise<ServerActionResult<T>>,\n    middleware: Middleware<P, T>[],\n): (...params: P) => Promise<ServerActionResult<T>> {\n    return middleware.reduceRight(\n        (next, mw) =>\n            (...params: P) =>\n                mw(next, ...params),\n        action,\n    );\n}\n\n/**\n * Composes multiple middleware into a single middleware.\n *\n * @deprecated Use `createAction().use(mw1).use(mw2).handle(fn)` instead.\n * The builder pattern provides better type inference for chained middleware.\n *\n * @example\n * ```ts\n * // Old way (deprecated):\n * const combined = composeMiddleware(withAuth, withLogging, withValidation);\n * const protectedAction = applyMiddleware(myAction, [combined]);\n *\n * // New way:\n * const protectedAction = createAction()\n *     .input(schema)\n *     .use(withAuth)\n *     .use(withLogging)\n *     .handle(async (ctx, input) => { ... });\n * ```\n */\nexport function composeMiddleware<P extends unknown[], T>(\n    ...middleware: Middleware<P, T>[]\n): Middleware<P, T> {\n    return (next, ...params) => {\n        const chain = middleware.reduceRight(\n            (nextFn, mw) =>\n                (...p: P) =>\n                    mw(nextFn, ...p),\n            next,\n        );\n        return chain(...params);\n    };\n}\n\n/**\n * Creates a middleware that validates the first parameter against a schema.\n * Works with Zod, Valibot, or any library with a compatible safeParse method.\n *\n * @deprecated Use `createAction().input(schema).handle(fn)` instead.\n * The `.input()` method provides automatic type inference from the schema.\n *\n * @example\n * ```ts\n * import { z } from \"zod\";\n *\n * const schema = z.object({\n *     name: z.string().min(1),\n *     email: z.string().email(),\n * });\n *\n * // Old way (deprecated):\n * const createUser = applyMiddleware(\n *     serverAction(async (input: z.infer<typeof schema>) => {\n *         return await db.user.create({ data: input });\n *     }),\n *     [withZodValidation(schema)]\n * );\n *\n * // New way:\n * const createUser = createAction()\n *     .input(schema)  // Type is inferred automatically!\n *     .handle(async (ctx, input) => {\n *         return { ok: true, data: await db.user.create({ data: input }) };\n *     });\n * ```\n */\nexport function withZodValidation<TInput, T>(\n    schema: ValidationSchema<TInput>,\n    options: WithValidationOptions = {},\n): Middleware<[TInput], T> {\n    const { code = \"VALIDATION_ERROR\", formatError } = options;\n\n    return async (next, input) => {\n        const result = schema.safeParse(input);\n\n        if (!result.success) {\n            const message = formatError\n                ? formatError(result.error)\n                : (result.error.errors?.[0]?.message ??\n                  result.error.message ??\n                  \"Validation failed\");\n\n            return { ok: false, message, code };\n        }\n\n        return next(result.data);\n    };\n}\n\n/**\n * Creates a middleware that logs action calls and results.\n */\nexport function withLogging<P extends unknown[], T>(\n    logger: {\n        onCall?: (params: P) => void;\n        onSuccess?: (data: T, params: P) => void;\n        onError?: (\n            message: string,\n            code: string | undefined,\n            params: P,\n        ) => void;\n    } = {},\n): Middleware<P, T> {\n    return async (next, ...params) => {\n        logger.onCall?.(params);\n        const result = await next(...params);\n        if (result.ok) {\n            logger.onSuccess?.(result.data, params);\n        } else {\n            logger.onError?.(result.message, result.code, params);\n        }\n        return result;\n    };\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -1,10 +1,14 @@
 {
     "name": "use-server-action",
-    "version": "1.1.3",
+    "version": "2.0.0",
     "description": "A React hook for working with Next.js server actions",
     "main": "./dist/index.js",
     "module": "./dist/index.mjs",
     "types": "./dist/index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/jackh-sh/use-server-action.git"
+    },
     "exports": {
         ".": {
             "import": {