server-act 1.6.0 → 1.7.0

package/README.md

@@ -71,7 +71,7 @@ import { z } from "zod";
 export const sayHelloAction = serverAct
   .middleware(() => {
     const t = i18n();
-    const userId = "..."
+    const userId = "...";
     return { t, userId };
   })
   .input((ctx) => {
@@ -85,63 +85,172 @@ export const sayHelloAction = serverAct
   });
 ```
 
+#### Chaining Middlewares
+
+You can chain multiple middlewares by calling `.middleware(...)` repeatedly.
+
+- Middlewares run in registration order.
+- Each middleware receives the current `ctx` and can return additional context.
+- Returned objects are shallow-merged into `ctx`.
+- 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
+  .middleware(() => ({
+    requestId: crypto.randomUUID(),
+    role: "user",
+  }))
+  .middleware(({ ctx }) => ({
+    role: "admin", // overrides previous role
+    actorLabel: `${ctx.role}-actor`,
+  }))
+  .middleware(({ ctx }) => ({
+    trace: `${ctx.requestId}:${ctx.actorLabel}`,
+  }))
+  .action(async ({ ctx }) => {
+    return `${ctx.role} -> ${ctx.trace}`;
+  });
+```
+
 ### `useActionState` Support
 
 > `useActionState` Documentation:
 >
 > - https://react.dev/reference/react/useActionState
 
-We recommend using [zod-form-data](https://www.npmjs.com/package/zod-form-data) for input validation.
-
 ```ts
 // action.ts;
 "use server";
 
 import { serverAct } from "server-act";
+import { formDataToObject } from "server-act/utils";
 import { z } from "zod";
-import { zfd } from "zod-form-data";
+
+function zodFormData<T extends z.ZodType>(schema: T) {
+  return z.preprocess<Record<string, unknown>, T, FormData>(
+    (v) => formDataToObject(v),
+    schema,
+  );
+}
 
 export const sayHelloAction = serverAct
   .input(
-    zfd.formData({
-      name: zfd.text(
-        z
-          .string({ required_error: `You haven't told me your name` })
-          .max(20, { message: "Any shorter name? You name is too long 😬" }),
-      ),
-    }),
+    zodFormData(
+      z.object({
+        name: z
+          .string()
+          .min(1, { error: `You haven't told me your name` })
+          .max(20, { error: "Any shorter name? You name is too long 😬" }),
+      }),
+    ),
   )
-  .stateAction(async ({ formData, input, formErrors, ctx }) => {
-    if (formErrors) {
-      return { formData, formErrors: formErrors.fieldErrors };
+  .stateAction(async ({ rawInput, input, inputErrors, ctx }) => {
+    if (inputErrors) {
+      return { formData: rawInput, inputErrors: inputErrors.fieldErrors };
     }
     return { message: `Hello, ${input.name}!` };
   });
 ```
 
-```tsx
-// client-component.tsx
-"use client";
+## Utilities
 
-import { useActionState } from "react";
-import { sayHelloAction } from "./action";
+### `formDataToObject`
 
-export const ClientComponent = () => {
-  const [state, dispatch] = useActionState(sayHelloAction, undefined);
+The `formDataToObject` utility converts FormData to a structured JavaScript object, supporting nested objects, arrays, and complex form structures.
 
-  return (
-    <form action={dispatch}>
-      <input
-        name="name"
-        required
-        defaultValue={state?.formData?.get("name")?.toString()}
-      />
-      {state?.formErrors?.name?.map((error) => <p key={error}>{error}</p>)}
-
-      <button type="submit">Submit</button>
-
-      {!!state?.message && <p>{state.message}</p>}
-    </form>
+```ts
+import { formDataToObject } from "server-act/utils";
+```
+
+#### Basic Usage
+
+```ts
+const formData = new FormData();
+formData.append("name", "John");
+
+const result = formDataToObject(formData);
+// Result: { name: 'John' }
+```
+
+#### Nested Objects and Arrays
+
+```ts
+const formData = new FormData();
+formData.append("user.name", "John");
+
+const result = formDataToObject(formData);
+// Result: { user: { name: 'John' } }
+```
+
+#### With Zod
+
+```ts
+"use server";
+
+import { serverAct } from "server-act";
+import { formDataToObject } from "server-act/utils";
+import { z } from "zod";
+
+function zodFormData<T extends z.ZodType>(schema: T) {
+  return z.preprocess<Record<string, unknown>, T, FormData>(
+    (v) => formDataToObject(v),
+    schema,
   );
-};
+}
+
+export const createUserAction = serverAct
+  .input(
+    zodFormData(
+      z.object({
+        name: z.string().min(1, "Name is required"),
+      }),
+    ),
+  )
+  .stateAction(async ({ rawInput, input, inputErrors }) => {
+    if (inputErrors) {
+      return { formData: rawInput, errors: inputErrors.fieldErrors };
+    }
+
+    // Process the validated input
+    console.log("User:", input.name);
+
+    return { success: true, userId: "123" };
+  });
+```
+
+#### With Valibot
+
+```ts
+"use server";
+
+import { serverAct } from "server-act";
+import { formDataToObject } from "server-act/utils";
+import * as v from "valibot";
+
+export const createPostAction = serverAct
+  .input(
+    v.pipe(
+      v.custom<FormData>((value) => value instanceof FormData),
+      v.transform(formDataToObject),
+      v.object({
+        title: v.pipe(v.string(), v.minLength(1, "Title is required")),
+      }),
+    ),
+  )
+  .stateAction(async ({ rawInput, input, inputErrors }) => {
+    if (inputErrors) {
+      return { formData: rawInput, errors: inputErrors.fieldErrors };
+    }
+
+    // Process the validated input
+    console.log("Post:", input.title);
+
+    return { success: true, postId: "456" };
+  });
 ```

package/dist/index.cjs

@@ -0,0 +1,141 @@
+let _standard_schema_utils = require("@standard-schema/utils");
+
+//#region src/internal/middleware.ts
+/**
+* Executes an array of middleware functions with the given initial context.
+*/
+async function executeMiddlewares(middlewares, initialCtx) {
+	let ctx = initialCtx && typeof initialCtx === "object" ? { ...initialCtx } : {};
+	for (const middleware of middlewares) {
+		const result = await middleware({ ctx });
+		if (result && typeof result === "object") ctx = {
+			...ctx,
+			...result
+		};
+	}
+	return ctx;
+}
+
+//#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 createServerActionBuilder(initDef = {}) {
+	const _def = {
+		input: void 0,
+		middleware: [],
+		...initDef
+	};
+	return {
+		middleware: (middleware) => createNewServerActionBuilder({
+			..._def,
+			middleware: [..._def.middleware, 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.serverAct = serverAct;

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

@@ -1,7 +1,12 @@
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
-//#region src/utils.d.ts
-declare function getFormErrors(issues: ReadonlyArray<StandardSchemaV1.Issue>): {
+//#region src/internal/middleware.d.ts
+type MiddlewareFunction<TContext, TReturn> = (params: {
+  ctx: TContext;
+}) => Promise<TReturn> | TReturn;
+//#endregion
+//#region src/internal/schema.d.ts
+declare function getInputErrors(issues: ReadonlyArray<StandardSchemaV1.Issue>): {
   messages: string[];
   fieldErrors: Record<string, string[]>;
 };
@@ -15,7 +20,6 @@ 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 +27,19 @@ 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.
    */
-  middleware: <TContext>(middleware: () => Promise<TContext> | TContext) => Omit<ActionBuilder<{
+  middleware: <TNewContext>(middleware: MiddlewareFunction<RemoveUnsetMarker<TParams["_context"]>, TNewContext>) => ActionBuilder<{
     _input: TParams["_input"];
-    _context: TContext;
-  }>, "middleware">;
+    _context: TParams["_context"] extends UnsetMarker ? TNewContext : Prettify<TParams["_context"] & TNewContext>;
+  }>;
   /**
    * Input validation for the action.
    */
   input: <TParser extends StandardSchemaV1>(input: ((params: {
-    ctx: InferContextType<TParams["_context"]>;
+    ctx: RemoveUnsetMarker<TParams["_context"]>;
   }) => Promise<TParser> | TParser) | TParser) => Omit<ActionBuilder<{
     _input: TParser;
     _context: TParams["_context"];
@@ -41,14 +48,30 @@ interface ActionBuilder<TParams extends ActionParams> {
    * Create an action.
    */
   action: <TOutput>(action: (params: {
-    ctx: InferContextType<TParams["_context"]>;
+    ctx: RemoveUnsetMarker<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: RemoveUnsetMarker<TParams["_context"]>;
+    prevState: RemoveUnsetMarker<TPrevState>;
+    rawInput: InferInputType<TParams["_input"], "in">;
+  } & ({
+    input: InferInputType<TParams["_input"], "out">;
+    inputErrors?: undefined;
+  } | {
+    input?: undefined;
+    inputErrors: ReturnType<typeof getInputErrors>;
+  })>) => Promise<TState>) => (prevState: TState | RemoveUnsetMarker<TPrevState>, input: InferInputType<TParams["_input"], "in">) => Promise<TState | RemoveUnsetMarker<TPrevState>>;
+  /**
+   * Create an action for React `useActionState`
+   *
+   * @deprecated Use `stateAction` instead.
+   */
+  formAction: <TState, TPrevState = UnsetMarker>(action: (params: Prettify<{
+    ctx: RemoveUnsetMarker<TParams["_context"]>;
     prevState: RemoveUnsetMarker<TPrevState>;
     formData: FormData;
   } & ({
@@ -56,7 +79,7 @@ interface ActionBuilder<TParams extends ActionParams> {
     formErrors?: undefined;
   } | {
     input?: undefined;
-    formErrors: ReturnType<typeof getFormErrors>;
+    formErrors: ReturnType<typeof getInputErrors>;
   })>) => Promise<TState>) => (prevState: TState | RemoveUnsetMarker<TPrevState>, formData: InferInputType<TParams["_input"], "in">) => Promise<TState | RemoveUnsetMarker<TPrevState>>;
 }
 /**

package/dist/index.d.mts

@@ -1,7 +1,12 @@
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
-//#region src/utils.d.ts
-declare function getFormErrors(issues: ReadonlyArray<StandardSchemaV1.Issue>): {
+//#region src/internal/middleware.d.ts
+type MiddlewareFunction<TContext, TReturn> = (params: {
+  ctx: TContext;
+}) => Promise<TReturn> | TReturn;
+//#endregion
+//#region src/internal/schema.d.ts
+declare function getInputErrors(issues: ReadonlyArray<StandardSchemaV1.Issue>): {
   messages: string[];
   fieldErrors: Record<string, string[]>;
 };
@@ -15,7 +20,6 @@ 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 +27,19 @@ 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.
    */
-  middleware: <TContext>(middleware: () => Promise<TContext> | TContext) => Omit<ActionBuilder<{
+  middleware: <TNewContext>(middleware: MiddlewareFunction<RemoveUnsetMarker<TParams["_context"]>, TNewContext>) => ActionBuilder<{
     _input: TParams["_input"];
-    _context: TContext;
-  }>, "middleware">;
+    _context: TParams["_context"] extends UnsetMarker ? TNewContext : Prettify<TParams["_context"] & TNewContext>;
+  }>;
   /**
    * Input validation for the action.
    */
   input: <TParser extends StandardSchemaV1>(input: ((params: {
-    ctx: InferContextType<TParams["_context"]>;
+    ctx: RemoveUnsetMarker<TParams["_context"]>;
   }) => Promise<TParser> | TParser) | TParser) => Omit<ActionBuilder<{
     _input: TParser;
     _context: TParams["_context"];
@@ -41,14 +48,30 @@ interface ActionBuilder<TParams extends ActionParams> {
    * Create an action.
    */
   action: <TOutput>(action: (params: {
-    ctx: InferContextType<TParams["_context"]>;
+    ctx: RemoveUnsetMarker<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: RemoveUnsetMarker<TParams["_context"]>;
+    prevState: RemoveUnsetMarker<TPrevState>;
+    rawInput: InferInputType<TParams["_input"], "in">;
+  } & ({
+    input: InferInputType<TParams["_input"], "out">;
+    inputErrors?: undefined;
+  } | {
+    input?: undefined;
+    inputErrors: ReturnType<typeof getInputErrors>;
+  })>) => Promise<TState>) => (prevState: TState | RemoveUnsetMarker<TPrevState>, input: InferInputType<TParams["_input"], "in">) => Promise<TState | RemoveUnsetMarker<TPrevState>>;
+  /**
+   * Create an action for React `useActionState`
+   *
+   * @deprecated Use `stateAction` instead.
+   */
+  formAction: <TState, TPrevState = UnsetMarker>(action: (params: Prettify<{
+    ctx: RemoveUnsetMarker<TParams["_context"]>;
     prevState: RemoveUnsetMarker<TPrevState>;
     formData: FormData;
   } & ({
@@ -56,7 +79,7 @@ interface ActionBuilder<TParams extends ActionParams> {
     formErrors?: undefined;
   } | {
     input?: undefined;
-    formErrors: ReturnType<typeof getFormErrors>;
+    formErrors: ReturnType<typeof getInputErrors>;
   })>) => Promise<TState>) => (prevState: TState | RemoveUnsetMarker<TPrevState>, formData: InferInputType<TParams["_input"], "in">) => Promise<TState | RemoveUnsetMarker<TPrevState>>;
 }
 /**

package/dist/index.mjs

@@ -1,12 +1,29 @@
 import { SchemaError, getDotPath } from "@standard-schema/utils";
 
-//#region src/utils.ts
+//#region src/internal/middleware.ts
+/**
+* Executes an array of middleware functions with the given initial context.
+*/
+async function executeMiddlewares(middlewares, initialCtx) {
+	let ctx = initialCtx && typeof initialCtx === "object" ? { ...initialCtx } : {};
+	for (const middleware of middlewares) {
+		const result = await middleware({ ctx });
+		if (result && typeof result === "object") ctx = {
+			...ctx,
+			...result
+		};
+	}
+	return ctx;
+}
+
+//#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 getFormErrors(issues) {
+function getInputErrors(issues) {
 	const messages = [];
 	const fieldErrors = {};
 	for (const issue of issues) {
@@ -23,20 +40,19 @@ function getFormErrors(issues) {
 
 //#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,
+		middleware: [],
 		...initDef
 	};
 	return {
 		middleware: (middleware) => createNewServerActionBuilder({
 			..._def,
-			middleware
+			middleware: [..._def.middleware, middleware]
 		}),
 		input: (input) => createNewServerActionBuilder({
 			..._def,
@@ -44,10 +60,10 @@ function createServerActionBuilder(initDef = {}) {
 		}),
 		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,
@@ -61,16 +77,43 @@ function createServerActionBuilder(initDef = {}) {
 			};
 		},
 		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) => {
-				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,
 						formData,
-						formErrors: getFormErrors(result.issues)
+						formErrors: getInputErrors(result.issues)
 					});
 					return await action({
 						ctx,

package/dist/utils.cjs

@@ -0,0 +1,107 @@
+
+//#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) {
+	return /^\d+$/.test(str);
+}
+function set(obj, path, value) {
+	if (path.length > 1) {
+		const newPath = [...path];
+		const key = newPath.shift();
+		assert(key != null);
+		const nextKey = newPath[0];
+		assert(nextKey != null);
+		if (!obj[key]) obj[key] = isNumberString(nextKey) ? [] : {};
+		else if (Array.isArray(obj[key]) && !isNumberString(nextKey)) obj[key] = Object.fromEntries(Object.entries(obj[key]));
+		set(obj[key], newPath, value);
+		return;
+	}
+	const p = path[0];
+	assert(p != null);
+	if (obj[p] === void 0) obj[p] = value;
+	else if (Array.isArray(obj[p])) obj[p].push(value);
+	else obj[p] = [obj[p], value];
+}
+/**
+* Converts FormData to a structured JavaScript object
+*
+* This function parses FormData entries and converts them into a nested object structure.
+* It supports dot notation, array notation, and mixed nested structures.
+*
+* @param formData - The FormData object to convert
+* @returns A structured object representing the form data
+*
+* @example
+* Basic usage:
+* ```ts
+* const formData = new FormData();
+* formData.append('name', 'John');
+* formData.append('email', 'john@example.com');
+*
+* const result = formDataToObject(formData);
+* // Result: { name: 'John', email: 'john@example.com' }
+* ```
+*
+* @example
+* Nested objects with dot notation:
+* ```ts
+* const formData = new FormData();
+* formData.append('user.name', 'John');
+* formData.append('user.profile.age', '30');
+*
+* const result = formDataToObject(formData);
+* // Result: { user: { name: 'John', profile: { age: '30' } } }
+* ```
+*
+* @example
+* Arrays with bracket notation:
+* ```ts
+* const formData = new FormData();
+* formData.append('items[0]', 'apple');
+* formData.append('items[1]', 'banana');
+*
+* const result = formDataToObject(formData);
+* // Result: { items: ['apple', 'banana'] }
+* ```
+*
+* @example
+* Multiple values for the same key:
+* ```ts
+* const formData = new FormData();
+* formData.append('tags', 'javascript');
+* formData.append('tags', 'typescript');
+*
+* const result = formDataToObject(formData);
+* // Result: { tags: ['javascript', 'typescript'] }
+* ```
+*
+* @example
+* Mixed nested structures:
+* ```ts
+* const formData = new FormData();
+* formData.append('users[0].name', 'John');
+* formData.append('users[0].emails[0]', 'john@work.com');
+* formData.append('users[0].emails[1]', 'john@personal.com');
+*
+* const result = formDataToObject(formData);
+* // Result: {
+* //   users: [{
+* //     name: 'John',
+* //     emails: ['john@work.com', 'john@personal.com']
+* //   }]
+* // }
+* ```
+*/
+function formDataToObject(formData) {
+	const obj = {};
+	for (const [key, value] of formData.entries()) set(obj, key.split(/[.[\]]/).filter(Boolean), value);
+	return obj;
+}
+
+//#endregion
+exports.formDataToObject = formDataToObject;

package/dist/utils.d.cts

@@ -0,0 +1,74 @@
+//#region src/utils.d.ts
+/**
+ * Converts FormData to a structured JavaScript object
+ *
+ * This function parses FormData entries and converts them into a nested object structure.
+ * It supports dot notation, array notation, and mixed nested structures.
+ *
+ * @param formData - The FormData object to convert
+ * @returns A structured object representing the form data
+ *
+ * @example
+ * Basic usage:
+ * ```ts
+ * const formData = new FormData();
+ * formData.append('name', 'John');
+ * formData.append('email', 'john@example.com');
+ *
+ * const result = formDataToObject(formData);
+ * // Result: { name: 'John', email: 'john@example.com' }
+ * ```
+ *
+ * @example
+ * Nested objects with dot notation:
+ * ```ts
+ * const formData = new FormData();
+ * formData.append('user.name', 'John');
+ * formData.append('user.profile.age', '30');
+ *
+ * const result = formDataToObject(formData);
+ * // Result: { user: { name: 'John', profile: { age: '30' } } }
+ * ```
+ *
+ * @example
+ * Arrays with bracket notation:
+ * ```ts
+ * const formData = new FormData();
+ * formData.append('items[0]', 'apple');
+ * formData.append('items[1]', 'banana');
+ *
+ * const result = formDataToObject(formData);
+ * // Result: { items: ['apple', 'banana'] }
+ * ```
+ *
+ * @example
+ * Multiple values for the same key:
+ * ```ts
+ * const formData = new FormData();
+ * formData.append('tags', 'javascript');
+ * formData.append('tags', 'typescript');
+ *
+ * const result = formDataToObject(formData);
+ * // Result: { tags: ['javascript', 'typescript'] }
+ * ```
+ *
+ * @example
+ * Mixed nested structures:
+ * ```ts
+ * const formData = new FormData();
+ * formData.append('users[0].name', 'John');
+ * formData.append('users[0].emails[0]', 'john@work.com');
+ * formData.append('users[0].emails[1]', 'john@personal.com');
+ *
+ * const result = formDataToObject(formData);
+ * // Result: {
+ * //   users: [{
+ * //     name: 'John',
+ * //     emails: ['john@work.com', 'john@personal.com']
+ * //   }]
+ * // }
+ * ```
+ */
+declare function formDataToObject(formData: FormData): Record<string, unknown>;
+//#endregion
+export { formDataToObject };

package/dist/utils.d.mts

@@ -0,0 +1,74 @@
+//#region src/utils.d.ts
+/**
+ * Converts FormData to a structured JavaScript object
+ *
+ * This function parses FormData entries and converts them into a nested object structure.
+ * It supports dot notation, array notation, and mixed nested structures.
+ *
+ * @param formData - The FormData object to convert
+ * @returns A structured object representing the form data
+ *
+ * @example
+ * Basic usage:
+ * ```ts
+ * const formData = new FormData();
+ * formData.append('name', 'John');
+ * formData.append('email', 'john@example.com');
+ *
+ * const result = formDataToObject(formData);
+ * // Result: { name: 'John', email: 'john@example.com' }
+ * ```
+ *
+ * @example
+ * Nested objects with dot notation:
+ * ```ts
+ * const formData = new FormData();
+ * formData.append('user.name', 'John');
+ * formData.append('user.profile.age', '30');
+ *
+ * const result = formDataToObject(formData);
+ * // Result: { user: { name: 'John', profile: { age: '30' } } }
+ * ```
+ *
+ * @example
+ * Arrays with bracket notation:
+ * ```ts
+ * const formData = new FormData();
+ * formData.append('items[0]', 'apple');
+ * formData.append('items[1]', 'banana');
+ *
+ * const result = formDataToObject(formData);
+ * // Result: { items: ['apple', 'banana'] }
+ * ```
+ *
+ * @example
+ * Multiple values for the same key:
+ * ```ts
+ * const formData = new FormData();
+ * formData.append('tags', 'javascript');
+ * formData.append('tags', 'typescript');
+ *
+ * const result = formDataToObject(formData);
+ * // Result: { tags: ['javascript', 'typescript'] }
+ * ```
+ *
+ * @example
+ * Mixed nested structures:
+ * ```ts
+ * const formData = new FormData();
+ * formData.append('users[0].name', 'John');
+ * formData.append('users[0].emails[0]', 'john@work.com');
+ * formData.append('users[0].emails[1]', 'john@personal.com');
+ *
+ * const result = formDataToObject(formData);
+ * // Result: {
+ * //   users: [{
+ * //     name: 'John',
+ * //     emails: ['john@work.com', 'john@personal.com']
+ * //   }]
+ * // }
+ * ```
+ */
+declare function formDataToObject(formData: FormData): Record<string, unknown>;
+//#endregion
+export { formDataToObject };

package/dist/utils.mjs

@@ -0,0 +1,106 @@
+//#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) {
+	return /^\d+$/.test(str);
+}
+function set(obj, path, value) {
+	if (path.length > 1) {
+		const newPath = [...path];
+		const key = newPath.shift();
+		assert(key != null);
+		const nextKey = newPath[0];
+		assert(nextKey != null);
+		if (!obj[key]) obj[key] = isNumberString(nextKey) ? [] : {};
+		else if (Array.isArray(obj[key]) && !isNumberString(nextKey)) obj[key] = Object.fromEntries(Object.entries(obj[key]));
+		set(obj[key], newPath, value);
+		return;
+	}
+	const p = path[0];
+	assert(p != null);
+	if (obj[p] === void 0) obj[p] = value;
+	else if (Array.isArray(obj[p])) obj[p].push(value);
+	else obj[p] = [obj[p], value];
+}
+/**
+* Converts FormData to a structured JavaScript object
+*
+* This function parses FormData entries and converts them into a nested object structure.
+* It supports dot notation, array notation, and mixed nested structures.
+*
+* @param formData - The FormData object to convert
+* @returns A structured object representing the form data
+*
+* @example
+* Basic usage:
+* ```ts
+* const formData = new FormData();
+* formData.append('name', 'John');
+* formData.append('email', 'john@example.com');
+*
+* const result = formDataToObject(formData);
+* // Result: { name: 'John', email: 'john@example.com' }
+* ```
+*
+* @example
+* Nested objects with dot notation:
+* ```ts
+* const formData = new FormData();
+* formData.append('user.name', 'John');
+* formData.append('user.profile.age', '30');
+*
+* const result = formDataToObject(formData);
+* // Result: { user: { name: 'John', profile: { age: '30' } } }
+* ```
+*
+* @example
+* Arrays with bracket notation:
+* ```ts
+* const formData = new FormData();
+* formData.append('items[0]', 'apple');
+* formData.append('items[1]', 'banana');
+*
+* const result = formDataToObject(formData);
+* // Result: { items: ['apple', 'banana'] }
+* ```
+*
+* @example
+* Multiple values for the same key:
+* ```ts
+* const formData = new FormData();
+* formData.append('tags', 'javascript');
+* formData.append('tags', 'typescript');
+*
+* const result = formDataToObject(formData);
+* // Result: { tags: ['javascript', 'typescript'] }
+* ```
+*
+* @example
+* Mixed nested structures:
+* ```ts
+* const formData = new FormData();
+* formData.append('users[0].name', 'John');
+* formData.append('users[0].emails[0]', 'john@work.com');
+* formData.append('users[0].emails[1]', 'john@personal.com');
+*
+* const result = formDataToObject(formData);
+* // Result: {
+* //   users: [{
+* //     name: 'John',
+* //     emails: ['john@work.com', 'john@personal.com']
+* //   }]
+* // }
+* ```
+*/
+function formDataToObject(formData) {
+	const obj = {};
+	for (const [key, value] of formData.entries()) set(obj, key.split(/[.[\]]/).filter(Boolean), value);
+	return obj;
+}
+
+//#endregion
+export { formDataToObject };

package/package.json

@@ -1,48 +1,46 @@
 {
   "name": "server-act",
-  "version": "1.6.0",
+  "version": "1.7.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"
-  },
-  "main": "dist/index.js",
-  "module": "dist/index.mjs",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": {
-        "types": "./dist/index.d.mts",
-        "default": "./dist/index.mjs"
-      },
-      "require": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      }
-    }
-  },
   "files": [
     "dist",
-    "package.json",
     "LICENSE",
+    "package.json",
     "README.md"
   ],
-  "keywords": [
-    "next",
-    "nextjs",
-    "react",
-    "react server component",
-    "react server action",
-    "rsc",
-    "server component",
-    "server action",
-    "action"
-  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./utils": {
+      "types": "./dist/utils.d.ts",
+      "import": "./dist/utils.mjs",
+      "require": "./dist/utils.js"
+    },
+    "./package.json": "./package.json"
+  },
   "dependencies": {
     "@standard-schema/spec": "^1.0.0",
     "@standard-schema/utils": "^0.3.0"

package/dist/index.js

@@ -1,121 +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/utils.ts
-async function standardValidate(schema, input) {
-	let result = schema["~standard"].validate(input);
-	if (result instanceof Promise) result = await result;
-	return result;
-}
-function getFormErrors(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, 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: getFormErrors(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;