use-server-action 1.1.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jack Humphries
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,87 @@
+# use-server-action
+
+A type-safe React hook and utilities for working with Next.js server actions.
+
+## Installation
+
+```bash
+npm install use-server-action
+```
+
+## Quick Start
+
+### 1. Create a server action
+
+```ts
+// app/actions.ts
+"use server";
+
+import { serverAction, success, error } from "use-server-action/server";
+
+export const createUser = serverAction(async (name: string) => {
+    if (!name.trim()) {
+        throw new Error("Name is required");
+    }
+
+    const user = await db.user.create({ data: { name } });
+    return user;
+});
+
+// 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");
+    }
+};
+```
+
+### 2. Use in a client component
+
+```tsx
+"use client";
+
+import { useServerAction } from "use-server-action";
+import { createUser } from "./actions";
+
+export function CreateUserForm() {
+    const {
+        execute,
+        data,
+        error,
+        isPending,
+        isSuccess,
+        isError,
+        reset,
+    } = useServerAction({
+        action: createUser,
+        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)}>
+            <input name="name" placeholder="Name" disabled={isPending} />
+            <button type="submit" disabled={isPending}>
+                {isPending ? "Creating..." : "Create User"}
+            </button>
+            {isError && <p className="error">{error}</p>}
+            {isSuccess && <p className="success">Created: {data?.name}</p>}
+        </form>
+    );
+}
+```
+
+## Documentation
+
+You can view the documentation [here](https://use-server-action.jackh.sh)
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,32 @@
+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';
+
+type UseServerActionInput<P extends unknown[], T> = {
+    action: (...args: P) => Promise<ServerActionResult<T>>;
+    onSuccess?: (data: T) => void;
+    onError?: (message: string, code?: string) => void;
+    onSettled?: () => void;
+};
+type UseServerActionReturn<P extends unknown[], T> = {
+    /** Whether the action is currently executing */
+    isPending: boolean;
+    /** Error message from the last failed execution */
+    error: string | null;
+    /** Error code from the last failed execution */
+    errorCode: string | null;
+    /** Data from the last successful execution */
+    data: T | null;
+    /** Whether the last execution was successful */
+    isSuccess: boolean;
+    /** Whether the last execution was an error */
+    isError: boolean;
+    /** Execute the action (wrapped in React transition) */
+    execute: (...args: P) => void;
+    /** Execute the action and return the result (not wrapped in transition) */
+    executeAsync: (...args: P) => Promise<ServerActionResult<T>>;
+    /** Reset state to initial values */
+    reset: () => void;
+};
+declare function useServerAction<P extends unknown[], T>(input: UseServerActionInput<P, T>): UseServerActionReturn<P, T>;
+
+export { ServerActionResult, type UseServerActionInput, type UseServerActionReturn, useServerAction };

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+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';
+
+type UseServerActionInput<P extends unknown[], T> = {
+    action: (...args: P) => Promise<ServerActionResult<T>>;
+    onSuccess?: (data: T) => void;
+    onError?: (message: string, code?: string) => void;
+    onSettled?: () => void;
+};
+type UseServerActionReturn<P extends unknown[], T> = {
+    /** Whether the action is currently executing */
+    isPending: boolean;
+    /** Error message from the last failed execution */
+    error: string | null;
+    /** Error code from the last failed execution */
+    errorCode: string | null;
+    /** Data from the last successful execution */
+    data: T | null;
+    /** Whether the last execution was successful */
+    isSuccess: boolean;
+    /** Whether the last execution was an error */
+    isError: boolean;
+    /** Execute the action (wrapped in React transition) */
+    execute: (...args: P) => void;
+    /** Execute the action and return the result (not wrapped in transition) */
+    executeAsync: (...args: P) => Promise<ServerActionResult<T>>;
+    /** Reset state to initial values */
+    reset: () => void;
+};
+declare function useServerAction<P extends unknown[], T>(input: UseServerActionInput<P, T>): UseServerActionReturn<P, T>;
+
+export { ServerActionResult, type UseServerActionInput, type UseServerActionReturn, useServerAction };

package/dist/index.js

@@ -0,0 +1,129 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  useServerAction: () => useServerAction
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/use-server-action.ts
+var import_react = require("react");
+function useServerAction(input) {
+  const { action, onSuccess, onError, onSettled } = input;
+  const [isPending, startTransition] = (0, import_react.useTransition)();
+  const [error, setError] = (0, import_react.useState)(null);
+  const [errorCode, setErrorCode] = (0, import_react.useState)(null);
+  const [data, setData] = (0, import_react.useState)(null);
+  const [isSuccess, setIsSuccess] = (0, import_react.useState)(false);
+  const [isError, setIsError] = (0, import_react.useState)(false);
+  const isMountedRef = (0, import_react.useRef)(true);
+  const callbacksRef = (0, import_react.useRef)({ onSuccess, onError, onSettled });
+  callbacksRef.current = { onSuccess, onError, onSettled };
+  (0, import_react.useEffect)(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+    };
+  }, []);
+  const handleResult = (0, import_react.useCallback)((res) => {
+    if (!isMountedRef.current) return;
+    if (res.ok) {
+      setData(res.data);
+      setError(null);
+      setErrorCode(null);
+      setIsSuccess(true);
+      setIsError(false);
+      callbacksRef.current.onSuccess?.(res.data);
+    } else {
+      setError(res.message);
+      setErrorCode(res.code ?? null);
+      setIsSuccess(false);
+      setIsError(true);
+      callbacksRef.current.onError?.(res.message, res.code);
+    }
+    callbacksRef.current.onSettled?.();
+  }, []);
+  const handleException = (0, import_react.useCallback)((err) => {
+    if (!isMountedRef.current) return;
+    const message = err instanceof Error ? err.message : "Unknown error";
+    const code = err instanceof Error ? err.name : "UNKNOWN_ERROR";
+    setError(message);
+    setErrorCode(code);
+    setIsSuccess(false);
+    setIsError(true);
+    callbacksRef.current.onError?.(message, code);
+    callbacksRef.current.onSettled?.();
+  }, []);
+  const execute = (0, import_react.useCallback)(
+    (...params) => {
+      setError(null);
+      setErrorCode(null);
+      setIsSuccess(false);
+      setIsError(false);
+      startTransition(() => {
+        action(...params).then(handleResult).catch(handleException);
+      });
+    },
+    [action, handleResult, handleException]
+  );
+  const executeAsync = (0, import_react.useCallback)(
+    async (...params) => {
+      setError(null);
+      setErrorCode(null);
+      setIsSuccess(false);
+      setIsError(false);
+      try {
+        const res = await action(...params);
+        handleResult(res);
+        return res;
+      } catch (err) {
+        handleException(err);
+        const message = err instanceof Error ? err.message : "Unknown error";
+        const code = err instanceof Error ? err.name : "UNKNOWN_ERROR";
+        return { ok: false, message, code };
+      }
+    },
+    [action, handleResult, handleException]
+  );
+  const reset = (0, import_react.useCallback)(() => {
+    setError(null);
+    setErrorCode(null);
+    setData(null);
+    setIsSuccess(false);
+    setIsError(false);
+  }, []);
+  return {
+    isPending,
+    error,
+    errorCode,
+    data,
+    isSuccess,
+    isError,
+    execute,
+    executeAsync,
+    reset
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useServerAction
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/use-server-action.ts"],"sourcesContent":["export { useServerAction } from \"./use-server-action\";\nexport type {\n    UseServerActionInput,\n    UseServerActionReturn,\n} from \"./use-server-action\";\n\n// Re-export types only from server (safe for client bundles)\nexport type {\n    ServerActionResult,\n    ServerActionSuccess,\n    ServerActionError,\n    ServerActionFn,\n} from \"./server/server-action\";\n","\"use client\";\n\nimport { useCallback, useEffect, useRef, useState, useTransition } from \"react\";\nimport type { ServerActionResult } from \"./server/server-action\";\n\nexport type UseServerActionInput<P extends unknown[], T> = {\n    action: (...args: P) => Promise<ServerActionResult<T>>;\n    onSuccess?: (data: T) => void;\n    onError?: (message: string, code?: string) => void;\n    onSettled?: () => void;\n};\n\nexport type UseServerActionReturn<P extends unknown[], T> = {\n    /** Whether the action is currently executing */\n    isPending: boolean;\n    /** Error message from the last failed execution */\n    error: string | null;\n    /** Error code from the last failed execution */\n    errorCode: string | null;\n    /** Data from the last successful execution */\n    data: T | null;\n    /** Whether the last execution was successful */\n    isSuccess: boolean;\n    /** Whether the last execution was an error */\n    isError: boolean;\n    /** Execute the action (wrapped in React transition) */\n    execute: (...args: P) => void;\n    /** Execute the action and return the result (not wrapped in transition) */\n    executeAsync: (...args: P) => Promise<ServerActionResult<T>>;\n    /** Reset state to initial values */\n    reset: () => void;\n};\n\nexport function useServerAction<P extends unknown[], T>(\n    input: UseServerActionInput<P, T>,\n): UseServerActionReturn<P, T> {\n    const { action, onSuccess, onError, onSettled } = input;\n\n    const [isPending, startTransition] = useTransition();\n    const [error, setError] = useState<string | null>(null);\n    const [errorCode, setErrorCode] = useState<string | null>(null);\n    const [data, setData] = useState<T | null>(null);\n    const [isSuccess, setIsSuccess] = useState(false);\n    const [isError, setIsError] = useState(false);\n\n    // Track if component is mounted to prevent state updates after unmount\n    const isMountedRef = useRef(true);\n\n    // Use ref to always have latest callbacks without causing re-renders\n    const callbacksRef = useRef({ onSuccess, onError, onSettled });\n    callbacksRef.current = { onSuccess, onError, onSettled };\n\n    // Cleanup on unmount\n    useEffect(() => {\n        isMountedRef.current = true;\n        return () => {\n            isMountedRef.current = false;\n        };\n    }, []);\n\n    const handleResult = useCallback((res: ServerActionResult<T>) => {\n        if (!isMountedRef.current) return;\n\n        if (res.ok) {\n            setData(res.data);\n            setError(null);\n            setErrorCode(null);\n            setIsSuccess(true);\n            setIsError(false);\n            callbacksRef.current.onSuccess?.(res.data);\n        } else {\n            setError(res.message);\n            setErrorCode(res.code ?? null);\n            setIsSuccess(false);\n            setIsError(true);\n            callbacksRef.current.onError?.(res.message, res.code);\n        }\n        callbacksRef.current.onSettled?.();\n    }, []);\n\n    const handleException = useCallback((err: unknown) => {\n        if (!isMountedRef.current) return;\n\n        const message = err instanceof Error ? err.message : \"Unknown error\";\n        const code = err instanceof Error ? err.name : \"UNKNOWN_ERROR\";\n        setError(message);\n        setErrorCode(code);\n        setIsSuccess(false);\n        setIsError(true);\n        callbacksRef.current.onError?.(message, code);\n        callbacksRef.current.onSettled?.();\n    }, []);\n\n    const execute = useCallback(\n        (...params: P) => {\n            setError(null);\n            setErrorCode(null);\n            setIsSuccess(false);\n            setIsError(false);\n\n            startTransition(() => {\n                action(...params).then(handleResult).catch(handleException);\n            });\n        },\n        [action, handleResult, handleException],\n    );\n\n    const executeAsync = useCallback(\n        async (...params: P): Promise<ServerActionResult<T>> => {\n            setError(null);\n            setErrorCode(null);\n            setIsSuccess(false);\n            setIsError(false);\n\n            try {\n                const res = await action(...params);\n                handleResult(res);\n                return res;\n            } catch (err) {\n                handleException(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        [action, handleResult, handleException],\n    );\n\n    const reset = useCallback(() => {\n        setError(null);\n        setErrorCode(null);\n        setData(null);\n        setIsSuccess(false);\n        setIsError(false);\n    }, []);\n\n    return {\n        isPending,\n        error,\n        errorCode,\n        data,\n        isSuccess,\n        isError,\n        execute,\n        executeAsync,\n        reset,\n    };\n}\n"],"mappings":"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","names":[]}

package/dist/index.mjs

@@ -0,0 +1,102 @@
+// src/use-server-action.ts
+import { useCallback, useEffect, useRef, useState, useTransition } from "react";
+function useServerAction(input) {
+  const { action, onSuccess, onError, onSettled } = input;
+  const [isPending, startTransition] = useTransition();
+  const [error, setError] = useState(null);
+  const [errorCode, setErrorCode] = useState(null);
+  const [data, setData] = useState(null);
+  const [isSuccess, setIsSuccess] = useState(false);
+  const [isError, setIsError] = useState(false);
+  const isMountedRef = useRef(true);
+  const callbacksRef = useRef({ onSuccess, onError, onSettled });
+  callbacksRef.current = { onSuccess, onError, onSettled };
+  useEffect(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+    };
+  }, []);
+  const handleResult = useCallback((res) => {
+    if (!isMountedRef.current) return;
+    if (res.ok) {
+      setData(res.data);
+      setError(null);
+      setErrorCode(null);
+      setIsSuccess(true);
+      setIsError(false);
+      callbacksRef.current.onSuccess?.(res.data);
+    } else {
+      setError(res.message);
+      setErrorCode(res.code ?? null);
+      setIsSuccess(false);
+      setIsError(true);
+      callbacksRef.current.onError?.(res.message, res.code);
+    }
+    callbacksRef.current.onSettled?.();
+  }, []);
+  const handleException = useCallback((err) => {
+    if (!isMountedRef.current) return;
+    const message = err instanceof Error ? err.message : "Unknown error";
+    const code = err instanceof Error ? err.name : "UNKNOWN_ERROR";
+    setError(message);
+    setErrorCode(code);
+    setIsSuccess(false);
+    setIsError(true);
+    callbacksRef.current.onError?.(message, code);
+    callbacksRef.current.onSettled?.();
+  }, []);
+  const execute = useCallback(
+    (...params) => {
+      setError(null);
+      setErrorCode(null);
+      setIsSuccess(false);
+      setIsError(false);
+      startTransition(() => {
+        action(...params).then(handleResult).catch(handleException);
+      });
+    },
+    [action, handleResult, handleException]
+  );
+  const executeAsync = useCallback(
+    async (...params) => {
+      setError(null);
+      setErrorCode(null);
+      setIsSuccess(false);
+      setIsError(false);
+      try {
+        const res = await action(...params);
+        handleResult(res);
+        return res;
+      } catch (err) {
+        handleException(err);
+        const message = err instanceof Error ? err.message : "Unknown error";
+        const code = err instanceof Error ? err.name : "UNKNOWN_ERROR";
+        return { ok: false, message, code };
+      }
+    },
+    [action, handleResult, handleException]
+  );
+  const reset = useCallback(() => {
+    setError(null);
+    setErrorCode(null);
+    setData(null);
+    setIsSuccess(false);
+    setIsError(false);
+  }, []);
+  return {
+    isPending,
+    error,
+    errorCode,
+    data,
+    isSuccess,
+    isError,
+    execute,
+    executeAsync,
+    reset
+  };
+}
+export {
+  useServerAction
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/use-server-action.ts"],"sourcesContent":["\"use client\";\n\nimport { useCallback, useEffect, useRef, useState, useTransition } from \"react\";\nimport type { ServerActionResult } from \"./server/server-action\";\n\nexport type UseServerActionInput<P extends unknown[], T> = {\n    action: (...args: P) => Promise<ServerActionResult<T>>;\n    onSuccess?: (data: T) => void;\n    onError?: (message: string, code?: string) => void;\n    onSettled?: () => void;\n};\n\nexport type UseServerActionReturn<P extends unknown[], T> = {\n    /** Whether the action is currently executing */\n    isPending: boolean;\n    /** Error message from the last failed execution */\n    error: string | null;\n    /** Error code from the last failed execution */\n    errorCode: string | null;\n    /** Data from the last successful execution */\n    data: T | null;\n    /** Whether the last execution was successful */\n    isSuccess: boolean;\n    /** Whether the last execution was an error */\n    isError: boolean;\n    /** Execute the action (wrapped in React transition) */\n    execute: (...args: P) => void;\n    /** Execute the action and return the result (not wrapped in transition) */\n    executeAsync: (...args: P) => Promise<ServerActionResult<T>>;\n    /** Reset state to initial values */\n    reset: () => void;\n};\n\nexport function useServerAction<P extends unknown[], T>(\n    input: UseServerActionInput<P, T>,\n): UseServerActionReturn<P, T> {\n    const { action, onSuccess, onError, onSettled } = input;\n\n    const [isPending, startTransition] = useTransition();\n    const [error, setError] = useState<string | null>(null);\n    const [errorCode, setErrorCode] = useState<string | null>(null);\n    const [data, setData] = useState<T | null>(null);\n    const [isSuccess, setIsSuccess] = useState(false);\n    const [isError, setIsError] = useState(false);\n\n    // Track if component is mounted to prevent state updates after unmount\n    const isMountedRef = useRef(true);\n\n    // Use ref to always have latest callbacks without causing re-renders\n    const callbacksRef = useRef({ onSuccess, onError, onSettled });\n    callbacksRef.current = { onSuccess, onError, onSettled };\n\n    // Cleanup on unmount\n    useEffect(() => {\n        isMountedRef.current = true;\n        return () => {\n            isMountedRef.current = false;\n        };\n    }, []);\n\n    const handleResult = useCallback((res: ServerActionResult<T>) => {\n        if (!isMountedRef.current) return;\n\n        if (res.ok) {\n            setData(res.data);\n            setError(null);\n            setErrorCode(null);\n            setIsSuccess(true);\n            setIsError(false);\n            callbacksRef.current.onSuccess?.(res.data);\n        } else {\n            setError(res.message);\n            setErrorCode(res.code ?? null);\n            setIsSuccess(false);\n            setIsError(true);\n            callbacksRef.current.onError?.(res.message, res.code);\n        }\n        callbacksRef.current.onSettled?.();\n    }, []);\n\n    const handleException = useCallback((err: unknown) => {\n        if (!isMountedRef.current) return;\n\n        const message = err instanceof Error ? err.message : \"Unknown error\";\n        const code = err instanceof Error ? err.name : \"UNKNOWN_ERROR\";\n        setError(message);\n        setErrorCode(code);\n        setIsSuccess(false);\n        setIsError(true);\n        callbacksRef.current.onError?.(message, code);\n        callbacksRef.current.onSettled?.();\n    }, []);\n\n    const execute = useCallback(\n        (...params: P) => {\n            setError(null);\n            setErrorCode(null);\n            setIsSuccess(false);\n            setIsError(false);\n\n            startTransition(() => {\n                action(...params).then(handleResult).catch(handleException);\n            });\n        },\n        [action, handleResult, handleException],\n    );\n\n    const executeAsync = useCallback(\n        async (...params: P): Promise<ServerActionResult<T>> => {\n            setError(null);\n            setErrorCode(null);\n            setIsSuccess(false);\n            setIsError(false);\n\n            try {\n                const res = await action(...params);\n                handleResult(res);\n                return res;\n            } catch (err) {\n                handleException(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        [action, handleResult, handleException],\n    );\n\n    const reset = useCallback(() => {\n        setError(null);\n        setErrorCode(null);\n        setData(null);\n        setIsSuccess(false);\n        setIsError(false);\n    }, []);\n\n    return {\n        isPending,\n        error,\n        errorCode,\n        data,\n        isSuccess,\n        isError,\n        execute,\n        executeAsync,\n        reset,\n    };\n}\n"],"mappings":"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","names":[]}

package/dist/server-action-HthxxP-Y.d.mts

@@ -0,0 +1,39 @@
+type ServerActionSuccess<T> = {
+    ok: true;
+    data: T;
+};
+type ServerActionError = {
+    ok: false;
+    message: string;
+    code?: string;
+};
+type ServerActionResult<T> = ServerActionSuccess<T> | ServerActionError;
+declare function success<T>(data: T): ServerActionSuccess<T>;
+declare function error(message: string, code?: string): ServerActionError;
+type ServerActionFn<P extends unknown[], T> = (...args: P) => Promise<ServerActionResult<T>>;
+type ServerActionOptions = {
+    onError?: (error: unknown) => void;
+};
+/**
+ * Wraps an async function to return a standardized ServerActionResult.
+ * Catches any thrown errors and converts them to error results.
+ */
+declare function serverAction<P extends unknown[], T>(fn: (...args: P) => Promise<T>, options?: ServerActionOptions): ServerActionFn<P, T>;
+/**
+ * Type guard to check if a result is successful
+ */
+declare function isSuccess<T>(result: ServerActionResult<T>): result is ServerActionSuccess<T>;
+/**
+ * Type guard to check if a result is an error
+ */
+declare function isError<T>(result: ServerActionResult<T>): result is ServerActionError;
+/**
+ * Unwraps a successful result or throws the error message
+ */
+declare function unwrap<T>(result: ServerActionResult<T>): T;
+/**
+ * Unwraps a successful result or returns a default value
+ */
+declare function unwrapOr<T>(result: ServerActionResult<T>, defaultValue: T): T;
+
+export { type ServerActionResult as S, type ServerActionSuccess as a, type ServerActionError as b, type ServerActionFn as c, success as d, error as e, isError as f, unwrapOr as g, isSuccess as i, serverAction as s, unwrap as u };

package/dist/server-action-HthxxP-Y.d.ts

@@ -0,0 +1,39 @@
+type ServerActionSuccess<T> = {
+    ok: true;
+    data: T;
+};
+type ServerActionError = {
+    ok: false;
+    message: string;
+    code?: string;
+};
+type ServerActionResult<T> = ServerActionSuccess<T> | ServerActionError;
+declare function success<T>(data: T): ServerActionSuccess<T>;
+declare function error(message: string, code?: string): ServerActionError;
+type ServerActionFn<P extends unknown[], T> = (...args: P) => Promise<ServerActionResult<T>>;
+type ServerActionOptions = {
+    onError?: (error: unknown) => void;
+};
+/**
+ * Wraps an async function to return a standardized ServerActionResult.
+ * Catches any thrown errors and converts them to error results.
+ */
+declare function serverAction<P extends unknown[], T>(fn: (...args: P) => Promise<T>, options?: ServerActionOptions): ServerActionFn<P, T>;
+/**
+ * Type guard to check if a result is successful
+ */
+declare function isSuccess<T>(result: ServerActionResult<T>): result is ServerActionSuccess<T>;
+/**
+ * Type guard to check if a result is an error
+ */
+declare function isError<T>(result: ServerActionResult<T>): result is ServerActionError;
+/**
+ * Unwraps a successful result or throws the error message
+ */
+declare function unwrap<T>(result: ServerActionResult<T>): T;
+/**
+ * Unwraps a successful result or returns a default value
+ */
+declare function unwrapOr<T>(result: ServerActionResult<T>, defaultValue: T): T;
+
+export { type ServerActionResult as S, type ServerActionSuccess as a, type ServerActionError as b, type ServerActionFn as c, success as d, error as e, isError as f, unwrapOr as g, isSuccess as i, serverAction as s, unwrap as u };

package/dist/server.d.mts

@@ -0,0 +1,107 @@
+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';
+
+/**
+ * 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>>;
+/**
+ * Creates a type-safe middleware function.
+ *
+ * @example
+ * ```ts
+ * const withLogging = createMiddleware(async (next, ...params) => {
+ *     console.log("Calling action with:", params);
+ *     const result = await next(...params);
+ *     console.log("Result:", result);
+ *     return result;
+ * });
+ * ```
+ */
+declare function createMiddleware<P extends unknown[], T>(handler: Middleware<P, T>): Middleware<P, T>;
+/**
+ * Applies middleware to a server action.
+ * Middleware is executed in order (first middleware wraps second, etc).
+ *
+ * @example
+ * ```ts
+ * const protectedAction = applyMiddleware(
+ *     myServerAction,
+ *     [withAuth, withLogging, withValidation]
+ * );
+ * ```
+ */
+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.
+ *
+ * @example
+ * ```ts
+ * const combined = composeMiddleware(withAuth, withLogging, withValidation);
+ * const protectedAction = applyMiddleware(myAction, [combined]);
+ * ```
+ */
+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.
+ *
+ * @example
+ * ```ts
+ * import { z } from "zod";
+ * import { withValidation, applyMiddleware } from "use-server-action/server";
+ *
+ * const CreateUserSchema = z.object({
+ *     name: z.string().min(1),
+ *     email: z.string().email(),
+ * });
+ *
+ * const createUser = applyMiddleware(
+ *     serverAction(async (input: z.infer<typeof CreateUserSchema>) => {
+ *         return await db.user.create({ data: input });
+ *     }),
+ *     [withValidation(CreateUserSchema)]
+ * );
+ * ```
+ */
+declare function withValidation<TInput, T>(schema: ValidationSchema<TInput>, options?: WithValidationOptions): Middleware<[TInput], T>;
+/**
+ * Creates a middleware that logs action calls and results.
+ */
+declare function withLogging<P extends unknown[], T>(logger?: {
+    onCall?: (params: P) => void;
+    onSuccess?: (data: T, params: P) => void;
+    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 };

package/dist/server.d.ts

@@ -0,0 +1,107 @@
+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';
+
+/**
+ * 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>>;
+/**
+ * Creates a type-safe middleware function.
+ *
+ * @example
+ * ```ts
+ * const withLogging = createMiddleware(async (next, ...params) => {
+ *     console.log("Calling action with:", params);
+ *     const result = await next(...params);
+ *     console.log("Result:", result);
+ *     return result;
+ * });
+ * ```
+ */
+declare function createMiddleware<P extends unknown[], T>(handler: Middleware<P, T>): Middleware<P, T>;
+/**
+ * Applies middleware to a server action.
+ * Middleware is executed in order (first middleware wraps second, etc).
+ *
+ * @example
+ * ```ts
+ * const protectedAction = applyMiddleware(
+ *     myServerAction,
+ *     [withAuth, withLogging, withValidation]
+ * );
+ * ```
+ */
+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.
+ *
+ * @example
+ * ```ts
+ * const combined = composeMiddleware(withAuth, withLogging, withValidation);
+ * const protectedAction = applyMiddleware(myAction, [combined]);
+ * ```
+ */
+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.
+ *
+ * @example
+ * ```ts
+ * import { z } from "zod";
+ * import { withValidation, applyMiddleware } from "use-server-action/server";
+ *
+ * const CreateUserSchema = z.object({
+ *     name: z.string().min(1),
+ *     email: z.string().email(),
+ * });
+ *
+ * const createUser = applyMiddleware(
+ *     serverAction(async (input: z.infer<typeof CreateUserSchema>) => {
+ *         return await db.user.create({ data: input });
+ *     }),
+ *     [withValidation(CreateUserSchema)]
+ * );
+ * ```
+ */
+declare function withValidation<TInput, T>(schema: ValidationSchema<TInput>, options?: WithValidationOptions): Middleware<[TInput], T>;
+/**
+ * Creates a middleware that logs action calls and results.
+ */
+declare function withLogging<P extends unknown[], T>(logger?: {
+    onCall?: (params: P) => void;
+    onSuccess?: (data: T, params: P) => void;
+    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 };

package/dist/server.js

@@ -0,0 +1,135 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/server/index.ts
+var server_exports = {};
+__export(server_exports, {
+  applyMiddleware: () => applyMiddleware,
+  composeMiddleware: () => composeMiddleware,
+  createMiddleware: () => createMiddleware,
+  error: () => error,
+  isError: () => isError,
+  isSuccess: () => isSuccess,
+  serverAction: () => serverAction,
+  success: () => success,
+  unwrap: () => unwrap,
+  unwrapOr: () => unwrapOr,
+  withLogging: () => withLogging,
+  withValidation: () => withValidation
+});
+module.exports = __toCommonJS(server_exports);
+
+// src/server/server-action.ts
+function success(data) {
+  return { ok: true, data };
+}
+function error(message, code) {
+  return { ok: false, message, code };
+}
+function serverAction(fn, options) {
+  return async (...args) => {
+    try {
+      const data = await fn(...args);
+      return success(data);
+    } catch (err) {
+      options?.onError?.(err);
+      if (err instanceof Error) {
+        return error(err.message, err.name);
+      }
+      return error("An unexpected error occurred", "UNKNOWN_ERROR");
+    }
+  };
+}
+function isSuccess(result) {
+  return result.ok === true;
+}
+function isError(result) {
+  return result.ok === false;
+}
+function unwrap(result) {
+  if (result.ok) {
+    return result.data;
+  }
+  throw new Error(result.message);
+}
+function unwrapOr(result, defaultValue) {
+  if (result.ok) {
+    return result.data;
+  }
+  return defaultValue;
+}
+
+// src/server/middleware.ts
+function createMiddleware(handler) {
+  return handler;
+}
+function applyMiddleware(action, middleware) {
+  return middleware.reduceRight(
+    (next, mw) => (...params) => mw(next, ...params),
+    action
+  );
+}
+function composeMiddleware(...middleware) {
+  return (next, ...params) => {
+    const chain = middleware.reduceRight(
+      (nextFn, mw) => (...p) => mw(nextFn, ...p),
+      next
+    );
+    return chain(...params);
+  };
+}
+function withValidation(schema, options = {}) {
+  const { code = "VALIDATION_ERROR", formatError } = options;
+  return async (next, input) => {
+    const result = schema.safeParse(input);
+    if (!result.success) {
+      const message = formatError ? formatError(result.error) : result.error.errors?.[0]?.message ?? result.error.message ?? "Validation failed";
+      return { ok: false, message, code };
+    }
+    return next(result.data);
+  };
+}
+function withLogging(logger = {}) {
+  return async (next, ...params) => {
+    logger.onCall?.(params);
+    const result = await next(...params);
+    if (result.ok) {
+      logger.onSuccess?.(result.data, params);
+    } else {
+      logger.onError?.(result.message, result.code, params);
+    }
+    return result;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyMiddleware,
+  composeMiddleware,
+  createMiddleware,
+  error,
+  isError,
+  isSuccess,
+  serverAction,
+  success,
+  unwrap,
+  unwrapOr,
+  withLogging,
+  withValidation
+});
+//# sourceMappingURL=server.js.map

package/dist/server.js.map

@@ -0,0 +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":[]}

package/dist/server.mjs

@@ -0,0 +1,97 @@
+// src/server/server-action.ts
+function success(data) {
+  return { ok: true, data };
+}
+function error(message, code) {
+  return { ok: false, message, code };
+}
+function serverAction(fn, options) {
+  return async (...args) => {
+    try {
+      const data = await fn(...args);
+      return success(data);
+    } catch (err) {
+      options?.onError?.(err);
+      if (err instanceof Error) {
+        return error(err.message, err.name);
+      }
+      return error("An unexpected error occurred", "UNKNOWN_ERROR");
+    }
+  };
+}
+function isSuccess(result) {
+  return result.ok === true;
+}
+function isError(result) {
+  return result.ok === false;
+}
+function unwrap(result) {
+  if (result.ok) {
+    return result.data;
+  }
+  throw new Error(result.message);
+}
+function unwrapOr(result, defaultValue) {
+  if (result.ok) {
+    return result.data;
+  }
+  return defaultValue;
+}
+
+// src/server/middleware.ts
+function createMiddleware(handler) {
+  return handler;
+}
+function applyMiddleware(action, middleware) {
+  return middleware.reduceRight(
+    (next, mw) => (...params) => mw(next, ...params),
+    action
+  );
+}
+function composeMiddleware(...middleware) {
+  return (next, ...params) => {
+    const chain = middleware.reduceRight(
+      (nextFn, mw) => (...p) => mw(nextFn, ...p),
+      next
+    );
+    return chain(...params);
+  };
+}
+function withValidation(schema, options = {}) {
+  const { code = "VALIDATION_ERROR", formatError } = options;
+  return async (next, input) => {
+    const result = schema.safeParse(input);
+    if (!result.success) {
+      const message = formatError ? formatError(result.error) : result.error.errors?.[0]?.message ?? result.error.message ?? "Validation failed";
+      return { ok: false, message, code };
+    }
+    return next(result.data);
+  };
+}
+function withLogging(logger = {}) {
+  return async (next, ...params) => {
+    logger.onCall?.(params);
+    const result = await next(...params);
+    if (result.ok) {
+      logger.onSuccess?.(result.data, params);
+    } else {
+      logger.onError?.(result.message, result.code, params);
+    }
+    return result;
+  };
+}
+export {
+  applyMiddleware,
+  composeMiddleware,
+  createMiddleware,
+  error,
+  isError,
+  isSuccess,
+  serverAction,
+  success,
+  unwrap,
+  unwrapOr,
+  withLogging,
+  withValidation
+};
+//# sourceMappingURL=server.mjs.map

package/dist/server.mjs.map

@@ -0,0 +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":[]}

package/package.json

@@ -0,0 +1,73 @@
+{
+    "name": "use-server-action",
+    "version": "1.1.3",
+    "description": "A React hook for working with Next.js server actions",
+    "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"
+            }
+        },
+        "./server": {
+            "import": {
+                "types": "./dist/server.d.mts",
+                "default": "./dist/server.mjs"
+            },
+            "require": {
+                "types": "./dist/server.d.ts",
+                "default": "./dist/server.js"
+            }
+        }
+    },
+    "files": [
+        "dist",
+        "package.json",
+        "README.md",
+        "LICENSE"
+    ],
+    "scripts": {
+        "build": "tsup",
+        "dev": "tsup --watch",
+        "lint": "eslint src/",
+        "typecheck": "tsc --noEmit",
+        "test": "vitest run",
+        "test:watch": "vitest",
+        "prepublishOnly": "npm run build"
+    },
+    "keywords": [
+        "react",
+        "nextjs",
+        "server-actions",
+        "hook",
+        "typescript"
+    ],
+    "author": "Jack Humphries <jack@jackh.sh>",
+    "license": "MIT",
+    "peerDependencies": {
+        "react": ">=18.0.0",
+        "zod": ">=3.0.0"
+    },
+    "peerDependenciesMeta": {
+        "zod": {
+            "optional": true
+        }
+    },
+    "devDependencies": {
+        "@testing-library/react": "^16.3.1",
+        "@types/react": "^19.2.7",
+        "jsdom": "^27.3.0",
+        "react": "^19.2.0",
+        "react-dom": "^19.2.3",
+        "tsup": "^8.5.1",
+        "typescript": "^5.9.3",
+        "vitest": "^4.0.16"
+    }
+}