next-action-plus 0.0.0

package/README.md

@@ -0,0 +1,285 @@
+# next-action-plus
+
+![next-action-plus logo](https://raw.githubusercontent.com/muhgholy/next-action-plus/main/assets/next-action-plus.svg)
+
+**next-action-plus** is a tiny TypeScript library for **type-safe Next.js Server Actions**.
+
+You write a server action like you always do. You optionally add a schema. You get:
+
+- Input validation (Zod compatible, but schema-agnostic)
+- Correct `parsedInput` type inference
+- A native-feeling API: `.schema(...).action(async (...) => ...)`
+
+No framework lock-in. No new mental model.
+
+## Table of contents
+
+- [Why next-action-plus](#why-next-action-plus)
+- [Install](#install)
+- [Quick start](#quick-start)
+- [Error handling](#error-handling)
+- [Examples](#examples)
+     - [Next.js Server Action](#nextjs-server-action)
+     - [Client Component usage](#client-component-usage)
+          - [FormData + File uploads](#formdata--file-uploads)
+          - [Middleware (ctx)](#middleware-ctx)
+          - [Schema-agnostic validation](#schema-agnostic-validation)
+- [FAQ](#faq)
+- [Release](#release)
+
+## Why next-action-plus
+
+Next.js Server Actions are great because they are simple: a function that runs on the server.
+But when you accept user input, you usually need:
+
+- validation
+- safe parsing
+- accurate types in the handler
+
+next-action-plus keeps the **server action function shape** and adds **type-safe input parsing**.
+You can treat your action like a normal function, and you still get strict TypeScript inference.
+
+## Install
+
+```bash
+npm i next-action-plus
+```
+
+If you want Zod schemas, also install:
+
+```bash
+npm i zod
+```
+
+## Quick start
+
+```ts
+import { createSafeActionClient } from 'next-action-plus';
+import { z } from 'zod';
+
+export const sayHello = createSafeActionClient()
+	.schema(z.object({ name: z.string().min(1) }))
+	.action(async ({ parsedInput }) => {
+		return { message: `Hello ${parsedInput.name}` };
+	});
+```
+
+### What you get
+
+- `sayHello` is still “just a function” you can call.
+- `parsedInput` is inferred from your schema.
+- The return type is inferred from your handler.
+
+## Error handling
+
+If schema validation fails, the action **throws** an `Error`.
+
+The error message is intentionally short and looks like:
+
+```txt
+Input (name) is error: String must contain at least 1 character(s)
+```
+
+Notes:
+
+- Only the **first** validation issue is used to build the message.
+- The thrown error is a `SafeActionValidationError` (extends `Error`) with a developer-friendly payload.
+- The original validator error is preserved on `error.cause`.
+- Normalized issues are available on `error.issues`.
+
+```ts
+try {
+	await sayHello({ name: '' });
+} catch (error) {
+	// error.message => "Input (name) is error: ..."
+	// (error as SafeActionValidationError).code   => "VALIDATION_ERROR"
+	// (error as SafeActionValidationError).issues => [{ path, message, raw }]
+	// (error as any).cause => original validator error (e.g. ZodError)
+}
+```
+
+### Customizing errors (options)
+
+`createSafeActionClient` accepts options to control logging and customize thrown errors.
+
+```ts
+import { createSafeActionClient } from 'next-action-plus';
+
+export const client = createSafeActionClient({
+	logger: false,
+	formatValidationError: ({ message, issues, error }) => {
+		const e = new Error(message);
+		(e as any).issues = issues;
+		(e as any).cause = error;
+		return e;
+	},
+	onError: ({ phase, error }) => {
+		// report errors (Sentry, etc)
+		// phase: "validation" | "middleware" | "handler"
+		void error;
+	},
+});
+```
+
+## Examples
+
+### Next.js Server Action
+
+This keeps the native Server Action feel.
+
+```ts
+import 'server-only';
+import { createSafeActionClient } from 'next-action-plus';
+import { z } from 'zod';
+
+export const updateProfile = createSafeActionClient()
+	.schema(z.object({ displayName: z.string().min(2) }))
+	.action(async ({ parsedInput }) => {
+		// parsedInput.displayName is string
+		return { ok: true };
+	});
+```
+
+More: [examples/nextjs-server-action.ts](https://github.com/muhgholy/next-action-plus/blob/main/examples/nextjs-server-action.ts)
+
+### Client Component usage
+
+You can import a Server Action into a Client Component and call it like a normal async function.
+Next.js runs it on the server.
+
+```tsx
+'use client';
+
+import { useState, useTransition } from 'react';
+import { sayHello } from '@/app/actions';
+
+export function SayHelloClient() {
+	const [name, setName] = useState('');
+	const [message, setMessage] = useState<string | null>(null);
+	const [pending, startTransition] = useTransition();
+
+	return (
+		<div>
+			<input value={name} onChange={e => setName(e.target.value)} placeholder='Ada' />
+			<button
+				disabled={pending}
+				onClick={() =>
+					startTransition(async () => {
+						const result = await sayHello({ name });
+						setMessage(result.message);
+					})
+				}
+			>
+				{pending ? 'Sending…' : 'Say hello'}
+			</button>
+			{message ? <p>{message}</p> : null}
+		</div>
+	);
+}
+```
+
+More:
+
+- [examples/nextjs-server-action-for-client.ts](https://github.com/muhgholy/next-action-plus/blob/main/examples/nextjs-server-action-for-client.ts)
+- [examples/nextjs-client-component.tsx](https://github.com/muhgholy/next-action-plus/blob/main/examples/nextjs-client-component.tsx)
+
+### FormData + File uploads
+
+Works with `FormData` and `File` using `zod-form-data`.
+
+If you chain multiple schemas and the input is a `FormData`, next-action-plus will first try to find a schema that can parse the `FormData` into a plain object, then validate the remaining schemas against that object.
+
+```ts
+import { createSafeActionClient } from 'next-action-plus';
+import { zfd } from 'zod-form-data';
+
+export const uploadAvatar = createSafeActionClient()
+	.schema(
+		zfd.formData({
+			avatar: zfd.file(),
+		}),
+	)
+	.action(async ({ parsedInput }) => {
+		// parsedInput.avatar is File
+		return { filename: parsedInput.avatar.name };
+	});
+```
+
+### Middleware (ctx)
+
+Add data to context in a type-safe way.
+
+Validation runs first, then middleware runs, then your handler runs.
+
+```ts
+import { createSafeActionClient } from 'next-action-plus';
+import { z } from 'zod';
+
+const client = createSafeActionClient().use(async ({ next }) => next({ ctx: { userId: 'u_123' } }));
+
+export const deletePost = client.schema(z.object({ postId: z.string() })).action(async ({ parsedInput, ctx }) => {
+	// ctx.userId is string
+	// parsedInput.postId is string
+	return { ok: true };
+});
+```
+
+### Schema-agnostic validation
+
+You are not forced into one validator.
+
+Supported schema shapes:
+
+- Zod (`parse` / `parseAsync`)
+- Generic `{ parse(...) }` and `{ parseAsync(...) }`
+- Standard Schema v1 (`~standard.validate`)
+
+If you already have a schema system, you can plug it in.
+
+#### Schema chaining
+
+You can chain multiple schemas. If they return objects, outputs are merged.
+
+```ts
+import { createSafeActionClient } from 'next-action-plus';
+
+const s1 = { parse: (_: unknown) => ({ a: 'a' }) };
+const s2 = { parse: (_: unknown) => ({ b: 2 }) };
+
+export const demo = createSafeActionClient()
+	.schema(s1)
+	.schema(s2)
+	.action(async ({ parsedInput }) => {
+		// parsedInput is { a: string; b: number }
+		return parsedInput;
+	});
+```
+
+## FAQ
+
+### Is next-action-plus only for Next.js?
+
+No. It is built for the Server Actions style, but it runs in any Node 20+ runtime.
+
+### Do I need to learn a new pattern?
+
+No. The API is intentionally small: `createSafeActionClient() → .schema() → .use() → .action()`.
+
+### Can I validate `FormData`?
+
+Yes. Use `zod-form-data` (see [FormData + File uploads](#formdata--file-uploads)).
+
+### Does it change my return types?
+
+No. The returned action function keeps the exact return type of your handler.
+
+### Can I chain multiple schemas?
+
+Yes. Multiple schemas can validate the same base input. If they produce objects, outputs are merged.
+
+## Release
+
+This repository ships with `semantic-release`.
+
+- Push Conventional Commits to `main`
+- GitHub Actions runs `npm test`, `npm run build`, then publishes

package/dist/index.d.ts

@@ -0,0 +1,214 @@
+import { z } from 'zod';
+
+type TMiddlewareFn<Ctx extends Record<string, unknown> = Record<string, never>, NextCtx extends Record<string, unknown> = Record<string, never>> = (opts: {
+    input: unknown;
+    ctx: Readonly<Ctx>;
+    next: {
+        <NC extends Record<string, unknown> = Record<string, never>>(opts?: {
+            ctx?: NC;
+        }): Promise<Ctx & NC>;
+    };
+}) => Promise<Ctx & NextCtx>;
+
+type TIsAny<T> = 0 extends 1 & T ? true : false;
+/**
+ * Makes a type disappear if it relies on a missing optional dependency.
+ *
+ * In practice this is used with `zod` as a peer dependency.
+ */
+type TIfInstalled<T> = TIsAny<T> extends true ? never : T;
+type TPrettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type TUnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+
+type TSafeActionIssuePathSegment = string | number;
+type TSafeActionIssue = {
+    path: TSafeActionIssuePathSegment[];
+    message: string;
+    raw?: unknown;
+};
+type TSafeActionErrorCode = 'VALIDATION_ERROR' | 'MIDDLEWARE_ERROR' | 'HANDLER_ERROR' | 'ACTION_ERROR';
+type TSafeActionErrorPhase = 'validation' | 'middleware' | 'handler';
+type TSafeActionUnknownErrorContext = {
+    phase: TSafeActionErrorPhase;
+    error: unknown;
+    input?: unknown;
+    parsedInput?: unknown;
+    ctx?: Record<string, unknown>;
+};
+type TSafeActionValidationErrorContext = TSafeActionUnknownErrorContext & {
+    message: string;
+    issues: TSafeActionIssue[];
+};
+type TSafeActionErrorContext = TSafeActionUnknownErrorContext | TSafeActionValidationErrorContext;
+type TSafeActionClientOptions = {
+    /**
+     * Control logging when an action throws.
+     * - `false` disables logging.
+     * - Defaults to `console`.
+     */
+    logger?: false | {
+        error: (...args: unknown[]) => void;
+    };
+    /**
+     * Hook called whenever an action throws (validation, middleware, or handler).
+     */
+    onError?: (ctx: TSafeActionErrorContext) => void;
+    /**
+     * Customize the thrown error when validation fails.
+     * The returned Error will be thrown.
+     */
+    formatValidationError?: (ctx: TSafeActionValidationErrorContext) => Error;
+    /**
+     * Customize the thrown error for non-validation failures.
+     * If omitted, the original error is re-thrown.
+     */
+    formatError?: (ctx: TSafeActionUnknownErrorContext) => Error;
+    /**
+     * When enabled, include `input`, `parsedInput`, and `ctx` in error details.
+     * Off by default because it can accidentally expose sensitive data.
+     */
+    includeInputInErrorDetails?: boolean;
+};
+declare class SafeActionError extends Error {
+    code: TSafeActionErrorCode;
+    phase?: TSafeActionErrorPhase;
+    data?: unknown;
+    cause?: unknown;
+    constructor(message: string, opts?: {
+        code: TSafeActionErrorCode;
+        phase?: TSafeActionErrorPhase;
+        cause?: unknown;
+        data?: unknown;
+    });
+}
+declare class SafeActionValidationError extends SafeActionError {
+    issues: TSafeActionIssue[];
+    constructor(message: string, opts: {
+        issues: TSafeActionIssue[];
+        phase?: TSafeActionErrorPhase;
+        cause?: unknown;
+        data?: unknown;
+    });
+}
+declare const isSafeActionError: (error: unknown) => error is SafeActionError;
+declare const isSafeActionValidationError: (error: unknown) => error is SafeActionValidationError;
+
+type TGenericSchema = {
+    parse: (input: unknown) => unknown;
+    safeParse?: (input: unknown) => {
+        success: boolean;
+        data?: unknown;
+        error?: unknown;
+    };
+};
+type TGenericSchemaAsync = {
+    parseAsync: (input: unknown) => Promise<unknown>;
+    safeParseAsync?: (input: unknown) => Promise<{
+        success: boolean;
+        data?: unknown;
+        error?: unknown;
+    }>;
+};
+
+type TStandardSchemaV1<Input = unknown, Output = Input> = {
+    readonly '~standard': {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: unknown) => TStandardSchemaV1Result<Output> | Promise<TStandardSchemaV1Result<Output>>;
+        readonly types?: {
+            readonly input: Input;
+            readonly output: Output;
+        } | undefined;
+    };
+};
+type TStandardSchemaV1PathSegment = {
+    readonly key: PropertyKey;
+};
+type TStandardSchemaV1Issue = {
+    readonly message: string;
+    readonly path?: ReadonlyArray<PropertyKey | TStandardSchemaV1PathSegment> | undefined;
+};
+type TStandardSchemaV1Result<Output> = {
+    readonly value: Output;
+    readonly issues?: undefined;
+} | {
+    readonly issues: ReadonlyArray<TStandardSchemaV1Issue>;
+    readonly value?: undefined;
+};
+type TStandardSchemaV1InferInput<S extends TStandardSchemaV1<any, any>> = S extends TStandardSchemaV1<infer Input, any> ? Input : unknown;
+type TStandardSchemaV1InferOutput<S extends TStandardSchemaV1<any, any>> = S extends TStandardSchemaV1<any, infer Output> ? Output : unknown;
+
+/**
+ * Helper type for `zod-form-data` (and similar) schemas.
+ *
+ * `zod-form-data`'s `zfd.formData(...)` wraps an object schema in a `z.preprocess`,
+ * so the resulting schema is a `ZodEffects` whose input includes `FormData`.
+ */
+type TZodFormDataSchemaFactory = {
+    <T extends z.ZodRawShape>(shape: T): z.ZodEffects<z.ZodObject<T>, z.output<z.ZodObject<T>>, FormData | z.input<z.ZodObject<T>>>;
+    <T extends z.ZodTypeAny>(schema: T): z.ZodEffects<T, z.output<T>, FormData | z.input<T>>;
+};
+type TZodAcceptsFormData<S extends z.ZodTypeAny> = S extends z.ZodEffects<z.ZodTypeAny, unknown, infer I> ? (FormData extends I ? true : false) : false;
+type TZodFormDataInput<S extends z.ZodTypeAny> = TZodAcceptsFormData<S> extends true ? FormData | z.input<S> : z.input<S>;
+
+declare const schemaAvailable: readonly ["zod", "generic", "genericAsync", "standard"];
+type TSchemaAvailable = (typeof schemaAvailable)[number];
+type TSchema = TIfInstalled<z.ZodTypeAny> | TIfInstalled<TGenericSchema> | TIfInstalled<TGenericSchemaAsync> | TStandardSchemaV1<any, any>;
+type TInfer<S extends TSchema> = S extends TIfInstalled<z.ZodTypeAny> ? z.infer<S> : S extends TIfInstalled<TGenericSchema> ? ReturnType<S['parse']> : S extends TIfInstalled<TGenericSchemaAsync> ? Awaited<ReturnType<S['parseAsync']>> : S extends TStandardSchemaV1<any, any> ? TStandardSchemaV1InferOutput<S> : never;
+type TInferIn<S extends TSchema> = S extends TIfInstalled<z.ZodTypeAny> ? z.input<S> : S extends TIfInstalled<TGenericSchema> ? Parameters<S['parse']>[0] : S extends TIfInstalled<TGenericSchemaAsync> ? Parameters<S['parseAsync']>[0] : S extends TStandardSchemaV1<any, any> ? TStandardSchemaV1InferInput<S> : never;
+type TInferArray<S extends readonly TSchema[]> = S extends readonly [infer First extends TSchema, ...infer Rest extends TSchema[]] ? [TInfer<First>, ...TInferArray<Rest>] : [];
+type TInferInArray<S extends readonly TSchema[]> = S extends readonly [infer First extends TSchema, ...infer Rest extends TSchema[]] ? [TInferIn<First>, ...TInferInArray<Rest>] : [];
+type TIsFormData<S extends TSchema> = S extends z.ZodTypeAny ? TZodAcceptsFormData<S> : S extends TStandardSchemaV1<infer Input, any> ? (FormData extends Input ? true : false) : false;
+type TFormDataInput<S extends TSchema> = S extends z.ZodTypeAny ? TZodFormDataInput<S> : S extends TStandardSchemaV1<infer Input, any> ? (FormData extends Input ? FormData | TInferIn<S> : TInferIn<S>) : TInferIn<S>;
+type TFormDataCompatibleInput<S extends readonly TSchema[]> = S extends readonly [infer First extends TSchema, ...infer Rest extends TSchema[]] ? (TIsFormData<First> extends true ? FormData : never) | TPrettify<TUnionToIntersection<TInferIn<First>>> | (Rest['length'] extends 0 ? never : TFormDataCompatibleInput<Rest>) : Record<string, never>;
+
+/**
+ * Class that handles safe server actions with validation
+ */
+declare class SafeActionClient<Schemas extends TSchema[] = [], Ctx extends Record<string, unknown> = Record<string, never>, Middlewares extends readonly TMiddlewareFn<any, any>[] = []> {
+    private schemas;
+    private middlewares;
+    private ctx;
+    private options;
+    constructor(options?: {
+        schemas?: Schemas;
+        middlewares?: Middlewares;
+        ctx?: Ctx;
+        options?: TSafeActionClientOptions;
+    });
+    /**
+     * Adds a validation schema
+     * @param schema Validation schema
+     */
+    schema<S extends TSchema>(schema: S): SafeActionClient<[...Schemas, S], Ctx, Middlewares>;
+    /**
+     * Adds a middleware function
+     * @param middleware Middleware function
+     */
+    use<NextCtx extends Record<string, unknown>>(middleware: TMiddlewareFn<Ctx, NextCtx>): SafeActionClient<Schemas, Ctx & NextCtx, [...Middlewares, TMiddlewareFn<Ctx, NextCtx>]>;
+    /**
+     * Creates an action with validation and middleware
+     * @param handler Action handler function
+     */
+    action<Output>(handler: (props: {
+        parsedInput: Schemas extends (infer S extends TSchema)[] ? TPrettify<TUnionToIntersection<TInfer<S>>> : Record<string, never>;
+        ctx: TPrettify<Ctx>;
+    }) => Promise<Output>): (input?: Schemas extends [infer S extends TSchema] ? TFormDataInput<S> : Schemas extends (infer _S extends TSchema)[] ? TFormDataCompatibleInput<Schemas> : unknown) => Promise<Output>;
+    private normalizeIssuePath;
+    private normalizeIssues;
+    private formatValidationErrorParts;
+    private validateInput;
+    private isPlainObject;
+    private parseSchema;
+    private tryParseSchema;
+    private runMiddlewareChain;
+    private isValidationError;
+}
+/**
+ * Creates a safe action client that handles validation and execution of server actions
+ */
+declare const createSafeActionClient: (options?: TSafeActionClientOptions) => SafeActionClient<[], Record<string, never>, []>;
+
+export { SafeActionClient, SafeActionError, SafeActionValidationError, type TFormDataCompatibleInput, type TFormDataInput, type TGenericSchema, type TGenericSchemaAsync, type TIfInstalled, type TInfer, type TInferArray, type TInferIn, type TInferInArray, type TIsAny, type TIsFormData, type TMiddlewareFn, type TPrettify, type TSafeActionClientOptions, type TSafeActionErrorCode, type TSafeActionErrorContext, type TSafeActionErrorPhase, type TSafeActionIssue, type TSafeActionIssuePathSegment, type TSafeActionUnknownErrorContext, type TSafeActionValidationErrorContext, type TSchema, type TSchemaAvailable, type TStandardSchemaV1, type TStandardSchemaV1InferInput, type TStandardSchemaV1InferOutput, type TStandardSchemaV1Issue, type TStandardSchemaV1PathSegment, type TStandardSchemaV1Result, type TUnionToIntersection, type TZodAcceptsFormData, type TZodFormDataInput, type TZodFormDataSchemaFactory, createSafeActionClient, isSafeActionError, isSafeActionValidationError, schemaAvailable };

package/dist/index.js

@@ -0,0 +1,289 @@
+// src/types/errors.ts
+var SafeActionError = class extends Error {
+  code;
+  phase;
+  data;
+  constructor(message, opts = { code: "ACTION_ERROR" }) {
+    super(message, { cause: opts.cause });
+    this.name = "SafeActionError";
+    this.code = opts.code;
+    this.phase = opts.phase;
+    this.data = opts.data;
+    this.cause = opts.cause;
+  }
+};
+var SafeActionValidationError = class extends SafeActionError {
+  issues;
+  constructor(message, opts) {
+    super(message, { code: "VALIDATION_ERROR", phase: opts.phase, cause: opts.cause, data: opts.data });
+    this.name = "SafeActionValidationError";
+    this.issues = opts.issues;
+  }
+};
+var isSafeActionError = (error) => {
+  if (typeof error !== "object" || error === null) return false;
+  if (!("code" in error)) return false;
+  const name = error.name;
+  return name === "SafeActionError" || name === "SafeActionValidationError";
+};
+var isSafeActionValidationError = (error) => {
+  return typeof error === "object" && error !== null && "issues" in error && error.name === "SafeActionValidationError";
+};
+
+// src/types/schema/index.ts
+var schemaAvailable = ["zod", "generic", "genericAsync", "standard"];
+
+// src/index.ts
+var SafeActionClient = class _SafeActionClient {
+  schemas;
+  middlewares;
+  ctx;
+  options;
+  constructor(options = {}) {
+    this.schemas = options.schemas || [];
+    this.middlewares = options.middlewares || [];
+    this.ctx = options.ctx || {};
+    this.options = options.options ?? {};
+  }
+  /**
+   * Adds a validation schema
+   * @param schema Validation schema
+   */
+  schema(schema) {
+    return new _SafeActionClient({
+      schemas: [...this.schemas, schema],
+      middlewares: this.middlewares,
+      ctx: this.ctx,
+      options: this.options
+    });
+  }
+  /**
+   * Adds a middleware function
+   * @param middleware Middleware function
+   */
+  use(middleware) {
+    return new _SafeActionClient({
+      schemas: this.schemas,
+      middlewares: [...this.middlewares, middleware],
+      ctx: this.ctx,
+      options: this.options
+    });
+  }
+  /**
+   * Creates an action with validation and middleware
+   * @param handler Action handler function
+   */
+  action(handler) {
+    return async (input) => {
+      let phase = "validation";
+      let parsedInputForErrors = void 0;
+      let ctxForErrors = void 0;
+      try {
+        phase = "validation";
+        const parsedInput = await this.validateInput(input);
+        parsedInputForErrors = parsedInput;
+        phase = "middleware";
+        const ctx = await this.runMiddlewareChain(parsedInput);
+        ctxForErrors = ctx;
+        phase = "handler";
+        return await handler({ parsedInput, ctx });
+      } catch (error) {
+        const logger = this.options.logger === void 0 ? console : this.options.logger;
+        if (logger !== false) {
+          logger.error("Action error:", error);
+        }
+        const includeInput = this.options.includeInputInErrorDetails === true;
+        const baseContext = {
+          phase,
+          error,
+          input: includeInput ? input : void 0,
+          parsedInput: includeInput ? parsedInputForErrors : void 0,
+          ctx: includeInput ? ctxForErrors : void 0
+        };
+        if (this.isValidationError(error)) {
+          const { message, issues } = this.formatValidationErrorParts(error);
+          const validationContext = { ...baseContext, message, issues };
+          this.options.onError?.(validationContext);
+          const formatted = this.options.formatValidationError?.(validationContext) ?? new SafeActionValidationError(message, {
+            issues,
+            phase,
+            cause: error,
+            data: includeInput ? { input, parsedInput: parsedInputForErrors, ctx: ctxForErrors } : void 0
+          });
+          throw formatted;
+        }
+        this.options.onError?.(baseContext);
+        const maybeFormatted = this.options.formatError?.(baseContext);
+        if (maybeFormatted) throw maybeFormatted;
+        throw error;
+      }
+    };
+  }
+  normalizeIssuePath(path) {
+    if (!Array.isArray(path)) return [];
+    return path.map((seg) => {
+      if (typeof seg === "string" || typeof seg === "number") return seg;
+      if (typeof seg === "object" && seg !== null && "key" in seg) {
+        const key = seg.key;
+        if (typeof key === "string" || typeof key === "number") return key;
+        return String(key);
+      }
+      return String(seg);
+    });
+  }
+  normalizeIssues(error) {
+    if (typeof error !== "object" || error === null) return [];
+    const maybe = error;
+    const rawIssues = maybe.errors ?? maybe.issues ?? [];
+    return rawIssues.map((issue) => ({
+      path: this.normalizeIssuePath(issue.path),
+      message: typeof issue.message === "string" ? issue.message : String(issue.message ?? ""),
+      raw: issue
+    }));
+  }
+  formatValidationErrorParts(error) {
+    const issues = this.normalizeIssues(error);
+    const first = issues[0];
+    if (!first) {
+      return { message: `Validation error: ${String(error)}`, issues: [] };
+    }
+    const fieldPath = first.path.length ? first.path.join(".") : "unknown";
+    const message = first.message || String(error);
+    return { message: `Input (${fieldPath}) is error: ${message}`, issues };
+  }
+  async validateInput(input) {
+    if (!this.schemas.length) return input;
+    const schemasToRun = [...this.schemas];
+    let baseInput = input;
+    if (input instanceof FormData) {
+      for (let i = 0; i < schemasToRun.length; i++) {
+        const candidate = schemasToRun[i];
+        const parsed = await this.tryParseSchema(candidate, input);
+        if (!parsed.ok) continue;
+        schemasToRun.splice(i, 1);
+        baseInput = parsed.value;
+        break;
+      }
+    }
+    if (schemasToRun.length === 0) {
+      return baseInput;
+    }
+    if (schemasToRun.length === 1) {
+      return await this.parseSchema(schemasToRun[0], baseInput);
+    }
+    let mergedObject;
+    let lastNonObject = void 0;
+    for (const schema of schemasToRun) {
+      const parsed = await this.parseSchema(schema, baseInput);
+      if (this.isPlainObject(parsed)) {
+        mergedObject = { ...mergedObject ?? {}, ...parsed };
+      } else {
+        lastNonObject = parsed;
+      }
+    }
+    return mergedObject ?? lastNonObject;
+  }
+  isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
+  }
+  async parseSchema(schema, input) {
+    if (schema && typeof schema === "object") {
+      const maybeAsync = schema.parseAsync;
+      if (typeof maybeAsync === "function") {
+        return await schema.parseAsync(input);
+      }
+      const maybeSync = schema.parse;
+      if (typeof maybeSync === "function") {
+        return schema.parse(input);
+      }
+      const maybeStandard = schema["~standard"];
+      if (maybeStandard && typeof maybeStandard === "object") {
+        const validate = maybeStandard.validate;
+        if (typeof validate === "function") {
+          const result = await validate(input);
+          if (result && typeof result === "object" && "issues" in result) {
+            const err = new Error("Validation error");
+            err.issues = result.issues;
+            throw err;
+          }
+          if (result && typeof result === "object" && "value" in result) {
+            return result.value;
+          }
+        }
+      }
+    }
+    throw new Error("Unsupported schema type");
+  }
+  async tryParseSchema(schema, input) {
+    try {
+      if (schema && typeof schema === "object") {
+        const safeAsync = schema.safeParseAsync;
+        if (typeof safeAsync === "function") {
+          const res = await schema.safeParseAsync(input);
+          return res.success ? { ok: true, value: res.data } : { ok: false };
+        }
+        const safeSync = schema.safeParse;
+        if (typeof safeSync === "function") {
+          const res = schema.safeParse(input);
+          return res.success ? { ok: true, value: res.data } : { ok: false };
+        }
+        const maybeStandard = schema["~standard"];
+        if (maybeStandard && typeof maybeStandard === "object") {
+          const validate = maybeStandard.validate;
+          if (typeof validate === "function") {
+            const result = await validate(input);
+            if (result && typeof result === "object" && "issues" in result) return { ok: false };
+            if (result && typeof result === "object" && "value" in result) return { ok: true, value: result.value };
+          }
+        }
+      }
+      return { ok: true, value: await this.parseSchema(schema, input) };
+    } catch {
+      return { ok: false };
+    }
+  }
+  async runMiddlewareChain(input) {
+    let ctx = { ...this.ctx };
+    let currentIndex = 0;
+    const middlewares = this.middlewares;
+    const runNext = async (options) => {
+      if (options?.ctx) {
+        ctx = { ...ctx, ...options.ctx };
+      }
+      if (currentIndex < middlewares.length) {
+        const middleware = middlewares[currentIndex];
+        currentIndex++;
+        return await middleware({
+          input,
+          ctx: Object.freeze({ ...ctx }),
+          next: runNext
+        });
+      }
+      return ctx;
+    };
+    return await runNext();
+  }
+  isValidationError(error) {
+    if (typeof error !== "object" || error === null) return false;
+    if ("name" in error) {
+      const errName = error.name;
+      if (errName === "ZodError" || errName.includes("ValidationError")) {
+        return true;
+      }
+    }
+    return "errors" in error || "issues" in error;
+  }
+};
+var createSafeActionClient = (options) => {
+  return new SafeActionClient({ options });
+};
+export {
+  SafeActionClient,
+  SafeActionError,
+  SafeActionValidationError,
+  createSafeActionClient,
+  isSafeActionError,
+  isSafeActionValidationError,
+  schemaAvailable
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types/errors.ts","../src/types/schema/index.ts","../src/index.ts"],"sourcesContent":["export type TSafeActionIssuePathSegment = string | number;\r\n\r\nexport type TSafeActionIssue = {\r\n\tpath: TSafeActionIssuePathSegment[];\r\n\tmessage: string;\r\n\traw?: unknown;\r\n};\r\n\r\nexport type TSafeActionErrorCode = 'VALIDATION_ERROR' | 'MIDDLEWARE_ERROR' | 'HANDLER_ERROR' | 'ACTION_ERROR';\r\n\r\nexport type TSafeActionErrorPhase = 'validation' | 'middleware' | 'handler';\r\n\r\nexport type TSafeActionUnknownErrorContext = {\r\n\tphase: TSafeActionErrorPhase;\r\n\terror: unknown;\r\n\tinput?: unknown;\r\n\tparsedInput?: unknown;\r\n\tctx?: Record<string, unknown>;\r\n};\r\n\r\nexport type TSafeActionValidationErrorContext = TSafeActionUnknownErrorContext & {\r\n\tmessage: string;\r\n\tissues: TSafeActionIssue[];\r\n};\r\n\r\nexport type TSafeActionErrorContext = TSafeActionUnknownErrorContext | TSafeActionValidationErrorContext;\r\n\r\nexport type TSafeActionClientOptions = {\r\n\t/**\r\n\t * Control logging when an action throws.\r\n\t * - `false` disables logging.\r\n\t * - Defaults to `console`.\r\n\t */\r\n\tlogger?: false | { error: (...args: unknown[]) => void };\r\n\r\n\t/**\r\n\t * Hook called whenever an action throws (validation, middleware, or handler).\r\n\t */\r\n\tonError?: (ctx: TSafeActionErrorContext) => void;\r\n\r\n\t/**\r\n\t * Customize the thrown error when validation fails.\r\n\t * The returned Error will be thrown.\r\n\t */\r\n\tformatValidationError?: (ctx: TSafeActionValidationErrorContext) => Error;\r\n\r\n\t/**\r\n\t * Customize the thrown error for non-validation failures.\r\n\t * If omitted, the original error is re-thrown.\r\n\t */\r\n\tformatError?: (ctx: TSafeActionUnknownErrorContext) => Error;\r\n\r\n\t/**\r\n\t * When enabled, include `input`, `parsedInput`, and `ctx` in error details.\r\n\t * Off by default because it can accidentally expose sensitive data.\r\n\t */\r\n\tincludeInputInErrorDetails?: boolean;\r\n};\r\n\r\nexport class SafeActionError extends Error {\r\n\tcode: TSafeActionErrorCode;\r\n\tphase?: TSafeActionErrorPhase;\r\n\tdata?: unknown;\r\n\tdeclare cause?: unknown;\r\n\r\n\tconstructor(\r\n\t\tmessage: string,\r\n\t\topts: {\r\n\t\t\tcode: TSafeActionErrorCode;\r\n\t\t\tphase?: TSafeActionErrorPhase;\r\n\t\t\tcause?: unknown;\r\n\t\t\tdata?: unknown;\r\n\t\t} = { code: 'ACTION_ERROR' },\r\n\t) {\r\n\t\tsuper(message, { cause: opts.cause });\r\n\t\tthis.name = 'SafeActionError';\r\n\t\tthis.code = opts.code;\r\n\t\tthis.phase = opts.phase;\r\n\t\tthis.data = opts.data;\r\n\t\tthis.cause = opts.cause;\r\n\t}\r\n}\r\n\r\nexport class SafeActionValidationError extends SafeActionError {\r\n\tissues: TSafeActionIssue[];\r\n\r\n\tconstructor(\r\n\t\tmessage: string,\r\n\t\topts: {\r\n\t\t\tissues: TSafeActionIssue[];\r\n\t\t\tphase?: TSafeActionErrorPhase;\r\n\t\t\tcause?: unknown;\r\n\t\t\tdata?: unknown;\r\n\t\t},\r\n\t) {\r\n\t\tsuper(message, { code: 'VALIDATION_ERROR', phase: opts.phase, cause: opts.cause, data: opts.data });\r\n\t\tthis.name = 'SafeActionValidationError';\r\n\t\tthis.issues = opts.issues;\r\n\t}\r\n}\r\n\r\nexport const isSafeActionError = (error: unknown): error is SafeActionError => {\r\n\tif (typeof error !== 'object' || error === null) return false;\r\n\tif (!('code' in error)) return false;\r\n\tconst name = (error as { name?: unknown }).name;\r\n\treturn name === 'SafeActionError' || name === 'SafeActionValidationError';\r\n};\r\n\r\nexport const isSafeActionValidationError = (error: unknown): error is SafeActionValidationError => {\r\n\treturn typeof error === 'object' && error !== null && 'issues' in error && (error as { name?: unknown }).name === 'SafeActionValidationError';\r\n};\r\n","import type { z } from 'zod';\r\n\r\nimport type { TIfInstalled, TPrettify, TUnionToIntersection } from '../utils';\r\nimport type { TGenericSchema, TGenericSchemaAsync } from './generic';\r\nimport type { TStandardSchemaV1, TStandardSchemaV1InferInput, TStandardSchemaV1InferOutput } from './standard';\r\nimport type { TZodAcceptsFormData, TZodFormDataInput } from './zod';\r\n\r\nexport const schemaAvailable = ['zod', 'generic', 'genericAsync', 'standard'] as const;\r\nexport type TSchemaAvailable = (typeof schemaAvailable)[number];\r\n\r\nexport type TSchema = TIfInstalled<z.ZodTypeAny> | TIfInstalled<TGenericSchema> | TIfInstalled<TGenericSchemaAsync> | TStandardSchemaV1<any, any>;\r\n\r\nexport type TInfer<S extends TSchema> = S extends TIfInstalled<z.ZodTypeAny> ? z.infer<S> : S extends TIfInstalled<TGenericSchema> ? ReturnType<S['parse']> : S extends TIfInstalled<TGenericSchemaAsync> ? Awaited<ReturnType<S['parseAsync']>> : S extends TStandardSchemaV1<any, any> ? TStandardSchemaV1InferOutput<S> : never;\r\n\r\nexport type TInferIn<S extends TSchema> = S extends TIfInstalled<z.ZodTypeAny> ? z.input<S> : S extends TIfInstalled<TGenericSchema> ? Parameters<S['parse']>[0] : S extends TIfInstalled<TGenericSchemaAsync> ? Parameters<S['parseAsync']>[0] : S extends TStandardSchemaV1<any, any> ? TStandardSchemaV1InferInput<S> : never;\r\n\r\nexport type TInferArray<S extends readonly TSchema[]> = S extends readonly [infer First extends TSchema, ...infer Rest extends TSchema[]] ? [TInfer<First>, ...TInferArray<Rest>] : [];\r\n\r\nexport type TInferInArray<S extends readonly TSchema[]> = S extends readonly [infer First extends TSchema, ...infer Rest extends TSchema[]] ? [TInferIn<First>, ...TInferInArray<Rest>] : [];\r\n\r\nexport type TIsFormData<S extends TSchema> = S extends z.ZodTypeAny ? TZodAcceptsFormData<S> : S extends TStandardSchemaV1<infer Input, any> ? (FormData extends Input ? true : false) : false;\r\n\r\nexport type TFormDataInput<S extends TSchema> = S extends z.ZodTypeAny ? TZodFormDataInput<S> : S extends TStandardSchemaV1<infer Input, any> ? (FormData extends Input ? FormData | TInferIn<S> : TInferIn<S>) : TInferIn<S>;\r\n\r\nexport type TFormDataCompatibleInput<S extends readonly TSchema[]> = S extends readonly [infer First extends TSchema, ...infer Rest extends TSchema[]] ? (TIsFormData<First> extends true ? FormData : never) | TPrettify<TUnionToIntersection<TInferIn<First>>> | (Rest['length'] extends 0 ? never : TFormDataCompatibleInput<Rest>) : Record<string, never>;\r\n","import type { TSafeActionClientOptions, TSafeActionErrorPhase, TSafeActionIssue, TFormDataCompatibleInput, TFormDataInput, TInfer, TPrettify, TSchema, TMiddlewareFn, TUnionToIntersection } from './types';\r\nimport { SafeActionValidationError } from './types';\r\n\r\nexport { schemaAvailable } from './types';\r\nexport { SafeActionError, SafeActionValidationError, isSafeActionError, isSafeActionValidationError } from './types';\r\nexport type * from './types';\r\n\r\n/**\r\n * Class that handles safe server actions with validation\r\n */\r\nexport class SafeActionClient<Schemas extends TSchema[] = [], Ctx extends Record<string, unknown> = Record<string, never>, Middlewares extends readonly TMiddlewareFn<any, any>[] = []> {\r\n\tprivate schemas: Schemas;\r\n\tprivate middlewares: Middlewares;\r\n\tprivate ctx: Ctx;\r\n\tprivate options: TSafeActionClientOptions;\r\n\r\n\tconstructor(\r\n\t\toptions: {\r\n\t\t\tschemas?: Schemas;\r\n\t\t\tmiddlewares?: Middlewares;\r\n\t\t\tctx?: Ctx;\r\n\t\t\toptions?: TSafeActionClientOptions;\r\n\t\t} = {},\r\n\t) {\r\n\t\tthis.schemas = (options.schemas || []) as unknown as Schemas;\r\n\t\tthis.middlewares = (options.middlewares || []) as unknown as Middlewares;\r\n\t\tthis.ctx = (options.ctx || {}) as Ctx;\r\n\t\tthis.options = options.options ?? {};\r\n\t}\r\n\r\n\t/**\r\n\t * Adds a validation schema\r\n\t * @param schema Validation schema\r\n\t */\r\n\tschema<S extends TSchema>(schema: S): SafeActionClient<[...Schemas, S], Ctx, Middlewares> {\r\n\t\treturn new SafeActionClient({\r\n\t\t\tschemas: [...this.schemas, schema] as unknown as [...Schemas, S],\r\n\t\t\tmiddlewares: this.middlewares,\r\n\t\t\tctx: this.ctx,\r\n\t\t\toptions: this.options,\r\n\t\t});\r\n\t}\r\n\r\n\t/**\r\n\t * Adds a middleware function\r\n\t * @param middleware Middleware function\r\n\t */\r\n\tuse<NextCtx extends Record<string, unknown>>(middleware: TMiddlewareFn<Ctx, NextCtx>): SafeActionClient<Schemas, Ctx & NextCtx, [...Middlewares, TMiddlewareFn<Ctx, NextCtx>]> {\r\n\t\treturn new SafeActionClient({\r\n\t\t\tschemas: this.schemas,\r\n\t\t\tmiddlewares: [...this.middlewares, middleware] as unknown as [...Middlewares, TMiddlewareFn<Ctx, NextCtx>],\r\n\t\t\tctx: this.ctx as unknown as Ctx & NextCtx,\r\n\t\t\toptions: this.options,\r\n\t\t});\r\n\t}\r\n\r\n\t/**\r\n\t * Creates an action with validation and middleware\r\n\t * @param handler Action handler function\r\n\t */\r\n\taction<Output>(handler: (props: { parsedInput: Schemas extends (infer S extends TSchema)[] ? TPrettify<TUnionToIntersection<TInfer<S>>> : Record<string, never>; ctx: TPrettify<Ctx> }) => Promise<Output>): (input?: Schemas extends [infer S extends TSchema] ? TFormDataInput<S> : Schemas extends (infer _S extends TSchema)[] ? TFormDataCompatibleInput<Schemas> : unknown) => Promise<Output> {\r\n\t\treturn async (input?: unknown): Promise<Output> => {\r\n\t\t\tlet phase: TSafeActionErrorPhase = 'validation';\r\n\t\t\tlet parsedInputForErrors: unknown = undefined;\r\n\t\t\tlet ctxForErrors: unknown = undefined;\r\n\r\n\t\t\ttry {\r\n\t\t\t\t// Validate input against all schemas\r\n\t\t\t\ttype ParsedInput = Schemas extends (infer S extends TSchema)[] ? TPrettify<TUnionToIntersection<TInfer<S>>> : Record<string, never>;\r\n\t\t\t\tphase = 'validation';\r\n\t\t\t\tconst parsedInput = (await this.validateInput(input)) as ParsedInput;\r\n\t\t\t\tparsedInputForErrors = parsedInput;\r\n\r\n\t\t\t\t// Run middleware chain\r\n\t\t\t\tphase = 'middleware';\r\n\t\t\t\tconst ctx = await this.runMiddlewareChain(parsedInput);\r\n\t\t\t\tctxForErrors = ctx;\r\n\r\n\t\t\t\t// Execute handler\r\n\t\t\t\tphase = 'handler';\r\n\t\t\t\treturn await handler({ parsedInput, ctx });\r\n\t\t\t} catch (error: unknown) {\r\n\t\t\t\tconst logger = this.options.logger === undefined ? console : this.options.logger;\r\n\t\t\t\tif (logger !== false) {\r\n\t\t\t\t\tlogger.error('Action error:', error);\r\n\t\t\t\t}\r\n\r\n\t\t\t\tconst includeInput = this.options.includeInputInErrorDetails === true;\r\n\t\t\t\tconst baseContext = {\r\n\t\t\t\t\tphase,\r\n\t\t\t\t\terror,\r\n\t\t\t\t\tinput: includeInput ? input : undefined,\r\n\t\t\t\t\tparsedInput: includeInput ? parsedInputForErrors : undefined,\r\n\t\t\t\t\tctx: includeInput ? (ctxForErrors as Record<string, unknown> | undefined) : undefined,\r\n\t\t\t\t};\r\n\r\n\t\t\t\t// Handle validation errors\r\n\t\t\t\tif (this.isValidationError(error)) {\r\n\t\t\t\t\tconst { message, issues } = this.formatValidationErrorParts(error);\r\n\t\t\t\t\tconst validationContext = { ...baseContext, message, issues };\r\n\t\t\t\t\tthis.options.onError?.(validationContext);\r\n\r\n\t\t\t\t\tconst formatted =\r\n\t\t\t\t\t\tthis.options.formatValidationError?.(validationContext) ??\r\n\t\t\t\t\t\tnew SafeActionValidationError(message, {\r\n\t\t\t\t\t\t\tissues,\r\n\t\t\t\t\t\t\tphase,\r\n\t\t\t\t\t\t\tcause: error,\r\n\t\t\t\t\t\t\tdata: includeInput ? { input, parsedInput: parsedInputForErrors, ctx: ctxForErrors } : undefined,\r\n\t\t\t\t\t\t});\r\n\r\n\t\t\t\t\tthrow formatted;\r\n\t\t\t\t}\r\n\r\n\t\t\t\tthis.options.onError?.(baseContext);\r\n\t\t\t\tconst maybeFormatted = this.options.formatError?.(baseContext);\r\n\t\t\t\tif (maybeFormatted) throw maybeFormatted;\r\n\r\n\t\t\t\tthrow error;\r\n\t\t\t}\r\n\t\t};\r\n\t}\r\n\r\n\tprivate normalizeIssuePath(path: unknown): Array<string | number> {\r\n\t\tif (!Array.isArray(path)) return [];\r\n\t\treturn path.map(seg => {\r\n\t\t\tif (typeof seg === 'string' || typeof seg === 'number') return seg;\r\n\t\t\tif (typeof seg === 'object' && seg !== null && 'key' in (seg as Record<string, unknown>)) {\r\n\t\t\t\tconst key = (seg as { key: unknown }).key;\r\n\t\t\t\tif (typeof key === 'string' || typeof key === 'number') return key;\r\n\t\t\t\treturn String(key);\r\n\t\t\t}\r\n\t\t\treturn String(seg);\r\n\t\t});\r\n\t}\r\n\r\n\tprivate normalizeIssues(error: unknown): TSafeActionIssue[] {\r\n\t\tif (typeof error !== 'object' || error === null) return [];\r\n\r\n\t\tconst maybe = error as {\r\n\t\t\terrors?: Array<{ path?: unknown; message?: unknown }>;\r\n\t\t\tissues?: Array<{ path?: unknown; message?: unknown }>;\r\n\t\t};\r\n\r\n\t\tconst rawIssues = (maybe.errors ?? maybe.issues ?? []) as Array<{ path?: unknown; message?: unknown }>;\r\n\t\treturn rawIssues.map(issue => ({\r\n\t\t\tpath: this.normalizeIssuePath(issue.path),\r\n\t\t\tmessage: typeof issue.message === 'string' ? issue.message : String(issue.message ?? ''),\r\n\t\t\traw: issue,\r\n\t\t}));\r\n\t}\r\n\r\n\tprivate formatValidationErrorParts(error: unknown): { message: string; issues: TSafeActionIssue[] } {\r\n\t\tconst issues = this.normalizeIssues(error);\r\n\t\tconst first = issues[0];\r\n\t\tif (!first) {\r\n\t\t\treturn { message: `Validation error: ${String(error)}`, issues: [] };\r\n\t\t}\r\n\r\n\t\tconst fieldPath = first.path.length ? first.path.join('.') : 'unknown';\r\n\t\tconst message = first.message || String(error);\r\n\t\treturn { message: `Input (${fieldPath}) is error: ${message}`, issues };\r\n\t}\r\n\r\n\tprivate async validateInput(input: unknown): Promise<unknown> {\r\n\t\tif (!this.schemas.length) return input;\r\n\r\n\t\t// zod-form-data uses `z.preprocess` and accepts FormData/URLSearchParams at runtime.\r\n\t\t// If the incoming input is FormData, try to find a single schema that can parse it into a\r\n\t\t// regular object first (regardless of ordering). Then validate *all* remaining schemas\r\n\t\t// against the same base input so schemas can validate different slices reliably.\r\n\t\tconst schemasToRun = [...this.schemas];\r\n\t\tlet baseInput: unknown = input;\r\n\r\n\t\tif (input instanceof FormData) {\r\n\t\t\tfor (let i = 0; i < schemasToRun.length; i++) {\r\n\t\t\t\tconst candidate = schemasToRun[i];\r\n\t\t\t\tconst parsed = await this.tryParseSchema(candidate, input);\r\n\t\t\t\tif (!parsed.ok) continue;\r\n\r\n\t\t\t\tschemasToRun.splice(i, 1);\r\n\t\t\t\tbaseInput = parsed.value;\r\n\r\n\t\t\t\tbreak;\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t// If a FormData schema consumed the input and there are no schemas left,\r\n\t\t// the parsed base input is the validated result.\r\n\t\tif (schemasToRun.length === 0) {\r\n\t\t\treturn baseInput;\r\n\t\t}\r\n\r\n\t\t// Single schema: return parsed value directly.\r\n\t\tif (schemasToRun.length === 1) {\r\n\t\t\treturn await this.parseSchema(schemasToRun[0] as TSchema, baseInput);\r\n\t\t}\r\n\r\n\t\tlet mergedObject: Record<string, unknown> | undefined;\r\n\t\tlet lastNonObject: unknown = undefined;\r\n\r\n\t\tfor (const schema of schemasToRun) {\r\n\t\t\tconst parsed = await this.parseSchema(schema, baseInput);\r\n\t\t\tif (this.isPlainObject(parsed)) {\r\n\t\t\t\tmergedObject = { ...(mergedObject ?? {}), ...(parsed as Record<string, unknown>) };\r\n\t\t\t} else {\r\n\t\t\t\tlastNonObject = parsed;\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\treturn mergedObject ?? lastNonObject;\r\n\t}\r\n\r\n\tprivate isPlainObject(value: unknown): value is Record<string, unknown> {\r\n\t\treturn typeof value === 'object' && value !== null && !Array.isArray(value) && !(value instanceof Date);\r\n\t}\r\n\r\n\tprivate async parseSchema(schema: TSchema, input: unknown): Promise<unknown> {\r\n\t\tif (schema && typeof schema === 'object') {\r\n\t\t\tconst maybeAsync = (schema as { parseAsync?: unknown }).parseAsync;\r\n\t\t\tif (typeof maybeAsync === 'function') {\r\n\t\t\t\treturn await (schema as { parseAsync: (i: unknown) => Promise<unknown> }).parseAsync(input);\r\n\t\t\t}\r\n\t\t\tconst maybeSync = (schema as { parse?: unknown }).parse;\r\n\t\t\tif (typeof maybeSync === 'function') {\r\n\t\t\t\treturn (schema as { parse: (i: unknown) => unknown }).parse(input);\r\n\t\t\t}\r\n\r\n\t\t\t// Standard Schema v1 support.\r\n\t\t\t// Note: Zod v3+ exposes a `~standard` adapter too, but we prefer Zod's native parse/parseAsync\r\n\t\t\t// when available so validation failures produce a real `ZodError`.\r\n\t\t\tconst maybeStandard = (schema as { '~standard'?: unknown })['~standard'];\r\n\t\t\tif (maybeStandard && typeof maybeStandard === 'object') {\r\n\t\t\t\tconst validate = (maybeStandard as { validate?: unknown }).validate;\r\n\t\t\t\tif (typeof validate === 'function') {\r\n\t\t\t\t\tconst result = await (validate as (v: unknown) => unknown)(input);\r\n\t\t\t\t\tif (result && typeof result === 'object' && 'issues' in result) {\r\n\t\t\t\t\t\tconst err = new Error('Validation error');\r\n\t\t\t\t\t\t(err as unknown as { issues: unknown }).issues = (result as { issues: unknown }).issues;\r\n\t\t\t\t\t\tthrow err;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif (result && typeof result === 'object' && 'value' in result) {\r\n\t\t\t\t\t\treturn (result as { value: unknown }).value;\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tthrow new Error('Unsupported schema type');\r\n\t}\r\n\r\n\tprivate async tryParseSchema(schema: TSchema, input: unknown): Promise<{ ok: true; value: unknown } | { ok: false }> {\r\n\t\ttry {\r\n\t\t\tif (schema && typeof schema === 'object') {\r\n\t\t\t\tconst safeAsync = (schema as { safeParseAsync?: unknown }).safeParseAsync;\r\n\t\t\t\tif (typeof safeAsync === 'function') {\r\n\t\t\t\t\tconst res = await (\r\n\t\t\t\t\t\tschema as {\r\n\t\t\t\t\t\t\tsafeParseAsync: (i: unknown) => Promise<{ success: boolean; data?: unknown }>;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t).safeParseAsync(input);\r\n\t\t\t\t\treturn res.success ? { ok: true, value: res.data } : { ok: false };\r\n\t\t\t\t}\r\n\r\n\t\t\t\tconst safeSync = (schema as { safeParse?: unknown }).safeParse;\r\n\t\t\t\tif (typeof safeSync === 'function') {\r\n\t\t\t\t\tconst res = (schema as { safeParse: (i: unknown) => { success: boolean; data?: unknown } }).safeParse(input);\r\n\t\t\t\t\treturn res.success ? { ok: true, value: res.data } : { ok: false };\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// Standard Schema v1 support.\r\n\t\t\t\tconst maybeStandard = (schema as { '~standard'?: unknown })['~standard'];\r\n\t\t\t\tif (maybeStandard && typeof maybeStandard === 'object') {\r\n\t\t\t\t\tconst validate = (maybeStandard as { validate?: unknown }).validate;\r\n\t\t\t\t\tif (typeof validate === 'function') {\r\n\t\t\t\t\t\tconst result = await (validate as (v: unknown) => unknown)(input);\r\n\t\t\t\t\t\tif (result && typeof result === 'object' && 'issues' in result) return { ok: false };\r\n\t\t\t\t\t\tif (result && typeof result === 'object' && 'value' in result) return { ok: true, value: (result as { value: unknown }).value };\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\t// Fallback to throwing parse.\r\n\t\t\treturn { ok: true, value: await this.parseSchema(schema, input) };\r\n\t\t} catch {\r\n\t\t\treturn { ok: false };\r\n\t\t}\r\n\t}\r\n\r\n\tprivate async runMiddlewareChain(input: unknown): Promise<Ctx> {\r\n\t\tlet ctx = { ...(this.ctx as Record<string, unknown>) } as Ctx;\r\n\t\tlet currentIndex = 0;\r\n\t\tconst middlewares = this.middlewares as unknown as readonly TMiddlewareFn<any, any>[];\r\n\r\n\t\tconst runNext = async <NC extends Record<string, unknown> = Record<string, never>>(options?: { ctx?: NC }): Promise<Ctx & NC> => {\r\n\t\t\tif (options?.ctx) {\r\n\t\t\t\tctx = { ...ctx, ...options.ctx } as Ctx;\r\n\t\t\t}\r\n\r\n\t\t\tif (currentIndex < middlewares.length) {\r\n\t\t\t\tconst middleware = middlewares[currentIndex] as TMiddlewareFn<any, any>;\r\n\t\t\t\tcurrentIndex++;\r\n\r\n\t\t\t\treturn (await middleware({\r\n\t\t\t\t\tinput,\r\n\t\t\t\t\tctx: Object.freeze({ ...ctx }),\r\n\t\t\t\t\tnext: runNext,\r\n\t\t\t\t})) as Ctx & NC;\r\n\t\t\t}\r\n\r\n\t\t\treturn ctx as Ctx & NC;\r\n\t\t};\r\n\r\n\t\treturn await runNext();\r\n\t}\r\n\r\n\tprivate isValidationError(error: unknown): boolean {\r\n\t\tif (typeof error !== 'object' || error === null) return false;\r\n\r\n\t\tif ('name' in error) {\r\n\t\t\tconst errName = (error as { name: string }).name;\r\n\t\t\tif (errName === 'ZodError' || errName.includes('ValidationError')) {\r\n\t\t\t\treturn true;\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\treturn 'errors' in error || 'issues' in error;\r\n\t}\r\n}\r\n\r\n/**\r\n * Creates a safe action client that handles validation and execution of server actions\r\n */\r\nexport const createSafeActionClient = (options?: TSafeActionClientOptions) => {\r\n\treturn new SafeActionClient({ options });\r\n};\r\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,71 @@
+{
+     "name": "next-action-plus",
+     "version": "0.0.0",
+     "description": "Plug-and-play, type-safe server actions with schema validation (schema-agnostic, Zod compatible).",
+     "license": "UNLICENSED",
+     "repository": {
+          "type": "git",
+          "url": "git+https://github.com/muhgholy/next-action-plus.git"
+     },
+     "homepage": "https://github.com/muhgholy/next-action-plus#readme",
+     "bugs": {
+          "url": "https://github.com/muhgholy/next-action-plus/issues"
+     },
+     "keywords": [
+          "next.js",
+          "nextjs",
+          "server actions",
+          "server action",
+          "type-safe",
+          "typescript",
+          "validation",
+          "zod",
+          "formdata",
+          "standard schema"
+     ],
+     "type": "module",
+     "main": "./dist/index.js",
+     "types": "./dist/index.d.ts",
+     "exports": {
+          ".": {
+               "types": "./dist/index.d.ts",
+               "import": "./dist/index.js",
+               "default": "./dist/index.js"
+          }
+     },
+     "engines": {
+          "node": ">=20"
+     },
+     "files": [
+          "dist"
+     ],
+     "publishConfig": {
+          "access": "public"
+     },
+     "scripts": {
+          "clean": "rm -rf dist",
+          "build": "tsup",
+          "typecheck": "tsc -p tsconfig.build.json --noEmit",
+          "test": "vitest run --typecheck",
+          "test:watch": "vitest --typecheck",
+          "release": "semantic-release"
+     },
+     "peerDependencies": {
+          "zod": "^3.22.0"
+     },
+     "devDependencies": {
+          "@semantic-release/changelog": "^6.0.3",
+          "@semantic-release/commit-analyzer": "^12.0.0",
+          "@semantic-release/git": "^10.0.1",
+          "@semantic-release/github": "^11.0.0",
+          "@semantic-release/npm": "^12.0.0",
+          "@semantic-release/release-notes-generator": "^13.0.0",
+          "@types/node": "^22.10.2",
+          "semantic-release": "^24.0.0",
+          "tsup": "^8.5.0",
+          "typescript": "^5.6.3",
+          "vitest": "^4.0.7",
+          "zod-form-data": "^3.0.1",
+          "zod": "^3.22.0"
+     }
+}