honertia 0.1.3 → 0.1.4

package/README.md

@@ -433,47 +433,55 @@ vite.hmrHead()  // HMR preamble script tags for React Fast Refresh
 
 ### Effect-Based Handlers
 
-Route handlers are Effect computations that return `Response | Redirect`:
+Route handlers are Effect computations that return `Response | Redirect`. Actions are fully composable - you opt-in to features by yielding services:
 
 ```typescript
 import { Effect } from 'effect'
 import {
+  action,
+  authorize,
+  validateRequest,
   DatabaseService,
-  AuthUserService,
   render,
   redirect,
-} from 'honertia'
-
-// Simple page render
-export const showDashboard = Effect.gen(function* () {
-  const db = yield* DatabaseService
-  const user = yield* AuthUserService
+} from 'honertia/effect'
 
-  const projects = yield* Effect.tryPromise(() =>
-    db.query.projects.findMany({
-      where: eq(schema.projects.userId, user.user.id),
-      limit: 5,
-    })
-  )
+// Simple page render with auth
+export const showDashboard = action(
+  Effect.gen(function* () {
+    const auth = yield* authorize()
+    const db = yield* DatabaseService
 
-  return yield* render('Dashboard/Index', { projects })
-})
+    const projects = yield* Effect.tryPromise(() =>
+      db.query.projects.findMany({
+        where: eq(schema.projects.userId, auth.user.id),
+        limit: 5,
+      })
+    )
 
-// Form submission with redirect
-export const createProject = Effect.gen(function* () {
-  const db = yield* DatabaseService
-  const user = yield* AuthUserService
-  const input = yield* validateRequest(CreateProjectSchema)
+    return yield* render('Dashboard/Index', { projects })
+  })
+)
 
-  yield* Effect.tryPromise(() =>
-    db.insert(schema.projects).values({
-      ...input,
-      userId: user.user.id,
+// Form submission with permissions, validation, and redirect
+export const createProject = action(
+  Effect.gen(function* () {
+    const auth = yield* authorize((a) => a.user.role === 'admin')
+    const input = yield* validateRequest(CreateProjectSchema, {
+      errorComponent: 'Projects/Create',
     })
-  )
+    const db = yield* DatabaseService
 
-  return yield* redirect('/projects')
-})
+    yield* Effect.tryPromise(() =>
+      db.insert(schema.projects).values({
+        ...input,
+        userId: auth.user.id,
+      })
+    )
+
+    return yield* redirect('/projects')
+  })
+)
 ```
 
 ### Services
@@ -964,42 +972,219 @@ 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`
 
-## Action Factories
+## 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.
 
-For common patterns, use action factories:
+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 { effectAction, dbAction, authAction } from 'honertia'
-
-// effectAction: validation + custom handler
-export const updateSettings = effectAction(
-  SettingsSchema,
-  (input) => Effect.gen(function* () {
-    yield* saveSettings(input)
-    return yield* redirect('/settings')
-  }),
-  { errorComponent: 'Settings/Edit' }
+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()
 )
+```
 
-// dbAction: validation + db + auth
-export const createProject = dbAction(
-  CreateProjectSchema,
-  (input, { db, user }) => Effect.gen(function* () {
+#### `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: user.user.id })
+      db.insert(projects).values({
+        ...input,
+        userId: auth.user.id,
+      })
     )
+
+    // 4. Response - redirect on success
     return yield* redirect('/projects')
-  }),
-  { errorComponent: 'Projects/Create' }
+  })
 )
+```
+
+### 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:
 
-// authAction: just requires auth
-export const showDashboard = authAction((user) =>
+```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* () {
-    const data = yield* fetchDashboardData(user)
-    return yield* render('Dashboard', data)
+    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

package/dist/effect/action.d.ts

@@ -1,107 +1,67 @@
 /**
- * Effect Action Factories
+ * Effect Action Composables
  *
- * Pure function factories for creating Effect-based request handlers.
+ * Composable helpers for building Effect-based request handlers.
+ * Actions are fully opt-in - yield* only what you need.
  */
-import { Effect, Schema as S } from 'effect';
-import { DatabaseService, AuthUserService, RequestService, type AuthUser } from './services.js';
-import { ValidationError, UnauthorizedError } from './errors.js';
-import { Redirect } from './errors.js';
+import { Effect } from 'effect';
+import { DatabaseService, type AuthUser } from './services.js';
+import { UnauthorizedError, ForbiddenError, Redirect } from './errors.js';
 /**
- * Create an Effect action with schema validation.
+ * Semantic wrapper for Effect actions.
+ *
+ * This is a minimal wrapper that marks an Effect as an action.
+ * All capabilities are opt-in via yield* inside your handler.
  *
  * @example
- * const createProject = effectAction(
- *   S.Struct({ name: requiredString }),
- *   (input) => Effect.gen(function* () {
+ * const createProject = action(
+ *   Effect.gen(function* () {
+ *     // Opt-in to authorization
+ *     const auth = yield* authorize()
+ *
+ *     // Opt-in to validation
+ *     const input = yield* validateRequest(S.Struct({ name: requiredString }))
+ *
+ *     // Opt-in to database
  *     const db = yield* DatabaseService
- *     yield* Effect.tryPromise(() => db.insert(projects).values(input))
- *     return new Redirect({ url: '/projects', status: 303 })
- *   })
- * )
- */
-export declare function effectAction<A, I, R, E>(schema: S.Schema<A, I>, handler: (input: A) => Effect.Effect<Response | Redirect, E, R>, options?: {
-    errorComponent?: string;
-    messages?: Record<string, string>;
-    attributes?: Record<string, string>;
-}): Effect.Effect<Response | Redirect, E | ValidationError, R | RequestService>;
-/**
- * Create an Effect action that requires authentication and database access.
  *
- * @example
- * const createProject = dbAction(
- *   S.Struct({ name: requiredString }),
- *   (input, { db, user }) => Effect.gen(function* () {
  *     yield* Effect.tryPromise(() =>
- *       db.insert(projects).values({ ...input, userId: user.user.id })
+ *       db.insert(projects).values({ ...input, userId: auth.user.id })
  *     )
  *     return new Redirect({ url: '/projects', status: 303 })
  *   })
  * )
  */
-export declare function dbAction<A, I, E>(schema: S.Schema<A, I>, handler: (input: A, deps: {
-    db: unknown;
-    user: AuthUser;
-}) => Effect.Effect<Response | Redirect, E, never>, options?: {
-    errorComponent?: string;
-    messages?: Record<string, string>;
-    attributes?: Record<string, string>;
-}): Effect.Effect<Response | Redirect, E | ValidationError | UnauthorizedError, RequestService | DatabaseService | AuthUserService>;
+export declare function action<R, E>(handler: Effect.Effect<Response | Redirect, E, R>): Effect.Effect<Response | Redirect, E, R>;
 /**
- * Create an Effect action that requires authentication.
+ * Authorization helper - opt-in to auth check.
  *
- * @example
- * const showDashboard = authAction(() => Effect.gen(function* () {
- *   const user = yield* AuthUserService
- *   const honertia = yield* HonertiaService
- *   return yield* Effect.tryPromise(() => honertia.render('Dashboard', { user: user.user }))
- * }))
- */
-export declare function authAction<R, E>(handler: (user: AuthUser) => Effect.Effect<Response | Redirect, E, R>): Effect.Effect<Response | Redirect, E | UnauthorizedError, R | AuthUserService>;
-/**
- * Create a simple Effect action without validation.
+ * Returns the authenticated user if authorized.
+ * Fails with UnauthorizedError if no user is present.
+ * Fails with ForbiddenError if the check returns false.
+ * The check function is optional - if not provided, just requires authentication.
  *
  * @example
- * const listProjects = simpleAction(() => Effect.gen(function* () {
- *   const db = yield* DatabaseService
- *   const user = yield* AuthUserService
- *   const projects = yield* Effect.tryPromise(() => db.query.projects.findMany())
- *   const honertia = yield* HonertiaService
- *   return yield* Effect.tryPromise(() => honertia.render('Projects', { projects }))
- * }))
+ * // Just require authentication
+ * const auth = yield* authorize()
+ *
+ * // Require specific role (if your user type has a role field)
+ * const auth = yield* authorize((a) => a.user.role === 'admin')
+ *
+ * // Require resource ownership
+ * const auth = yield* authorize((a) => a.user.id === project.userId)
  */
-export declare function simpleAction<R, E>(handler: () => Effect.Effect<Response | Redirect, E, R>): Effect.Effect<Response | Redirect, E, R>;
+export declare function authorize(check?: (user: AuthUser) => boolean): Effect.Effect<AuthUser, UnauthorizedError | ForbiddenError, never>;
 /**
- * Inject additional data into the validated input.
+ * Run multiple database operations in a transaction.
+ * Automatically rolls back on any failure.
  *
  * @example
- * const createProject = effectAction(
- *   S.Struct({ name: requiredString }),
- *   (input) => pipe(
- *     injectUser(input),
- *     Effect.flatMap(({ name, userId }) =>
- *       Effect.tryPromise(() => db.insert(projects).values({ name, userId }))
- *     )
- *   )
- * )
- */
-export declare function injectUser<T extends Record<string, unknown>>(input: T): Effect.Effect<T & {
-    userId: string;
-}, UnauthorizedError, AuthUserService>;
-/**
- * Run a database operation wrapped in Effect.
- */
-export declare function dbOperation<T>(operation: (db: unknown) => Promise<T>): Effect.Effect<T, Error, DatabaseService>;
-/**
- * Prepare validation data by transforming it before validation.
- */
-export declare function prepareData<T extends Record<string, unknown>>(transform: (data: Record<string, unknown>) => T | Promise<T>): Effect.Effect<T, never, RequestService>;
-/**
- * Create an action with custom data preparation.
+ * yield* dbTransaction(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 preparedAction<A, I, R, E>(schema: S.Schema<A, I>, prepare: (data: Record<string, unknown>) => Record<string, unknown> | Promise<Record<string, unknown>>, handler: (input: A) => Effect.Effect<Response | Redirect, E, R>, options?: {
-    errorComponent?: string;
-    messages?: Record<string, string>;
-    attributes?: Record<string, string>;
-}): Effect.Effect<Response | Redirect, E | ValidationError, R | RequestService>;
+export declare function dbTransaction<T>(operations: (tx: unknown) => Promise<T>): Effect.Effect<T, Error, DatabaseService>;
 //# 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":"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"}
+{"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"}

package/dist/effect/action.js

@@ -1,150 +1,91 @@
 /**
- * Effect Action Factories
+ * Effect Action Composables
  *
- * Pure function factories for creating Effect-based request handlers.
+ * Composable helpers for building Effect-based request handlers.
+ * Actions are fully opt-in - yield* only what you need.
  */
-import { Effect } from 'effect';
+import { Effect, Option } from 'effect';
 import { DatabaseService, AuthUserService, } from './services.js';
-import { validateRequest, getValidationData, validate } from './validation.js';
+import { UnauthorizedError, ForbiddenError } from './errors.js';
 /**
- * Create an Effect action with schema validation.
+ * Semantic wrapper for Effect actions.
+ *
+ * This is a minimal wrapper that marks an Effect as an action.
+ * All capabilities are opt-in via yield* inside your handler.
  *
  * @example
- * const createProject = effectAction(
- *   S.Struct({ name: requiredString }),
- *   (input) => Effect.gen(function* () {
+ * const createProject = action(
+ *   Effect.gen(function* () {
+ *     // Opt-in to authorization
+ *     const auth = yield* authorize()
+ *
+ *     // Opt-in to validation
+ *     const input = yield* validateRequest(S.Struct({ name: requiredString }))
+ *
+ *     // Opt-in to database
  *     const db = yield* DatabaseService
- *     yield* Effect.tryPromise(() => db.insert(projects).values(input))
- *     return new Redirect({ url: '/projects', status: 303 })
- *   })
- * )
- */
-export function effectAction(schema, handler, options) {
-    return Effect.gen(function* () {
-        const input = yield* validateRequest(schema, {
-            errorComponent: options?.errorComponent,
-            messages: options?.messages,
-            attributes: options?.attributes,
-        });
-        return yield* handler(input);
-    });
-}
-/**
- * Create an Effect action that requires authentication and database access.
  *
- * @example
- * const createProject = dbAction(
- *   S.Struct({ name: requiredString }),
- *   (input, { db, user }) => Effect.gen(function* () {
  *     yield* Effect.tryPromise(() =>
- *       db.insert(projects).values({ ...input, userId: user.user.id })
+ *       db.insert(projects).values({ ...input, userId: auth.user.id })
  *     )
  *     return new Redirect({ url: '/projects', status: 303 })
  *   })
  * )
  */
-export function dbAction(schema, handler, options) {
-    return Effect.gen(function* () {
-        const db = yield* DatabaseService;
-        const user = yield* AuthUserService;
-        const input = yield* validateRequest(schema, {
-            errorComponent: options?.errorComponent,
-            messages: options?.messages,
-            attributes: options?.attributes,
-        });
-        return yield* handler(input, { db, user });
-    });
+export function action(handler) {
+    return handler;
 }
 /**
- * Create an Effect action that requires authentication.
+ * Authorization helper - opt-in to auth check.
  *
- * @example
- * const showDashboard = authAction(() => Effect.gen(function* () {
- *   const user = yield* AuthUserService
- *   const honertia = yield* HonertiaService
- *   return yield* Effect.tryPromise(() => honertia.render('Dashboard', { user: user.user }))
- * }))
- */
-export function authAction(handler) {
-    return Effect.gen(function* () {
-        const user = yield* AuthUserService;
-        return yield* handler(user);
-    });
-}
-/**
- * Create a simple Effect action without validation.
+ * Returns the authenticated user if authorized.
+ * Fails with UnauthorizedError if no user is present.
+ * Fails with ForbiddenError if the check returns false.
+ * The check function is optional - if not provided, just requires authentication.
  *
  * @example
- * const listProjects = simpleAction(() => Effect.gen(function* () {
- *   const db = yield* DatabaseService
- *   const user = yield* AuthUserService
- *   const projects = yield* Effect.tryPromise(() => db.query.projects.findMany())
- *   const honertia = yield* HonertiaService
- *   return yield* Effect.tryPromise(() => honertia.render('Projects', { projects }))
- * }))
- */
-export function simpleAction(handler) {
-    return handler();
-}
-/**
- * Inject additional data into the validated input.
+ * // Just require authentication
+ * const auth = yield* authorize()
  *
- * @example
- * const createProject = effectAction(
- *   S.Struct({ name: requiredString }),
- *   (input) => pipe(
- *     injectUser(input),
- *     Effect.flatMap(({ name, userId }) =>
- *       Effect.tryPromise(() => db.insert(projects).values({ name, userId }))
- *     )
- *   )
- * )
+ * // Require specific role (if your user type has a role field)
+ * const auth = yield* authorize((a) => a.user.role === 'admin')
+ *
+ * // Require resource ownership
+ * const auth = yield* authorize((a) => a.user.id === project.userId)
  */
-export function injectUser(input) {
+export function authorize(check) {
     return Effect.gen(function* () {
-        const authUser = yield* AuthUserService;
-        return { ...input, userId: authUser.user.id };
+        const maybeUser = yield* Effect.serviceOption(AuthUserService);
+        if (Option.isNone(maybeUser)) {
+            return yield* Effect.fail(new UnauthorizedError({
+                message: 'Authentication required',
+                redirectTo: '/login',
+            }));
+        }
+        const user = maybeUser.value;
+        if (check && !check(user)) {
+            return yield* Effect.fail(new ForbiddenError({ message: 'Not authorized' }));
+        }
+        return user;
     });
 }
 /**
- * Run a database operation wrapped in Effect.
+ * Run multiple database operations in a transaction.
+ * Automatically rolls back on any failure.
+ *
+ * @example
+ * yield* dbTransaction(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 dbOperation(operation) {
+export function dbTransaction(operations) {
     return Effect.gen(function* () {
         const db = yield* DatabaseService;
         return yield* Effect.tryPromise({
-            try: () => operation(db),
+            try: () => db.transaction(operations),
             catch: (error) => error instanceof Error ? error : new Error(String(error)),
         });
     });
 }
-/**
- * Prepare validation data by transforming it before validation.
- */
-export function prepareData(transform) {
-    return Effect.gen(function* () {
-        const data = yield* getValidationData;
-        return yield* Effect.tryPromise({
-            try: () => Promise.resolve(transform(data)),
-            catch: () => new Error('Transform failed'),
-        }).pipe(Effect.catchAll(() => Effect.succeed(data)));
-    });
-}
-/**
- * Create an action with custom data preparation.
- */
-export function preparedAction(schema, prepare, handler, options) {
-    return Effect.gen(function* () {
-        const rawData = yield* getValidationData;
-        const preparedData = yield* Effect.tryPromise({
-            try: () => Promise.resolve(prepare(rawData)),
-            catch: () => new Error('Prepare failed'),
-        }).pipe(Effect.catchAll(() => Effect.succeed(rawData)));
-        const input = yield* validate(schema, {
-            errorComponent: options?.errorComponent,
-            messages: options?.messages,
-            attributes: options?.attributes,
-        })(preparedData);
-        return yield* handler(input);
-    });
-}

package/dist/effect/index.d.ts

@@ -9,7 +9,7 @@ export * from './schema.js';
 export { getValidationData, formatSchemaErrors, validate, validateRequest, } from './validation.js';
 export { effectBridge, buildContextLayer, getEffectRuntime, type EffectBridgeConfig, } from './bridge.js';
 export { effectHandler, effect, handle, errorToResponse, } from './handler.js';
-export { effectAction, dbAction, authAction, simpleAction, injectUser, dbOperation, prepareData, preparedAction, } from './action.js';
+export { action, authorize, dbTransaction, } from './action.js';
 export { redirect, render, renderWithErrors, json, text, notFound, forbidden, httpError, prefersJson, jsonOrRender, share, } from './responses.js';
 export { EffectRouteBuilder, effectRoutes, type EffectHandler, type BaseServices, } from './routing.js';
 export { RequireAuthLayer, RequireGuestLayer, isAuthenticated, currentUser, requireAuth, requireGuest, shareAuth, shareAuthMiddleware, effectAuthRoutes, betterAuthFormAction, betterAuthLogoutAction, loadUser, type AuthRoutesConfig, type BetterAuthFormActionConfig, type BetterAuthLogoutConfig, type BetterAuthActionResult, } from './auth.js';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/effect/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,eAAe,EACf,WAAW,EACX,eAAe,EACf,eAAe,EACf,cAAc,EACd,sBAAsB,EACtB,KAAK,QAAQ,EACb,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,eAAe,GACrB,MAAM,eAAe,CAAA;AAGtB,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,aAAa,EACb,cAAc,EACd,SAAS,EACT,QAAQ,EACR,KAAK,QAAQ,GACd,MAAM,aAAa,CAAA;AAGpB,cAAc,aAAa,CAAA;AAG3B,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAClB,QAAQ,EACR,eAAe,GAChB,MAAM,iBAAiB,CAAA;AAGxB,OAAO,EACL,YAAY,EACZ,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,kBAAkB,GACxB,MAAM,aAAa,CAAA;AAGpB,OAAO,EACL,aAAa,EACb,MAAM,EACN,MAAM,EACN,eAAe,GAChB,MAAM,cAAc,CAAA;AAGrB,OAAO,EACL,YAAY,EACZ,QAAQ,EACR,UAAU,EACV,YAAY,EACZ,UAAU,EACV,WAAW,EACX,WAAW,EACX,cAAc,GACf,MAAM,aAAa,CAAA;AAGpB,OAAO,EACL,QAAQ,EACR,MAAM,EACN,gBAAgB,EAChB,IAAI,EACJ,IAAI,EACJ,QAAQ,EACR,SAAS,EACT,SAAS,EACT,WAAW,EACX,YAAY,EACZ,KAAK,GACN,MAAM,gBAAgB,CAAA;AAGvB,OAAO,EACL,kBAAkB,EAClB,YAAY,EACZ,KAAK,aAAa,EAClB,KAAK,YAAY,GAClB,MAAM,cAAc,CAAA;AAGrB,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,eAAe,EACf,WAAW,EACX,WAAW,EACX,YAAY,EACZ,SAAS,EACT,mBAAmB,EACnB,gBAAgB,EAChB,oBAAoB,EACpB,sBAAsB,EACtB,QAAQ,EACR,KAAK,gBAAgB,EACrB,KAAK,0BAA0B,EAC/B,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,GAC5B,MAAM,WAAW,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/effect/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,eAAe,EACf,WAAW,EACX,eAAe,EACf,eAAe,EACf,cAAc,EACd,sBAAsB,EACtB,KAAK,QAAQ,EACb,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,eAAe,GACrB,MAAM,eAAe,CAAA;AAGtB,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,aAAa,EACb,cAAc,EACd,SAAS,EACT,QAAQ,EACR,KAAK,QAAQ,GACd,MAAM,aAAa,CAAA;AAGpB,cAAc,aAAa,CAAA;AAG3B,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAClB,QAAQ,EACR,eAAe,GAChB,MAAM,iBAAiB,CAAA;AAGxB,OAAO,EACL,YAAY,EACZ,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,kBAAkB,GACxB,MAAM,aAAa,CAAA;AAGpB,OAAO,EACL,aAAa,EACb,MAAM,EACN,MAAM,EACN,eAAe,GAChB,MAAM,cAAc,CAAA;AAGrB,OAAO,EACL,MAAM,EACN,SAAS,EACT,aAAa,GACd,MAAM,aAAa,CAAA;AAGpB,OAAO,EACL,QAAQ,EACR,MAAM,EACN,gBAAgB,EAChB,IAAI,EACJ,IAAI,EACJ,QAAQ,EACR,SAAS,EACT,SAAS,EACT,WAAW,EACX,YAAY,EACZ,KAAK,GACN,MAAM,gBAAgB,CAAA;AAGvB,OAAO,EACL,kBAAkB,EAClB,YAAY,EACZ,KAAK,aAAa,EAClB,KAAK,YAAY,GAClB,MAAM,cAAc,CAAA;AAGrB,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,eAAe,EACf,WAAW,EACX,WAAW,EACX,YAAY,EACZ,SAAS,EACT,mBAAmB,EACnB,gBAAgB,EAChB,oBAAoB,EACpB,sBAAsB,EACtB,QAAQ,EACR,KAAK,gBAAgB,EACrB,KAAK,0BAA0B,EAC/B,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,GAC5B,MAAM,WAAW,CAAA"}

package/dist/effect/index.js

@@ -15,8 +15,8 @@ export { getValidationData, formatSchemaErrors, validate, validateRequest, } fro
 export { effectBridge, buildContextLayer, getEffectRuntime, } from './bridge.js';
 // Handler
 export { effectHandler, effect, handle, errorToResponse, } from './handler.js';
-// Action Factories
-export { effectAction, dbAction, authAction, simpleAction, injectUser, dbOperation, prepareData, preparedAction, } from './action.js';
+// Action Composables
+export { action, authorize, dbTransaction, } from './action.js';
 // Response Helpers
 export { redirect, render, renderWithErrors, json, text, notFound, forbidden, httpError, prefersJson, jsonOrRender, share, } from './responses.js';
 // Routing

package/package.json

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