honertia 0.1.4 → 0.1.6

package/README.md

@@ -23,10 +23,15 @@ I wanted to build on Cloudflare Workers whilst retaining the ergonomics of the L
 bun add honertia
 ```
 
-## Quick Start
+### Demo
+
+Deploy the honertia-worker-demo repo to Cloudflare
 
 [![Deploy to Cloudflare](https://deploy.workers.cloudflare.com/button)](https://deploy.workers.cloudflare.com/?url=https://github.com/PatrickOgilvie/honertia-worker-demo)
 
+## Quick Start
+
+
 ### Recommended File Structure
 
 ```
@@ -429,6 +434,225 @@ vite.hmrHead()  // HMR preamble script tags for React Fast Refresh
 - **Dependencies**:
   - `effect` >= 3.12.0
 
+## Anatomy of an Action
+
+Actions in Honertia are fully composable Effect computations. Instead of using different action factories for different combinations of features, you opt-in to exactly what you need by yielding services and helpers inside your action.
+
+This design is inspired by Laravel's [laravel-actions](https://laravelactions.com/) package, where you opt-in to capabilities by adding methods to your action class. In Honertia, you opt-in by yielding services - the order of your `yield*` statements determines the execution order.
+
+### The `action` Wrapper
+
+The `action` function is a semantic wrapper that marks an Effect as an action:
+
+```typescript
+import { Effect } from 'effect'
+import { action } from 'honertia/effect'
+
+export const myAction = action(
+  Effect.gen(function* () {
+    // Your action logic here
+    return new Response('OK')
+  })
+)
+```
+
+It's intentionally minimal - all the power comes from what you yield inside.
+
+### Composable Helpers
+
+#### `authorize` - Authentication & Authorization
+
+Opt-in to authentication and authorization checks. Returns the authenticated user, fails with `UnauthorizedError` if no user is present, and fails with `ForbiddenError` if the check returns `false`.
+
+```typescript
+import { authorize } from 'honertia/effect'
+
+// Just require authentication (any logged-in user)
+const auth = yield* authorize()
+
+// Require a specific role
+const auth = yield* authorize((a) => a.user.role === 'admin')
+
+// Require resource ownership
+const auth = yield* authorize((a) => a.user.id === project.userId)
+```
+
+If the check function returns `false`, the action fails immediately with a `ForbiddenError`.
+
+#### `validateRequest` - Schema Validation
+
+Opt-in to request validation using Effect Schema:
+
+```typescript
+import { Schema as S } from 'effect'
+import { validateRequest, requiredString } from 'honertia/effect'
+
+const input = yield* validateRequest(
+  S.Struct({ name: requiredString, description: S.optional(S.String) }),
+  { errorComponent: 'Projects/Create' }
+)
+// input is fully typed: { name: string, description?: string }
+```
+
+On validation failure, re-renders `errorComponent` with field-level errors.
+
+#### `DatabaseService` - Database Access
+
+Opt-in to database access:
+
+```typescript
+import { DatabaseService } from 'honertia/effect'
+
+const db = yield* DatabaseService
+const projects = yield* Effect.tryPromise(() =>
+  db.query.projects.findMany()
+)
+```
+
+#### `render` / `redirect` - Responses
+
+Return responses from your action:
+
+```typescript
+import { render, redirect } from 'honertia/effect'
+
+// Render a page
+return yield* render('Projects/Index', { projects })
+
+// Redirect after mutation
+return yield* redirect('/projects')
+```
+
+### Building an Action
+
+Here's how these composables work together:
+
+```typescript
+import { Effect, Schema as S } from 'effect'
+import {
+  action,
+  authorize,
+  validateRequest,
+  DatabaseService,
+  redirect,
+  requiredString,
+} from 'honertia/effect'
+
+const CreateProjectSchema = S.Struct({
+  name: requiredString,
+  description: S.optional(S.String),
+})
+
+export const createProject = action(
+  Effect.gen(function* () {
+    // 1. Authorization - fail fast if not allowed
+    const auth = yield* authorize((a) => a.user.role === 'author')
+
+    // 2. Validation - parse and validate request body
+    const input = yield* validateRequest(CreateProjectSchema, {
+      errorComponent: 'Projects/Create',
+    })
+
+    // 3. Database - perform the mutation
+    const db = yield* DatabaseService
+    yield* Effect.tryPromise(() =>
+      db.insert(projects).values({
+        ...input,
+        userId: auth.user.id,
+      })
+    )
+
+    // 4. Response - redirect on success
+    return yield* redirect('/projects')
+  })
+)
+```
+
+### Execution Order Matters
+
+The order you yield services determines when they execute:
+
+```typescript
+// Authorization BEFORE validation (recommended for most actions)
+// Don't waste cycles validating if user can't perform the action
+const auth = yield* authorize((a) => a.user.role === 'admin')
+const input = yield* validateRequest(schema)
+
+// Validation BEFORE authorization (when you need to fetch the resource first)
+// Validate the ID format, fetch from DB, then check ownership against the DB record
+const { id } = yield* validateRequest(Schema.Struct({ id: Schema.UUID }))
+const project = yield* db.findProjectById(id)
+const auth = yield* authorize((a) => a.user.id === project.ownerId)
+```
+
+### Type Safety
+
+Effect tracks all service requirements at the type level. Your action's type signature shows exactly what it needs:
+
+```typescript
+// This action requires: RequestService, DatabaseService
+export const createProject: Effect.Effect<
+  Response | Redirect,
+  ValidationError | UnauthorizedError | ForbiddenError | Error,
+  RequestService | DatabaseService
+>
+```
+
+The compiler ensures all required services are provided when the action runs.
+Note: `authorize` uses an optional `AuthUserService`, so it won't appear in the required service list unless you `yield* AuthUserService` directly or provide `RequireAuthLayer` explicitly.
+
+### Minimal Actions
+
+Not every action needs all features. Use only what you need:
+
+```typescript
+// Public page - no auth, no validation
+export const showAbout = action(
+  Effect.gen(function* () {
+    return yield* render('About', {})
+  })
+)
+
+// Read-only authenticated page
+export const showDashboard = action(
+  Effect.gen(function* () {
+    const auth = yield* authorize()
+    const db = yield* DatabaseService
+    const stats = yield* fetchStats(db, auth)
+    return yield* render('Dashboard', { stats })
+  })
+)
+
+// API endpoint with just validation
+export const searchProjects = action(
+  Effect.gen(function* () {
+    const { query } = yield* validateRequest(S.Struct({ query: S.String }))
+    const db = yield* DatabaseService
+    const results = yield* search(db, query)
+    return yield* json({ results })
+  })
+)
+```
+
+### Helper Utilities
+
+#### `dbTransaction` - Database Transactions
+
+Run multiple database operations in a transaction with automatic rollback on failure. The database instance is passed explicitly to keep the dependency visible and consistent with other service patterns:
+
+```typescript
+import { DatabaseService, dbTransaction } from 'honertia/effect'
+
+const db = yield* DatabaseService
+
+yield* dbTransaction(db, async (tx) => {
+  await tx.insert(users).values({ name: 'Alice', email: 'alice@example.com' })
+  await tx.update(accounts).set({ balance: 100 }).where(eq(accounts.userId, id))
+  // If any operation fails, the entire transaction rolls back
+  return { success: true }
+})
+```
+
 ## Core Concepts
 
 ### Effect-Based Handlers
@@ -655,6 +879,45 @@ export const createProject = Effect.gen(function* () {
 })
 ```
 
+### Validation Options
+
+`validateRequest` accepts an options object with:
+
+```typescript
+const input = yield* validateRequest(schema, {
+  // Re-render this component with errors on validation failure
+  // If not set, redirects back to the previous page
+  errorComponent: 'Projects/Create',
+
+  // Override default error messages per field
+  messages: {
+    name: 'Please enter a project name',
+    email: 'That email address is not valid',
+  },
+
+  // Human-readable field names for the :attribute placeholder
+  // Use with messages like 'The :attribute field is required'
+  attributes: {
+    name: 'project name',
+    email: 'email address',
+  },
+})
+```
+
+**Example with `:attribute` placeholder:**
+
+```typescript
+const schema = S.Struct({
+  email: S.String.pipe(S.minLength(1, { message: () => 'The :attribute field is required' })),
+})
+
+const input = yield* validateRequest(schema, {
+  attributes: { email: 'email address' },
+  errorComponent: 'Auth/Register',
+})
+// Error: "The email address field is required"
+```
+
 ### Available Validators
 
 #### Strings
@@ -972,221 +1235,6 @@ export const logoutUser = betterAuthLogoutAction({
 2. **better-auth returns an error** → Calls your `errorMapper`, then re-renders `errorComponent` with those errors
 3. **Success** → Sets session cookies from better-auth's response headers, then 303 redirects to `redirectTo`
 
-## Anatomy of an Action
-
-Actions in Honertia are fully composable Effect computations. Instead of using different action factories for different combinations of features, you opt-in to exactly what you need by yielding services and helpers inside your action.
-
-This design is inspired by Laravel's [laravel-actions](https://laravelactions.com/) package, where you opt-in to capabilities by adding methods to your action class. In Honertia, you opt-in by yielding services - the order of your `yield*` statements determines the execution order.
-
-### The `action` Wrapper
-
-The `action` function is a semantic wrapper that marks an Effect as an action:
-
-```typescript
-import { Effect } from 'effect'
-import { action } from 'honertia/effect'
-
-export const myAction = action(
-  Effect.gen(function* () {
-    // Your action logic here
-    return new Response('OK')
-  })
-)
-```
-
-It's intentionally minimal - all the power comes from what you yield inside.
-
-### Composable Helpers
-
-#### `authorize` - Authentication & Authorization
-
-Opt-in to authentication and authorization checks. Returns the authenticated user, fails with `UnauthorizedError` if no user is present, and fails with `ForbiddenError` if the check returns `false`.
-
-```typescript
-import { authorize } from 'honertia/effect'
-
-// Just require authentication (any logged-in user)
-const auth = yield* authorize()
-
-// Require a specific role
-const auth = yield* authorize((a) => a.user.role === 'admin')
-
-// Require resource ownership
-const auth = yield* authorize((a) => a.user.id === project.userId)
-```
-
-If the check function returns `false`, the action fails immediately with a `ForbiddenError`.
-
-#### `validateRequest` - Schema Validation
-
-Opt-in to request validation using Effect Schema:
-
-```typescript
-import { Schema as S } from 'effect'
-import { validateRequest, requiredString } from 'honertia/effect'
-
-const input = yield* validateRequest(
-  S.Struct({ name: requiredString, description: S.optional(S.String) }),
-  { errorComponent: 'Projects/Create' }
-)
-// input is fully typed: { name: string, description?: string }
-```
-
-On validation failure, re-renders `errorComponent` with field-level errors.
-
-#### `DatabaseService` - Database Access
-
-Opt-in to database access:
-
-```typescript
-import { DatabaseService } from 'honertia/effect'
-
-const db = yield* DatabaseService
-const projects = yield* Effect.tryPromise(() =>
-  db.query.projects.findMany()
-)
-```
-
-#### `render` / `redirect` - Responses
-
-Return responses from your action:
-
-```typescript
-import { render, redirect } from 'honertia/effect'
-
-// Render a page
-return yield* render('Projects/Index', { projects })
-
-// Redirect after mutation
-return yield* redirect('/projects')
-```
-
-### Building an Action
-
-Here's how these composables work together:
-
-```typescript
-import { Effect, Schema as S } from 'effect'
-import {
-  action,
-  authorize,
-  validateRequest,
-  DatabaseService,
-  redirect,
-  requiredString,
-} from 'honertia/effect'
-
-const CreateProjectSchema = S.Struct({
-  name: requiredString,
-  description: S.optional(S.String),
-})
-
-export const createProject = action(
-  Effect.gen(function* () {
-    // 1. Authorization - fail fast if not allowed
-    const auth = yield* authorize((a) => a.user.role === 'author')
-
-    // 2. Validation - parse and validate request body
-    const input = yield* validateRequest(CreateProjectSchema, {
-      errorComponent: 'Projects/Create',
-    })
-
-    // 3. Database - perform the mutation
-    const db = yield* DatabaseService
-    yield* Effect.tryPromise(() =>
-      db.insert(projects).values({
-        ...input,
-        userId: auth.user.id,
-      })
-    )
-
-    // 4. Response - redirect on success
-    return yield* redirect('/projects')
-  })
-)
-```
-
-### Execution Order Matters
-
-The order you yield services determines when they execute:
-
-```typescript
-// Authorization BEFORE validation (recommended for mutations)
-// Don't waste cycles validating if user can't perform the action
-const auth = yield* authorize((a) => a.user.role === 'admin')
-const input = yield* validateRequest(schema)
-
-// Validation BEFORE authorization (when you need input for auth check)
-const input = yield* validateRequest(schema)
-const auth = yield* authorize((a) => a.user.id === input.ownerId)
-```
-
-### Type Safety
-
-Effect tracks all service requirements at the type level. Your action's type signature shows exactly what it needs:
-
-```typescript
-// This action requires: RequestService, DatabaseService
-export const createProject: Effect.Effect<
-  Response | Redirect,
-  ValidationError | UnauthorizedError | ForbiddenError | Error,
-  RequestService | DatabaseService
->
-```
-
-The compiler ensures all required services are provided when the action runs.
-Note: `authorize` uses an optional `AuthUserService`, so it won't appear in the required service list unless you `yield* AuthUserService` directly or provide `RequireAuthLayer` explicitly.
-
-### Minimal Actions
-
-Not every action needs all features. Use only what you need:
-
-```typescript
-// Public page - no auth, no validation
-export const showAbout = action(
-  Effect.gen(function* () {
-    return yield* render('About', {})
-  })
-)
-
-// Read-only authenticated page
-export const showDashboard = action(
-  Effect.gen(function* () {
-    const auth = yield* authorize()
-    const db = yield* DatabaseService
-    const stats = yield* fetchStats(db, auth)
-    return yield* render('Dashboard', { stats })
-  })
-)
-
-// API endpoint with just validation
-export const searchProjects = action(
-  Effect.gen(function* () {
-    const { query } = yield* validateRequest(S.Struct({ query: S.String }))
-    const db = yield* DatabaseService
-    const results = yield* search(db, query)
-    return yield* json({ results })
-  })
-)
-```
-
-### Helper Utilities
-
-#### `dbTransaction` - Database Transactions
-
-Run multiple database operations in a transaction with automatic rollback on failure:
-
-```typescript
-import { dbTransaction } from 'honertia/effect'
-
-yield* dbTransaction(async (tx) => {
-  await tx.insert(users).values({ name: 'Alice', email: 'alice@example.com' })
-  await tx.update(accounts).set({ balance: 100 }).where(eq(accounts.userId, id))
-  // If any operation fails, the entire transaction rolls back
-  return { success: true }
-})
-```
-
 ## React Integration
 
 ### Page Component Type

package/dist/effect/action.d.ts

@@ -5,7 +5,7 @@
  * Actions are fully opt-in - yield* only what you need.
  */
 import { Effect } from 'effect';
-import { DatabaseService, type AuthUser } from './services.js';
+import { type AuthUser } from './services.js';
 import { UnauthorizedError, ForbiddenError, Redirect } from './errors.js';
 /**
  * Semantic wrapper for Effect actions.
@@ -57,11 +57,14 @@ export declare function authorize(check?: (user: AuthUser) => boolean): Effect.E
  * Automatically rolls back on any failure.
  *
  * @example
- * yield* dbTransaction(async (tx) => {
+ * const db = yield* DatabaseService
+ * yield* dbTransaction(db, async (tx) => {
  *   await tx.insert(users).values({ name: 'Alice' })
  *   await tx.update(accounts).set({ balance: 100 }).where(eq(accounts.userId, id))
  *   return { success: true }
  * })
  */
-export declare function dbTransaction<T>(operations: (tx: unknown) => Promise<T>): Effect.Effect<T, Error, DatabaseService>;
+export declare function dbTransaction<DB extends {
+    transaction: (fn: (tx: unknown) => Promise<T>) => Promise<T>;
+}, T>(db: DB, operations: (tx: unknown) => Promise<T>): Effect.Effect<T, Error>;
 //# sourceMappingURL=action.d.ts.map

package/dist/effect/action.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"action.d.ts","sourceRoot":"","sources":["../../src/effect/action.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAA;AACvC,OAAO,EACL,eAAe,EAEf,KAAK,QAAQ,EACd,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAEzE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EACzB,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,GAAG,QAAQ,EAAE,CAAC,EAAE,CAAC,CAAC,GAChD,MAAM,CAAC,MAAM,CAAC,QAAQ,GAAG,QAAQ,EAAE,CAAC,EAAE,CAAC,CAAC,CAE1C;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CACvB,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,OAAO,GAClC,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,iBAAiB,GAAG,cAAc,EAAE,KAAK,CAAC,CAoBpE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC7B,UAAU,EAAE,CAAC,EAAE,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,GACtC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,eAAe,CAAC,CAQ1C"}
+{"version":3,"file":"action.d.ts","sourceRoot":"","sources":["../../src/effect/action.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAA;AACvC,OAAO,EAGL,KAAK,QAAQ,EACd,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAEzE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EACzB,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,GAAG,QAAQ,EAAE,CAAC,EAAE,CAAC,CAAC,GAChD,MAAM,CAAC,MAAM,CAAC,QAAQ,GAAG,QAAQ,EAAE,CAAC,EAAE,CAAC,CAAC,CAE1C;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CACvB,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,OAAO,GAClC,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,iBAAiB,GAAG,cAAc,EAAE,KAAK,CAAC,CAoBpE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,EAAE,SAAS;IAAE,WAAW,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAA;CAAE,EAAE,CAAC,EAC1G,EAAE,EAAE,EAAE,EACN,UAAU,EAAE,CAAC,EAAE,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,GACtC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,CAKzB"}

package/dist/effect/action.js

@@ -5,7 +5,7 @@
  * Actions are fully opt-in - yield* only what you need.
  */
 import { Effect, Option } from 'effect';
-import { DatabaseService, AuthUserService, } from './services.js';
+import { AuthUserService, } from './services.js';
 import { UnauthorizedError, ForbiddenError } from './errors.js';
 /**
  * Semantic wrapper for Effect actions.
@@ -74,18 +74,16 @@ export function authorize(check) {
  * Automatically rolls back on any failure.
  *
  * @example
- * yield* dbTransaction(async (tx) => {
+ * const db = yield* DatabaseService
+ * yield* dbTransaction(db, async (tx) => {
  *   await tx.insert(users).values({ name: 'Alice' })
  *   await tx.update(accounts).set({ balance: 100 }).where(eq(accounts.userId, id))
  *   return { success: true }
  * })
  */
-export function dbTransaction(operations) {
-    return Effect.gen(function* () {
-        const db = yield* DatabaseService;
-        return yield* Effect.tryPromise({
-            try: () => db.transaction(operations),
-            catch: (error) => error instanceof Error ? error : new Error(String(error)),
-        });
+export function dbTransaction(db, operations) {
+    return Effect.tryPromise({
+        try: () => db.transaction(operations),
+        catch: (error) => error instanceof Error ? error : new Error(String(error)),
     });
 }

package/dist/effect/validation.d.ts

@@ -8,31 +8,53 @@ import { RequestService } from './services.js';
 import { ValidationError } from './errors.js';
 /**
  * Extract validation data from the request.
- * Merges route params, query params, and body.
+ * Merges route params, query params, and body (body takes precedence).
  */
-export declare const getValidationData: Effect.Effect<{
-    [x: string]: unknown;
-}, never, RequestService>;
+export declare const getValidationData: Effect.Effect<Record<string, unknown>, ValidationError, RequestService>;
 /**
  * Format Effect Schema parse errors into field-level validation errors.
  */
 export declare function formatSchemaErrors(error: ParseResult.ParseError, messages?: Record<string, string>, attributes?: Record<string, string>): Record<string, string>;
 /**
- * Validate data against a schema.
- * Returns validated data or fails with ValidationError.
+ * Options for validation functions.
  */
-export declare const validate: <A, I>(schema: S.Schema<A, I>, options?: {
+export interface ValidateOptions {
+    /**
+     * Custom error messages keyed by field name.
+     * Overrides the default messages from Effect Schema.
+     *
+     * @example
+     * { email: 'Please enter a valid email address' }
+     */
     messages?: Record<string, string>;
+    /**
+     * Human-readable names for fields, used with the `:attribute` placeholder.
+     * If a message contains `:attribute`, it will be replaced with the value here.
+     *
+     * @example
+     * // With attributes: { email: 'email address' }
+     * // And message: 'The :attribute field is required'
+     * // Produces: 'The email address field is required'
+     */
     attributes?: Record<string, string>;
+    /**
+     * The Inertia component to re-render when validation fails.
+     * If set, a ValidationError will trigger a re-render of this component
+     * with the errors passed as props. If not set, redirects back.
+     *
+     * @example
+     * 'Projects/Create'
+     */
     errorComponent?: string;
-}) => (data: unknown) => Effect.Effect<A, ValidationError, never>;
+}
+/**
+ * Validate data against a schema.
+ * Returns validated data or fails with ValidationError.
+ */
+export declare function validate<A, I>(schema: S.Schema<A, I>, data: unknown, options?: ValidateOptions): Effect.Effect<A, ValidationError, never>;
 /**
  * Validate request data against a schema.
  * Extracts data from request and validates in one step.
  */
-export declare const validateRequest: <A, I>(schema: S.Schema<A, I>, options?: {
-    messages?: Record<string, string>;
-    attributes?: Record<string, string>;
-    errorComponent?: string;
-}) => Effect.Effect<A, ValidationError, RequestService>;
+export declare function validateRequest<A, I>(schema: S.Schema<A, I>, options?: ValidateOptions): Effect.Effect<A, ValidationError, RequestService>;
 //# sourceMappingURL=validation.d.ts.map

package/dist/effect/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/effect/validation.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,IAAI,CAAC,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAA;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAE7C;;;GAGG;AACH,eAAO,MAAM,iBAAiB;;yBAuB5B,CAAA;AAEF;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,WAAW,CAAC,UAAU,EAC7B,QAAQ,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,EACrC,UAAU,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,GACtC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAqBxB;AAED;;;GAGG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,CAAC,EAC3B,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EACtB,UAAU;IACR,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,MAEA,MAAM,OAAO,KAAG,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,eAAe,EAAE,KAAK,CAYrD,CAAA;AAEL;;;GAGG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,EAAE,CAAC,EAClC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EACtB,UAAU;IACR,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,KACA,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,eAAe,EAAE,cAAc,CAI/C,CAAA"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/effect/validation.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,IAAI,CAAC,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAA;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAE7C;;;GAGG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,CAC3C,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACvB,eAAe,EACf,cAAc,CA0Bd,CAAA;AAEF;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,WAAW,CAAC,UAAU,EAC7B,QAAQ,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,EACrC,UAAU,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,GACtC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAgBxB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAEjC;;;;;;;;OAQG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAEnC;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAC3B,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EACtB,IAAI,EAAE,OAAO,EACb,OAAO,GAAE,eAAoB,GAC5B,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,eAAe,EAAE,KAAK,CAAC,CAS1C;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,CAAC,EAClC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EACtB,OAAO,GAAE,eAAoB,GAC5B,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,eAAe,EAAE,cAAc,CAAC,CAKnD"}

package/dist/effect/validation.js

@@ -8,46 +8,36 @@ import { RequestService } from './services.js';
 import { ValidationError } from './errors.js';
 /**
  * Extract validation data from the request.
- * Merges route params, query params, and body.
+ * Merges route params, query params, and body (body takes precedence).
  */
 export const getValidationData = Effect.gen(function* () {
     const request = yield* RequestService;
     const routeParams = request.params();
     const queryParams = request.query();
-    let body = {};
-    if (!['GET', 'HEAD'].includes(request.method.toUpperCase())) {
-        const contentType = request.header('Content-Type') || '';
-        const bodyResult = yield* Effect.tryPromise({
-            try: () => contentType.includes('application/json')
-                ? request.json()
-                : request.parseBody(),
-            catch: () => ({}),
-        }).pipe(Effect.catchAll(() => Effect.succeed({})));
-        body = bodyResult;
+    // Only parse body for methods that typically have one
+    if (['GET', 'HEAD'].includes(request.method.toUpperCase())) {
+        return { ...routeParams, ...queryParams };
     }
-    return {
-        ...routeParams,
-        ...queryParams,
-        ...body,
-    };
+    const contentType = request.header('Content-Type') ?? '';
+    const isJson = contentType.includes('application/json');
+    const body = yield* Effect.tryPromise(() => isJson ? request.json() : request.parseBody()).pipe(Effect.mapError(() => new ValidationError({
+        errors: { form: isJson ? 'Invalid JSON body' : 'Could not parse request body' },
+    })));
+    return { ...routeParams, ...queryParams, ...body };
 });
 /**
  * Format Effect Schema parse errors into field-level validation errors.
  */
 export function formatSchemaErrors(error, messages = {}, attributes = {}) {
     const errors = {};
-    // Use ArrayFormatter to get structured errors
-    const formattedErrors = ParseResult.ArrayFormatter.formatErrorSync(error);
-    for (const issue of formattedErrors) {
-        const pathStr = issue.path.length > 0
-            ? issue.path.map(p => typeof p === 'object' && p !== null && 'key' in p ? p.key : String(p)).join('.')
-            : 'form';
-        if (errors[pathStr])
+    const issues = ParseResult.ArrayFormatter.formatErrorSync(error);
+    for (const issue of issues) {
+        const field = issue.path.length > 0 ? issue.path.map(String).join('.') : 'form';
+        if (errors[field])
             continue; // First error wins
-        const attribute = attributes[pathStr] ?? pathStr;
-        const messageKey = messages[pathStr];
-        const message = messageKey ?? issue.message;
-        errors[pathStr] = message.replace(/:attribute/g, attribute);
+        const attribute = attributes[field] ?? field;
+        const message = messages[field] ?? issue.message;
+        errors[field] = message.replace(/:attribute/g, attribute);
     }
     return errors;
 }
@@ -55,15 +45,19 @@ export function formatSchemaErrors(error, messages = {}, attributes = {}) {
  * Validate data against a schema.
  * Returns validated data or fails with ValidationError.
  */
-export const validate = (schema, options) => (data) => S.decodeUnknown(schema)(data).pipe(Effect.mapError((error) => new ValidationError({
-    errors: formatSchemaErrors(error, options?.messages ?? {}, options?.attributes ?? {}),
-    component: options?.errorComponent,
-})));
+export function validate(schema, data, options = {}) {
+    return S.decodeUnknown(schema)(data).pipe(Effect.mapError((error) => new ValidationError({
+        errors: formatSchemaErrors(error, options.messages, options.attributes),
+        component: options.errorComponent,
+    })));
+}
 /**
  * Validate request data against a schema.
  * Extracts data from request and validates in one step.
  */
-export const validateRequest = (schema, options) => Effect.gen(function* () {
-    const data = yield* getValidationData;
-    return yield* validate(schema, options)(data);
-});
+export function validateRequest(schema, options = {}) {
+    return Effect.gen(function* () {
+        const data = yield* getValidationData;
+        return yield* validate(schema, data, options);
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "honertia",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Inertia.js-style server-driven SPA adapter for Hono",
   "type": "module",
   "main": "./dist/index.js",