server-act 1.6.1 → 1.8.0

package/README.md

@@ -69,12 +69,12 @@ import { serverAct } from "server-act";
 import { z } from "zod";
 
 export const sayHelloAction = serverAct
-  .middleware(() => {
+  .use(({ next }) => {
     const t = i18n();
-    const userId = "..."
-    return { t, userId };
+    const userId = "...";
+    return next({ ctx: { t, userId } });
   })
-  .input((ctx) => {
+  .input(({ ctx }) => {
     return z.object({
       name: z.string().min(1, { message: ctx.t("form.name.required") }),
     });
@@ -85,6 +85,91 @@ export const sayHelloAction = serverAct
   });
 ```
 
+#### Chaining Middlewares
+
+You can chain multiple middlewares by calling `.use(...)` repeatedly.
+
+- Middlewares run in registration order.
+- Each middleware receives the current `ctx` and forwards additions with `next({ ctx })`.
+- `next()` can be called without params when nothing needs to be added.
+- `next({ ctx })` shallow-merges the provided keys into the current context.
+- Later middleware values override earlier values for the same key.
+- Errors thrown in middleware propagate and stop later middleware from running.
+
+```ts
+// action.ts
+"use server";
+
+import { serverAct } from "server-act";
+
+export const createGreetingAction = serverAct
+  .use(({ next }) =>
+    next({
+      ctx: {
+        requestId: crypto.randomUUID(),
+        role: "user",
+      },
+    }),
+  )
+  .use(({ ctx, next }) =>
+    next({
+      ctx: {
+        role: "admin", // overrides previous role
+        actorLabel: `${ctx.role}-actor`,
+      },
+    }),
+  )
+  .use(({ ctx, next }) =>
+    next({
+      ctx: {
+        trace: `${ctx.requestId}:${ctx.actorLabel}`,
+      },
+    }),
+  )
+  .action(async ({ ctx }) => {
+    return `${ctx.role} -> ${ctx.trace}`;
+  });
+```
+
+#### Migrating From `.middleware()`
+
+`.middleware()` is still supported for backward compatibility, but it is deprecated in favor of `.use()`.
+
+```ts
+const legacyAction = serverAct.middleware(({ ctx }) => ({
+  user: getUser(),
+}));
+
+const nextStyleAction = serverAct.use(({ ctx, next }) =>
+  next({
+    ctx: {
+      user: getUser(),
+    },
+  }),
+);
+```
+
+#### Reusable Middleware
+
+Use `createServerActMiddleware` to define middleware once and reuse it across actions.
+
+```ts
+import { createServerActMiddleware, serverAct } from "server-act";
+
+const requestIdMiddleware = createServerActMiddleware(({ next }) =>
+  next({ ctx: { requestId: crypto.randomUUID() } }),
+);
+
+const traceMiddleware = createServerActMiddleware(({ ctx, next }) =>
+  next({ ctx: { trace: `${ctx.requestId}-trace` } }),
+);
+
+export const action = serverAct
+  .use(requestIdMiddleware)
+  .use(traceMiddleware)
+  .action(async ({ ctx }) => `${ctx.requestId}:${ctx.trace}`);
+```
+
 ### `useActionState` Support
 
 > `useActionState` Documentation:
@@ -99,9 +184,7 @@ import { serverAct } from "server-act";
 import { formDataToObject } from "server-act/utils";
 import { z } from "zod";
 
-function zodFormData<T extends z.ZodType>(
-  schema: T,
-): z.ZodPipe<z.ZodTransform<Record<string, unknown>, FormData>, T> {
+function zodFormData<T extends z.ZodType>(schema: T) {
   return z.preprocess<Record<string, unknown>, T, FormData>(
     (v) => formDataToObject(v),
     schema,
@@ -141,7 +224,7 @@ import { formDataToObject } from "server-act/utils";
 
 ```ts
 const formData = new FormData();
-formData.append('name', 'John');
+formData.append("name", "John");
 
 const result = formDataToObject(formData);
 // Result: { name: 'John' }
@@ -151,7 +234,7 @@ const result = formDataToObject(formData);
 
 ```ts
 const formData = new FormData();
-formData.append('user.name', 'John');
+formData.append("user.name", "John");
 
 const result = formDataToObject(formData);
 // Result: { user: { name: 'John' } }
@@ -166,9 +249,7 @@ import { serverAct } from "server-act";
 import { formDataToObject } from "server-act/utils";
 import { z } from "zod";
 
-function zodFormData<T extends z.ZodType>(
-  schema: T,
-): z.ZodPipe<z.ZodTransform<Record<string, unknown>, FormData>, T> {
+function zodFormData<T extends z.ZodType>(schema: T) {
   return z.preprocess<Record<string, unknown>, T, FormData>(
     (v) => formDataToObject(v),
     schema,

package/dist/index.cjs

@@ -0,0 +1,173 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _standard_schema_utils = require("@standard-schema/utils");
+//#region src/internal/middleware.ts
+function normalizeCtx(ctx) {
+	return ctx && typeof ctx === "object" ? { ...ctx } : {};
+}
+/**
+* Executes an array of middleware functions with the given initial context.
+*/
+async function executeMiddlewares(middlewares, initialCtx) {
+	const executeAt = async (index, ctx) => {
+		const entry = middlewares[index];
+		if (!entry) return ctx;
+		if (entry.kind === "legacy") {
+			const result = await entry.middleware({ ctx });
+			const nextCtx = result && typeof result === "object" ? {
+				...ctx,
+				...result
+			} : ctx;
+			return await executeAt(index + 1, nextCtx);
+		}
+		let nextCalled = false;
+		const result = await entry.middleware({
+			ctx,
+			next: async (opts) => {
+				nextCalled = true;
+				const nextCtx = opts?.ctx ? {
+					...ctx,
+					...opts.ctx
+				} : ctx;
+				return await executeAt(index + 1, nextCtx);
+			}
+		});
+		if (!nextCalled) throw new Error(".use() middleware must call next()");
+		return normalizeCtx(result);
+	};
+	return await executeAt(0, normalizeCtx(initialCtx));
+}
+//#endregion
+//#region src/internal/schema.ts
+async function standardValidate(schema, input) {
+	let result = schema["~standard"].validate(input);
+	if (result instanceof Promise) result = await result;
+	return result;
+}
+function getInputErrors(issues) {
+	const messages = [];
+	const fieldErrors = {};
+	for (const issue of issues) {
+		const dotPath = (0, _standard_schema_utils.getDotPath)(issue);
+		if (dotPath) if (fieldErrors[dotPath]) fieldErrors[dotPath].push(issue.message);
+		else fieldErrors[dotPath] = [issue.message];
+		else messages.push(issue.message);
+	}
+	return {
+		messages,
+		fieldErrors
+	};
+}
+//#endregion
+//#region src/index.ts
+function createNewServerActionBuilder(def) {
+	return createServerActionBuilder(def);
+}
+function createServerActMiddleware(middleware) {
+	return middleware;
+}
+function createServerActionBuilder(initDef = {}) {
+	const _def = {
+		input: void 0,
+		middleware: [],
+		...initDef
+	};
+	return {
+		middleware: (middleware) => createNewServerActionBuilder({
+			..._def,
+			middleware: [..._def.middleware, {
+				kind: "legacy",
+				middleware
+			}]
+		}),
+		use: ((middleware) => createNewServerActionBuilder({
+			..._def,
+			middleware: [..._def.middleware, {
+				kind: "use",
+				middleware
+			}]
+		})),
+		input: (input) => createNewServerActionBuilder({
+			..._def,
+			input
+		}),
+		action: (action) => {
+			return async (input) => {
+				let ctx = {};
+				if (_def.middleware.length > 0) ctx = await executeMiddlewares(_def.middleware, ctx);
+				if (_def.input) {
+					const result = await standardValidate(typeof _def.input === "function" ? await _def.input({ ctx }) : _def.input, input);
+					if (result.issues) throw new _standard_schema_utils.SchemaError(result.issues);
+					return await action({
+						ctx,
+						input: result.value
+					});
+				}
+				return await action({
+					ctx,
+					input: void 0
+				});
+			};
+		},
+		stateAction: (action) => {
+			return async (prevState, rawInput) => {
+				let ctx = {};
+				if (_def.middleware.length > 0) ctx = await executeMiddlewares(_def.middleware, ctx);
+				if (_def.input) {
+					const result = await standardValidate(typeof _def.input === "function" ? await _def.input({ ctx }) : _def.input, rawInput);
+					if (result.issues) return await action({
+						ctx,
+						prevState,
+						rawInput,
+						inputErrors: getInputErrors(result.issues)
+					});
+					return await action({
+						ctx,
+						prevState,
+						rawInput,
+						input: result.value
+					});
+				}
+				return await action({
+					ctx,
+					prevState,
+					rawInput,
+					input: void 0
+				});
+			};
+		},
+		formAction: (action) => {
+			return async (prevState, formData) => {
+				let ctx = {};
+				if (_def.middleware.length > 0) ctx = await executeMiddlewares(_def.middleware, ctx);
+				if (_def.input) {
+					const result = await standardValidate(typeof _def.input === "function" ? await _def.input({ ctx }) : _def.input, formData);
+					if (result.issues) return await action({
+						ctx,
+						prevState,
+						formData,
+						formErrors: getInputErrors(result.issues)
+					});
+					return await action({
+						ctx,
+						prevState,
+						formData,
+						input: result.value
+					});
+				}
+				return await action({
+					ctx,
+					prevState,
+					formData,
+					input: void 0
+				});
+			};
+		}
+	};
+}
+/**
+* Server action builder
+*/
+const serverAct = createServerActionBuilder();
+//#endregion
+exports.createServerActMiddleware = createServerActMiddleware;
+exports.serverAct = serverAct;

package/dist/{index.d.ts → index.d.cts}

@@ -1,5 +1,19 @@
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
+//#region src/internal/middleware.d.ts
+type LegacyMiddlewareFunction<TContext, TReturn> = (params: {
+  ctx: TContext;
+}) => Promise<TReturn> | TReturn;
+type MiddlewareContext = Record<string, unknown>;
+type Prettify$1<T> = { [P in keyof T]: T[P] } & {};
+type MiddlewareNextFunction<TContext extends MiddlewareContext> = <TAddedContext extends MiddlewareContext>(opts?: {
+  ctx?: TAddedContext;
+}) => Promise<Prettify$1<TContext & TAddedContext>>;
+type UseMiddlewareFunction<TContext extends MiddlewareContext, TNextContext extends MiddlewareContext> = (params: {
+  ctx: TContext;
+  next: MiddlewareNextFunction<TContext>;
+}) => Promise<TNextContext> | TNextContext;
+//#endregion
 //#region src/internal/schema.d.ts
 declare function getInputErrors(issues: ReadonlyArray<StandardSchemaV1.Issue>): {
   messages: string[];
@@ -10,12 +24,12 @@ declare function getInputErrors(issues: ReadonlyArray<StandardSchemaV1.Issue>):
 declare const unsetMarker: unique symbol;
 type UnsetMarker = typeof unsetMarker;
 type RemoveUnsetMarker<T> = T extends UnsetMarker ? undefined : T;
+type NormalizeContext<T> = RemoveUnsetMarker<T> extends Record<string, unknown> ? RemoveUnsetMarker<T> : {};
 type Equals<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
 type Prettify<T> = { [P in keyof T]: T[P] } & {};
 type SanitizeFunctionParam<T extends (param: any) => any> = T extends ((param: infer P) => infer R) ? Equals<P, undefined> extends true ? () => R : Equals<P, P | undefined> extends true ? (param?: P) => R : (param: P) => R : never;
 type InferParserType<T, TType extends "in" | "out"> = T extends StandardSchemaV1 ? TType extends "in" ? StandardSchemaV1.InferInput<T> : StandardSchemaV1.InferOutput<T> : never;
 type InferInputType<T, TType extends "in" | "out"> = T extends UnsetMarker ? undefined : InferParserType<T, TType>;
-type InferContextType<T> = RemoveUnsetMarker<T>;
 interface ActionParams<TInput = unknown, TContext = unknown> {
   _input: TInput;
   _context: TContext;
@@ -23,16 +37,28 @@ interface ActionParams<TInput = unknown, TContext = unknown> {
 interface ActionBuilder<TParams extends ActionParams> {
   /**
    * Middleware allows you to run code before the action, its return value will pass as context to the action.
+   *
+   * Chaining multiple middlewares is possible, each middleware receives context from previous middlewares
+   * and returns additional context that gets merged.
+   *
+   * @deprecated Use `.use()` instead.
+   */
+  middleware: <TNewContext>(middleware: LegacyMiddlewareFunction<NormalizeContext<TParams["_context"]>, TNewContext>) => ActionBuilder<{
+    _input: TParams["_input"];
+    _context: TParams["_context"] extends UnsetMarker ? TNewContext : Prettify<TParams["_context"] & TNewContext>;
+  }>;
+  /**
+   * tRPC-style middleware that forwards context via `next()`.
    */
-  middleware: <TContext>(middleware: () => Promise<TContext> | TContext) => Omit<ActionBuilder<{
+  use: <TNextContext extends Record<string, unknown>>(middleware: UseMiddlewareFunction<NormalizeContext<TParams["_context"]>, TNextContext>) => ActionBuilder<{
     _input: TParams["_input"];
-    _context: TContext;
-  }>, "middleware">;
+    _context: TNextContext;
+  }>;
   /**
    * Input validation for the action.
    */
   input: <TParser extends StandardSchemaV1>(input: ((params: {
-    ctx: InferContextType<TParams["_context"]>;
+    ctx: NormalizeContext<TParams["_context"]>;
   }) => Promise<TParser> | TParser) | TParser) => Omit<ActionBuilder<{
     _input: TParser;
     _context: TParams["_context"];
@@ -41,14 +67,14 @@ interface ActionBuilder<TParams extends ActionParams> {
    * Create an action.
    */
   action: <TOutput>(action: (params: {
-    ctx: InferContextType<TParams["_context"]>;
+    ctx: NormalizeContext<TParams["_context"]>;
     input: InferInputType<TParams["_input"], "out">;
   }) => Promise<TOutput>) => SanitizeFunctionParam<(input: InferInputType<TParams["_input"], "in">) => Promise<TOutput>>;
   /**
    * Create an action for React `useActionState`
    */
   stateAction: <TState, TPrevState = UnsetMarker>(action: (params: Prettify<{
-    ctx: InferContextType<TParams["_context"]>;
+    ctx: NormalizeContext<TParams["_context"]>;
     prevState: RemoveUnsetMarker<TPrevState>;
     rawInput: InferInputType<TParams["_input"], "in">;
   } & ({
@@ -64,7 +90,7 @@ interface ActionBuilder<TParams extends ActionParams> {
    * @deprecated Use `stateAction` instead.
    */
   formAction: <TState, TPrevState = UnsetMarker>(action: (params: Prettify<{
-    ctx: InferContextType<TParams["_context"]>;
+    ctx: NormalizeContext<TParams["_context"]>;
     prevState: RemoveUnsetMarker<TPrevState>;
     formData: FormData;
   } & ({
@@ -75,6 +101,7 @@ interface ActionBuilder<TParams extends ActionParams> {
     formErrors: ReturnType<typeof getInputErrors>;
   })>) => Promise<TState>) => (prevState: TState | RemoveUnsetMarker<TPrevState>, formData: InferInputType<TParams["_input"], "in">) => Promise<TState | RemoveUnsetMarker<TPrevState>>;
 }
+declare function createServerActMiddleware<TAddedContext extends Record<string, unknown>, TContext extends Record<string, unknown> = {}>(middleware: UseMiddlewareFunction<TContext, Prettify<TContext & TAddedContext>>): UseMiddlewareFunction<TContext, Prettify<TContext & TAddedContext>>;
 /**
  * Server action builder
  */
@@ -83,4 +110,4 @@ declare const serverAct: ActionBuilder<{
   _context: UnsetMarker;
 }>;
 //#endregion
-export { serverAct };
+export { createServerActMiddleware, serverAct };

package/dist/index.d.mts

@@ -1,5 +1,19 @@
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
+//#region src/internal/middleware.d.ts
+type LegacyMiddlewareFunction<TContext, TReturn> = (params: {
+  ctx: TContext;
+}) => Promise<TReturn> | TReturn;
+type MiddlewareContext = Record<string, unknown>;
+type Prettify$1<T> = { [P in keyof T]: T[P] } & {};
+type MiddlewareNextFunction<TContext extends MiddlewareContext> = <TAddedContext extends MiddlewareContext>(opts?: {
+  ctx?: TAddedContext;
+}) => Promise<Prettify$1<TContext & TAddedContext>>;
+type UseMiddlewareFunction<TContext extends MiddlewareContext, TNextContext extends MiddlewareContext> = (params: {
+  ctx: TContext;
+  next: MiddlewareNextFunction<TContext>;
+}) => Promise<TNextContext> | TNextContext;
+//#endregion
 //#region src/internal/schema.d.ts
 declare function getInputErrors(issues: ReadonlyArray<StandardSchemaV1.Issue>): {
   messages: string[];
@@ -10,12 +24,12 @@ declare function getInputErrors(issues: ReadonlyArray<StandardSchemaV1.Issue>):
 declare const unsetMarker: unique symbol;
 type UnsetMarker = typeof unsetMarker;
 type RemoveUnsetMarker<T> = T extends UnsetMarker ? undefined : T;
+type NormalizeContext<T> = RemoveUnsetMarker<T> extends Record<string, unknown> ? RemoveUnsetMarker<T> : {};
 type Equals<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
 type Prettify<T> = { [P in keyof T]: T[P] } & {};
 type SanitizeFunctionParam<T extends (param: any) => any> = T extends ((param: infer P) => infer R) ? Equals<P, undefined> extends true ? () => R : Equals<P, P | undefined> extends true ? (param?: P) => R : (param: P) => R : never;
 type InferParserType<T, TType extends "in" | "out"> = T extends StandardSchemaV1 ? TType extends "in" ? StandardSchemaV1.InferInput<T> : StandardSchemaV1.InferOutput<T> : never;
 type InferInputType<T, TType extends "in" | "out"> = T extends UnsetMarker ? undefined : InferParserType<T, TType>;
-type InferContextType<T> = RemoveUnsetMarker<T>;
 interface ActionParams<TInput = unknown, TContext = unknown> {
   _input: TInput;
   _context: TContext;
@@ -23,16 +37,28 @@ interface ActionParams<TInput = unknown, TContext = unknown> {
 interface ActionBuilder<TParams extends ActionParams> {
   /**
    * Middleware allows you to run code before the action, its return value will pass as context to the action.
+   *
+   * Chaining multiple middlewares is possible, each middleware receives context from previous middlewares
+   * and returns additional context that gets merged.
+   *
+   * @deprecated Use `.use()` instead.
+   */
+  middleware: <TNewContext>(middleware: LegacyMiddlewareFunction<NormalizeContext<TParams["_context"]>, TNewContext>) => ActionBuilder<{
+    _input: TParams["_input"];
+    _context: TParams["_context"] extends UnsetMarker ? TNewContext : Prettify<TParams["_context"] & TNewContext>;
+  }>;
+  /**
+   * tRPC-style middleware that forwards context via `next()`.
    */
-  middleware: <TContext>(middleware: () => Promise<TContext> | TContext) => Omit<ActionBuilder<{
+  use: <TNextContext extends Record<string, unknown>>(middleware: UseMiddlewareFunction<NormalizeContext<TParams["_context"]>, TNextContext>) => ActionBuilder<{
     _input: TParams["_input"];
-    _context: TContext;
-  }>, "middleware">;
+    _context: TNextContext;
+  }>;
   /**
    * Input validation for the action.
    */
   input: <TParser extends StandardSchemaV1>(input: ((params: {
-    ctx: InferContextType<TParams["_context"]>;
+    ctx: NormalizeContext<TParams["_context"]>;
   }) => Promise<TParser> | TParser) | TParser) => Omit<ActionBuilder<{
     _input: TParser;
     _context: TParams["_context"];
@@ -41,14 +67,14 @@ interface ActionBuilder<TParams extends ActionParams> {
    * Create an action.
    */
   action: <TOutput>(action: (params: {
-    ctx: InferContextType<TParams["_context"]>;
+    ctx: NormalizeContext<TParams["_context"]>;
     input: InferInputType<TParams["_input"], "out">;
   }) => Promise<TOutput>) => SanitizeFunctionParam<(input: InferInputType<TParams["_input"], "in">) => Promise<TOutput>>;
   /**
    * Create an action for React `useActionState`
    */
   stateAction: <TState, TPrevState = UnsetMarker>(action: (params: Prettify<{
-    ctx: InferContextType<TParams["_context"]>;
+    ctx: NormalizeContext<TParams["_context"]>;
     prevState: RemoveUnsetMarker<TPrevState>;
     rawInput: InferInputType<TParams["_input"], "in">;
   } & ({
@@ -64,7 +90,7 @@ interface ActionBuilder<TParams extends ActionParams> {
    * @deprecated Use `stateAction` instead.
    */
   formAction: <TState, TPrevState = UnsetMarker>(action: (params: Prettify<{
-    ctx: InferContextType<TParams["_context"]>;
+    ctx: NormalizeContext<TParams["_context"]>;
     prevState: RemoveUnsetMarker<TPrevState>;
     formData: FormData;
   } & ({
@@ -75,6 +101,7 @@ interface ActionBuilder<TParams extends ActionParams> {
     formErrors: ReturnType<typeof getInputErrors>;
   })>) => Promise<TState>) => (prevState: TState | RemoveUnsetMarker<TPrevState>, formData: InferInputType<TParams["_input"], "in">) => Promise<TState | RemoveUnsetMarker<TPrevState>>;
 }
+declare function createServerActMiddleware<TAddedContext extends Record<string, unknown>, TContext extends Record<string, unknown> = {}>(middleware: UseMiddlewareFunction<TContext, Prettify<TContext & TAddedContext>>): UseMiddlewareFunction<TContext, Prettify<TContext & TAddedContext>>;
 /**
  * Server action builder
  */
@@ -83,4 +110,4 @@ declare const serverAct: ActionBuilder<{
   _context: UnsetMarker;
 }>;
 //#endregion
-export { serverAct };
+export { createServerActMiddleware, serverAct };

package/dist/index.mjs

@@ -1,5 +1,41 @@
 import { SchemaError, getDotPath } from "@standard-schema/utils";
-
+//#region src/internal/middleware.ts
+function normalizeCtx(ctx) {
+	return ctx && typeof ctx === "object" ? { ...ctx } : {};
+}
+/**
+* Executes an array of middleware functions with the given initial context.
+*/
+async function executeMiddlewares(middlewares, initialCtx) {
+	const executeAt = async (index, ctx) => {
+		const entry = middlewares[index];
+		if (!entry) return ctx;
+		if (entry.kind === "legacy") {
+			const result = await entry.middleware({ ctx });
+			const nextCtx = result && typeof result === "object" ? {
+				...ctx,
+				...result
+			} : ctx;
+			return await executeAt(index + 1, nextCtx);
+		}
+		let nextCalled = false;
+		const result = await entry.middleware({
+			ctx,
+			next: async (opts) => {
+				nextCalled = true;
+				const nextCtx = opts?.ctx ? {
+					...ctx,
+					...opts.ctx
+				} : ctx;
+				return await executeAt(index + 1, nextCtx);
+			}
+		});
+		if (!nextCalled) throw new Error(".use() middleware must call next()");
+		return normalizeCtx(result);
+	};
+	return await executeAt(0, normalizeCtx(initialCtx));
+}
+//#endregion
 //#region src/internal/schema.ts
 async function standardValidate(schema, input) {
 	let result = schema["~standard"].validate(input);
@@ -20,34 +56,45 @@ function getInputErrors(issues) {
 		fieldErrors
 	};
 }
-
 //#endregion
 //#region src/index.ts
-const unsetMarker = Symbol("unsetMarker");
 function createNewServerActionBuilder(def) {
 	return createServerActionBuilder(def);
 }
+function createServerActMiddleware(middleware) {
+	return middleware;
+}
 function createServerActionBuilder(initDef = {}) {
 	const _def = {
 		input: void 0,
-		middleware: void 0,
+		middleware: [],
 		...initDef
 	};
 	return {
 		middleware: (middleware) => createNewServerActionBuilder({
 			..._def,
-			middleware
+			middleware: [..._def.middleware, {
+				kind: "legacy",
+				middleware
+			}]
 		}),
+		use: ((middleware) => createNewServerActionBuilder({
+			..._def,
+			middleware: [..._def.middleware, {
+				kind: "use",
+				middleware
+			}]
+		})),
 		input: (input) => createNewServerActionBuilder({
 			..._def,
 			input
 		}),
 		action: (action) => {
 			return async (input) => {
-				const ctx = await _def.middleware?.();
+				let ctx = {};
+				if (_def.middleware.length > 0) ctx = await executeMiddlewares(_def.middleware, ctx);
 				if (_def.input) {
-					const inputSchema = typeof _def.input === "function" ? await _def.input({ ctx }) : _def.input;
-					const result = await standardValidate(inputSchema, input);
+					const result = await standardValidate(typeof _def.input === "function" ? await _def.input({ ctx }) : _def.input, input);
 					if (result.issues) throw new SchemaError(result.issues);
 					return await action({
 						ctx,
@@ -62,10 +109,10 @@ function createServerActionBuilder(initDef = {}) {
 		},
 		stateAction: (action) => {
 			return async (prevState, rawInput) => {
-				const ctx = await _def.middleware?.();
+				let ctx = {};
+				if (_def.middleware.length > 0) ctx = await executeMiddlewares(_def.middleware, ctx);
 				if (_def.input) {
-					const inputSchema = typeof _def.input === "function" ? await _def.input({ ctx }) : _def.input;
-					const result = await standardValidate(inputSchema, rawInput);
+					const result = await standardValidate(typeof _def.input === "function" ? await _def.input({ ctx }) : _def.input, rawInput);
 					if (result.issues) return await action({
 						ctx,
 						prevState,
@@ -89,10 +136,10 @@ function createServerActionBuilder(initDef = {}) {
 		},
 		formAction: (action) => {
 			return async (prevState, formData) => {
-				const ctx = await _def.middleware?.();
+				let ctx = {};
+				if (_def.middleware.length > 0) ctx = await executeMiddlewares(_def.middleware, ctx);
 				if (_def.input) {
-					const inputSchema = typeof _def.input === "function" ? await _def.input({ ctx }) : _def.input;
-					const result = await standardValidate(inputSchema, formData);
+					const result = await standardValidate(typeof _def.input === "function" ? await _def.input({ ctx }) : _def.input, formData);
 					if (result.issues) return await action({
 						ctx,
 						prevState,
@@ -120,6 +167,5 @@ function createServerActionBuilder(initDef = {}) {
 * Server action builder
 */
 const serverAct = createServerActionBuilder();
-
 //#endregion
-export { serverAct };
+export { createServerActMiddleware, serverAct };

package/dist/{utils.js → utils.cjs}

@@ -1,9 +1,8 @@
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#region src/internal/assert.ts
 function assert(condition, message) {
 	if (!condition) throw new Error(message || "Assertion failed");
 }
-
 //#endregion
 //#region src/utils.ts
 function isNumberString(str) {
@@ -99,12 +98,8 @@ function set(obj, path, value) {
 */
 function formDataToObject(formData) {
 	const obj = {};
-	for (const [key, value] of formData.entries()) {
-		const parts = key.split(/[\.\[\]]/).filter(Boolean);
-		set(obj, parts, value);
-	}
+	for (const [key, value] of formData.entries()) set(obj, key.split(/[.[\]]/).filter(Boolean), value);
 	return obj;
 }
-
 //#endregion
-exports.formDataToObject = formDataToObject;
+exports.formDataToObject = formDataToObject;

package/dist/utils.mjs

@@ -2,7 +2,6 @@
 function assert(condition, message) {
 	if (!condition) throw new Error(message || "Assertion failed");
 }
-
 //#endregion
 //#region src/utils.ts
 function isNumberString(str) {
@@ -98,12 +97,8 @@ function set(obj, path, value) {
 */
 function formDataToObject(formData) {
 	const obj = {};
-	for (const [key, value] of formData.entries()) {
-		const parts = key.split(/[\.\[\]]/).filter(Boolean);
-		set(obj, parts, value);
-	}
+	for (const [key, value] of formData.entries()) set(obj, key.split(/[.[\]]/).filter(Boolean), value);
 	return obj;
 }
-
 //#endregion
-export { formDataToObject };
+export { formDataToObject };

package/package.json

@@ -1,16 +1,33 @@
 {
   "name": "server-act",
-  "version": "1.6.1",
+  "version": "1.8.0",
+  "keywords": [
+    "action",
+    "next",
+    "nextjs",
+    "react",
+    "react server action",
+    "react server component",
+    "rsc",
+    "server action",
+    "server component"
+  ],
   "homepage": "https://github.com/chungweileong94/server-act#readme",
-  "author": "chungweileong94",
+  "bugs": {
+    "url": "https://github.com/chungweileong94/server-act/issues"
+  },
   "license": "MIT",
+  "author": "chungweileong94",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/chungweileong94/server-act.git"
   },
-  "bugs": {
-    "url": "https://github.com/chungweileong94/server-act/issues"
-  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "package.json",
+    "README.md"
+  ],
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -24,23 +41,6 @@
     },
     "./package.json": "./package.json"
   },
-  "files": [
-    "dist",
-    "package.json",
-    "LICENSE",
-    "README.md"
-  ],
-  "keywords": [
-    "next",
-    "nextjs",
-    "react",
-    "react server component",
-    "react server action",
-    "rsc",
-    "server component",
-    "server action",
-    "action"
-  ],
   "dependencies": {
     "@standard-schema/spec": "^1.0.0",
     "@standard-schema/utils": "^0.3.0"

package/dist/index.js

@@ -1,148 +0,0 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-const __standard_schema_utils = __toESM(require("@standard-schema/utils"));
-
-//#region src/internal/schema.ts
-async function standardValidate(schema, input) {
-	let result = schema["~standard"].validate(input);
-	if (result instanceof Promise) result = await result;
-	return result;
-}
-function getInputErrors(issues) {
-	const messages = [];
-	const fieldErrors = {};
-	for (const issue of issues) {
-		const dotPath = (0, __standard_schema_utils.getDotPath)(issue);
-		if (dotPath) if (fieldErrors[dotPath]) fieldErrors[dotPath].push(issue.message);
-		else fieldErrors[dotPath] = [issue.message];
-		else messages.push(issue.message);
-	}
-	return {
-		messages,
-		fieldErrors
-	};
-}
-
-//#endregion
-//#region src/index.ts
-const unsetMarker = Symbol("unsetMarker");
-function createNewServerActionBuilder(def) {
-	return createServerActionBuilder(def);
-}
-function createServerActionBuilder(initDef = {}) {
-	const _def = {
-		input: void 0,
-		middleware: void 0,
-		...initDef
-	};
-	return {
-		middleware: (middleware) => createNewServerActionBuilder({
-			..._def,
-			middleware
-		}),
-		input: (input) => createNewServerActionBuilder({
-			..._def,
-			input
-		}),
-		action: (action) => {
-			return async (input) => {
-				const ctx = await _def.middleware?.();
-				if (_def.input) {
-					const inputSchema = typeof _def.input === "function" ? await _def.input({ ctx }) : _def.input;
-					const result = await standardValidate(inputSchema, input);
-					if (result.issues) throw new __standard_schema_utils.SchemaError(result.issues);
-					return await action({
-						ctx,
-						input: result.value
-					});
-				}
-				return await action({
-					ctx,
-					input: void 0
-				});
-			};
-		},
-		stateAction: (action) => {
-			return async (prevState, rawInput) => {
-				const ctx = await _def.middleware?.();
-				if (_def.input) {
-					const inputSchema = typeof _def.input === "function" ? await _def.input({ ctx }) : _def.input;
-					const result = await standardValidate(inputSchema, rawInput);
-					if (result.issues) return await action({
-						ctx,
-						prevState,
-						rawInput,
-						inputErrors: getInputErrors(result.issues)
-					});
-					return await action({
-						ctx,
-						prevState,
-						rawInput,
-						input: result.value
-					});
-				}
-				return await action({
-					ctx,
-					prevState,
-					rawInput,
-					input: void 0
-				});
-			};
-		},
-		formAction: (action) => {
-			return async (prevState, formData) => {
-				const ctx = await _def.middleware?.();
-				if (_def.input) {
-					const inputSchema = typeof _def.input === "function" ? await _def.input({ ctx }) : _def.input;
-					const result = await standardValidate(inputSchema, formData);
-					if (result.issues) return await action({
-						ctx,
-						prevState,
-						formData,
-						formErrors: getInputErrors(result.issues)
-					});
-					return await action({
-						ctx,
-						prevState,
-						formData,
-						input: result.value
-					});
-				}
-				return await action({
-					ctx,
-					prevState,
-					formData,
-					input: void 0
-				});
-			};
-		}
-	};
-}
-/**
-* Server action builder
-*/
-const serverAct = createServerActionBuilder();
-
-//#endregion
-exports.serverAct = serverAct;