honertia 0.1.0

package/dist/effect/bridge.js

@@ -0,0 +1,103 @@
+/**
+ * Hono-Effect Bridge
+ *
+ * Middleware that connects Hono's request handling to Effect's runtime.
+ */
+import { Layer, ManagedRuntime } from 'effect';
+import { DatabaseService, AuthService, AuthUserService, HonertiaService, RequestService, ResponseFactoryService, } from './services.js';
+/**
+ * Symbol for storing Effect runtime in Hono context.
+ */
+const EFFECT_RUNTIME = Symbol('effectRuntime');
+/**
+ * Create a RequestContext from Hono context.
+ */
+function createRequestContext(c) {
+    return {
+        method: c.req.method,
+        url: c.req.url,
+        headers: c.req.raw.headers,
+        param: (name) => c.req.param(name),
+        params: () => {
+            const params = c.req.param();
+            return typeof params === 'string' ? {} : params;
+        },
+        query: () => c.req.query(),
+        json: () => c.req.json(),
+        parseBody: () => c.req.parseBody(),
+        header: (name) => c.req.header(name),
+    };
+}
+/**
+ * Create a ResponseFactory from Hono context.
+ */
+function createResponseFactory(c) {
+    return {
+        redirect: (url, status = 302) => c.redirect(url, status),
+        json: (data, status = 200) => c.json(data, status),
+        text: (data, status = 200) => c.text(data, status),
+        notFound: () => c.notFound(),
+    };
+}
+/**
+ * Create a HonertiaRenderer from Hono context.
+ */
+function createHonertiaRenderer(c) {
+    const honertia = c.var?.honertia;
+    if (!honertia) {
+        return {
+            render: async () => c.text('Honertia not configured', 500),
+            share: () => { },
+            setErrors: () => { },
+        };
+    }
+    return {
+        render: (component, props) => honertia.render(component, props),
+        share: (key, value) => honertia.share(key, value),
+        setErrors: (errors) => honertia.setErrors(errors),
+    };
+}
+/**
+ * Build the Effect layer from Hono context.
+ */
+export function buildContextLayer(c, config) {
+    const requestLayer = Layer.succeed(RequestService, createRequestContext(c));
+    const responseLayer = Layer.succeed(ResponseFactoryService, createResponseFactory(c));
+    const honertiaLayer = Layer.succeed(HonertiaService, createHonertiaRenderer(c));
+    // Build optional layers
+    const databaseLayer = config?.database
+        ? Layer.succeed(DatabaseService, config.database(c))
+        : Layer.succeed(DatabaseService, c.var?.db);
+    let baseLayer = Layer.mergeAll(requestLayer, responseLayer, honertiaLayer, databaseLayer);
+    if (c.var?.auth) {
+        baseLayer = Layer.merge(baseLayer, Layer.succeed(AuthService, c.var.auth));
+    }
+    if (c.var?.authUser) {
+        baseLayer = Layer.merge(baseLayer, Layer.succeed(AuthUserService, c.var.authUser));
+    }
+    return baseLayer;
+}
+/**
+ * Get the Effect runtime from Hono context.
+ */
+export function getEffectRuntime(c) {
+    return c.var?.[EFFECT_RUNTIME];
+}
+/**
+ * Middleware that sets up the Effect runtime for each request.
+ */
+export function effectBridge(config) {
+    return async (c, next) => {
+        const layer = buildContextLayer(c, config);
+        const runtime = ManagedRuntime.make(layer);
+        // Store runtime in context
+        c.set(EFFECT_RUNTIME, runtime);
+        try {
+            await next();
+        }
+        finally {
+            // Cleanup runtime after request
+            await runtime.dispose();
+        }
+    };
+}

package/dist/effect/errors.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Typed Errors for Honertia Effect
+ *
+ * Using Effect's Data.TaggedError for type-safe error handling.
+ */
+declare const ValidationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ValidationError";
+} & Readonly<A>;
+/**
+ * Validation Error - Field-level validation failures
+ */
+export declare class ValidationError extends ValidationError_base<{
+    readonly errors: Record<string, string>;
+    readonly component?: string;
+}> {
+}
+declare const UnauthorizedError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "UnauthorizedError";
+} & Readonly<A>;
+/**
+ * Unauthorized Error - Authentication/authorization failures
+ */
+export declare class UnauthorizedError extends UnauthorizedError_base<{
+    readonly message: string;
+    readonly redirectTo?: string;
+}> {
+}
+declare const NotFoundError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "NotFoundError";
+} & Readonly<A>;
+/**
+ * Not Found Error - Resource not found
+ */
+export declare class NotFoundError extends NotFoundError_base<{
+    readonly resource: string;
+    readonly id?: string | number;
+}> {
+}
+declare const ForbiddenError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ForbiddenError";
+} & Readonly<A>;
+/**
+ * Forbidden Error - Authenticated but not authorized
+ */
+export declare class ForbiddenError extends ForbiddenError_base<{
+    readonly message: string;
+}> {
+}
+declare const HttpError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "HttpError";
+} & Readonly<A>;
+/**
+ * HTTP Error - Generic HTTP error
+ */
+export declare class HttpError extends HttpError_base<{
+    readonly status: number;
+    readonly message: string;
+    readonly body?: unknown;
+}> {
+}
+declare const Redirect_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Readonly<A> & {
+    readonly _tag: "Redirect";
+};
+/**
+ * Redirect - Not an error, but uses same control flow
+ * This is a tagged class (not error) for redirects
+ */
+export declare class Redirect extends Redirect_base<{
+    readonly url: string;
+    readonly status: 302 | 303;
+}> {
+}
+/**
+ * Union of all application errors
+ */
+export type AppError = ValidationError | UnauthorizedError | NotFoundError | ForbiddenError | HttpError;
+export {};
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/effect/errors.ts"],"names":[],"mappings":"AAAA;;;;GAIG;;;;AAIH;;GAEG;AACH,qBAAa,eAAgB,SAAQ,qBAAoC;IACvE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACvC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAC5B,CAAC;CAAG;;;;AAEL;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,uBAAsC;IAC3E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAC7B,CAAC;CAAG;;;;AAEL;;GAEG;AACH,qBAAa,aAAc,SAAQ,mBAAkC;IACnE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;CAC9B,CAAC;CAAG;;;;AAEL;;GAEG;AACH,qBAAa,cAAe,SAAQ,oBAAmC;IACrE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB,CAAC;CAAG;;;;AAEL;;GAEG;AACH,qBAAa,SAAU,SAAQ,eAA8B;IAC3D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CACxB,CAAC;CAAG;;;;AAEL;;;GAGG;AACH,qBAAa,QAAS,SAAQ,cAA6B;IACzD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,CAAA;CAC3B,CAAC;CAAG;AAEL;;GAEG;AACH,MAAM,MAAM,QAAQ,GAChB,eAAe,GACf,iBAAiB,GACjB,aAAa,GACb,cAAc,GACd,SAAS,CAAA"}

package/dist/effect/errors.js

@@ -0,0 +1,37 @@
+/**
+ * Typed Errors for Honertia Effect
+ *
+ * Using Effect's Data.TaggedError for type-safe error handling.
+ */
+import { Data } from 'effect';
+/**
+ * Validation Error - Field-level validation failures
+ */
+export class ValidationError extends Data.TaggedError('ValidationError') {
+}
+/**
+ * Unauthorized Error - Authentication/authorization failures
+ */
+export class UnauthorizedError extends Data.TaggedError('UnauthorizedError') {
+}
+/**
+ * Not Found Error - Resource not found
+ */
+export class NotFoundError extends Data.TaggedError('NotFoundError') {
+}
+/**
+ * Forbidden Error - Authenticated but not authorized
+ */
+export class ForbiddenError extends Data.TaggedError('ForbiddenError') {
+}
+/**
+ * HTTP Error - Generic HTTP error
+ */
+export class HttpError extends Data.TaggedError('HttpError') {
+}
+/**
+ * Redirect - Not an error, but uses same control flow
+ * This is a tagged class (not error) for redirects
+ */
+export class Redirect extends Data.TaggedClass('Redirect') {
+}

package/dist/effect/handler.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Effect Handler
+ *
+ * Wraps Effect computations into Hono handlers.
+ */
+import { Effect } from 'effect';
+import type { Context as HonoContext, MiddlewareHandler, Env } from 'hono';
+import { Redirect, type AppError } from './errors.js';
+/**
+ * Convert an Effect error to an HTTP response.
+ */
+export declare function errorToResponse<E extends Env>(error: AppError, c: HonoContext<E>): Promise<Response>;
+/**
+ * Wrap an Effect into a Hono handler.
+ */
+export declare function effectHandler<E extends Env, R, Err extends AppError>(effect: Effect.Effect<Response | Redirect, Err, R>): MiddlewareHandler<E>;
+/**
+ * Create a handler from a function that returns an Effect.
+ */
+export declare function effect<E extends Env, R, Err extends AppError>(fn: () => Effect.Effect<Response | Redirect, Err, R>): MiddlewareHandler<E>;
+/**
+ * Create a handler from an Effect directly.
+ */
+export declare const handle: typeof effectHandler;
+//# sourceMappingURL=handler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../../src/effect/handler.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,MAAM,EAA+B,MAAM,QAAQ,CAAA;AAC5D,OAAO,KAAK,EAAE,OAAO,IAAI,WAAW,EAAE,iBAAiB,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAE1E,OAAO,EAML,QAAQ,EACR,KAAK,QAAQ,EACd,MAAM,aAAa,CAAA;AAGpB;;GAEG;AACH,wBAAsB,eAAe,CAAC,CAAC,SAAS,GAAG,EACjD,KAAK,EAAE,QAAQ,EACf,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,GAChB,OAAO,CAAC,QAAQ,CAAC,CA6CnB;AAgBD;;GAEG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,GAAG,EAAE,CAAC,EAAE,GAAG,SAAS,QAAQ,EAClE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,GAAG,QAAQ,EAAE,GAAG,EAAE,CAAC,CAAC,GACjD,iBAAiB,CAAC,CAAC,CAAC,CAoBtB;AAsCD;;GAEG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,GAAG,EAAE,CAAC,EAAE,GAAG,SAAS,QAAQ,EAC3D,EAAE,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,QAAQ,GAAG,QAAQ,EAAE,GAAG,EAAE,CAAC,CAAC,GACnD,iBAAiB,CAAC,CAAC,CAAC,CAEtB;AAED;;GAEG;AACH,eAAO,MAAM,MAAM,sBAAgB,CAAA"}

package/dist/effect/handler.js

@@ -0,0 +1,120 @@
+/**
+ * Effect Handler
+ *
+ * Wraps Effect computations into Hono handlers.
+ */
+import { Effect, Exit, Cause, ManagedRuntime } from 'effect';
+import { getEffectRuntime, buildContextLayer } from './bridge.js';
+import { ValidationError, UnauthorizedError, NotFoundError, ForbiddenError, HttpError, Redirect, } from './errors.js';
+/**
+ * Convert an Effect error to an HTTP response.
+ */
+export async function errorToResponse(error, c) {
+    if (error instanceof ValidationError) {
+        const isInertia = c.req.header('X-Inertia') === 'true';
+        const prefersJson = c.req.header('Accept')?.includes('application/json') ||
+            c.req.header('Content-Type')?.includes('application/json');
+        if (prefersJson && !isInertia) {
+            return c.json({ errors: error.errors }, 422);
+        }
+        // For Inertia requests with a component, render the component with errors
+        if (error.component && c.var?.honertia) {
+            const honertia = c.var.honertia;
+            honertia.setErrors(error.errors);
+            return await honertia.render(error.component);
+        }
+        // Redirect back with errors
+        const referer = c.req.header('Referer') || '/';
+        c.var?.honertia?.setErrors(error.errors);
+        return c.redirect(referer, 303);
+    }
+    if (error instanceof UnauthorizedError) {
+        const isInertia = c.req.header('X-Inertia') === 'true';
+        const redirectTo = error.redirectTo ?? '/login';
+        return c.redirect(redirectTo, isInertia ? 303 : 302);
+    }
+    if (error instanceof ForbiddenError) {
+        return c.json({ message: error.message }, 403);
+    }
+    if (error instanceof NotFoundError) {
+        return c.notFound();
+    }
+    if (error instanceof HttpError) {
+        return c.json({ message: error.message, ...error.body }, error.status);
+    }
+    // Unknown error
+    console.error('Unhandled error:', error);
+    return c.json({ message: 'Internal server error' }, 500);
+}
+/**
+ * Handle a Redirect value (which is not an error).
+ */
+function handleRedirect(redirect, c) {
+    return c.redirect(redirect.url, redirect.status);
+}
+/**
+ * Check if a value is a Redirect.
+ */
+function isRedirect(value) {
+    return value instanceof Redirect;
+}
+/**
+ * Wrap an Effect into a Hono handler.
+ */
+export function effectHandler(effect) {
+    return async (c) => {
+        const runtime = getEffectRuntime(c);
+        if (!runtime) {
+            // No runtime set up, create one for this request
+            const layer = buildContextLayer(c);
+            const tempRuntime = ManagedRuntime.make(layer);
+            try {
+                const exit = await tempRuntime.runPromiseExit(effect);
+                return await handleExit(exit, c);
+            }
+            finally {
+                await tempRuntime.dispose();
+            }
+        }
+        const exit = await runtime.runPromiseExit(effect);
+        return await handleExit(exit, c);
+    };
+}
+/**
+ * Handle an Effect exit value.
+ */
+async function handleExit(exit, c) {
+    if (Exit.isSuccess(exit)) {
+        const value = exit.value;
+        if (isRedirect(value)) {
+            return handleRedirect(value, c);
+        }
+        return value;
+    }
+    // Handle failure
+    const cause = exit.cause;
+    if (Cause.isFailure(cause)) {
+        const error = Cause.failureOption(cause);
+        if (error._tag === 'Some') {
+            return await errorToResponse(error.value, c);
+        }
+    }
+    // Handle defects (unexpected errors)
+    if (Cause.isDie(cause)) {
+        const defect = Cause.dieOption(cause);
+        if (defect._tag === 'Some') {
+            console.error('Effect defect:', defect.value);
+        }
+    }
+    return c.json({ message: 'Internal server error' }, 500);
+}
+/**
+ * Create a handler from a function that returns an Effect.
+ */
+export function effect(fn) {
+    return effectHandler(Effect.suspend(fn));
+}
+/**
+ * Create a handler from an Effect directly.
+ */
+export const handle = effectHandler;

package/dist/effect/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Effect Module Barrel Export
+ *
+ * Re-exports all Effect-related functionality.
+ */
+export { DatabaseService, AuthService, AuthUserService, HonertiaService, RequestService, ResponseFactoryService, type AuthUser, type HonertiaRenderer, type RequestContext, type ResponseFactory, } from './services.js';
+export { ValidationError, UnauthorizedError, NotFoundError, ForbiddenError, HttpError, Redirect, type AppError, } from './errors.js';
+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 { 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, loadUser, type AuthRoutesConfig, } from './auth.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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,QAAQ,EACR,KAAK,gBAAgB,GACtB,MAAM,WAAW,CAAA"}

package/dist/effect/index.js

@@ -0,0 +1,25 @@
+/**
+ * Effect Module Barrel Export
+ *
+ * Re-exports all Effect-related functionality.
+ */
+// Services
+export { DatabaseService, AuthService, AuthUserService, HonertiaService, RequestService, ResponseFactoryService, } from './services.js';
+// Errors
+export { ValidationError, UnauthorizedError, NotFoundError, ForbiddenError, HttpError, Redirect, } from './errors.js';
+// Schema Validators
+export * from './schema.js';
+// Validation Helpers
+export { getValidationData, formatSchemaErrors, validate, validateRequest, } from './validation.js';
+// Bridge
+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';
+// Response Helpers
+export { redirect, render, renderWithErrors, json, text, notFound, forbidden, httpError, prefersJson, jsonOrRender, share, } from './responses.js';
+// Routing
+export { EffectRouteBuilder, effectRoutes, } from './routing.js';
+// Auth
+export { RequireAuthLayer, RequireGuestLayer, isAuthenticated, currentUser, requireAuth, requireGuest, shareAuth, shareAuthMiddleware, effectAuthRoutes, loadUser, } from './auth.js';

package/dist/effect/responses.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Effect Response Helpers
+ *
+ * Utility functions for creating responses within Effect computations.
+ */
+import { Effect } from 'effect';
+import { HonertiaService, ResponseFactoryService, RequestService } from './services.js';
+import { Redirect, NotFoundError, ForbiddenError, HttpError } from './errors.js';
+/**
+ * Create a redirect response.
+ *
+ * @example
+ * return yield* redirect('/projects')
+ * return yield* redirect('/login', 302)
+ */
+export declare const redirect: (url: string, status?: 302 | 303) => Effect.Effect<Redirect, never, never>;
+/**
+ * Render a Honertia component.
+ *
+ * @example
+ * return yield* render('Dashboard/Index', { projects })
+ */
+export declare const render: <T extends object>(component: string, props?: T) => Effect.Effect<Response, never, HonertiaService>;
+/**
+ * Render a Honertia component with validation errors pre-set.
+ *
+ * @example
+ * return yield* renderWithErrors('Auth/Login', { email: 'Invalid' })
+ */
+export declare const renderWithErrors: <T extends object>(component: string, errors: Record<string, string>, props?: T) => Effect.Effect<Response, never, HonertiaService>;
+/**
+ * Return a JSON response.
+ *
+ * @example
+ * return yield* json({ success: true })
+ * return yield* json({ error: 'Not found' }, 404)
+ */
+export declare const json: <T>(data: T, status?: number) => Effect.Effect<Response, never, ResponseFactoryService>;
+/**
+ * Return a text response.
+ */
+export declare const text: (data: string, status?: number) => Effect.Effect<Response, never, ResponseFactoryService>;
+/**
+ * Fail with a not found error.
+ *
+ * @example
+ * if (!project) return yield* notFound('Project')
+ */
+export declare const notFound: (resource: string, id?: string | number) => Effect.Effect<never, NotFoundError, never>;
+/**
+ * Fail with a forbidden error.
+ *
+ * @example
+ * if (!canEdit) return yield* forbidden('You cannot edit this resource')
+ */
+export declare const forbidden: (message?: string) => Effect.Effect<never, ForbiddenError, never>;
+/**
+ * Fail with a custom HTTP error.
+ */
+export declare const httpError: (status: number, message: string, body?: unknown) => Effect.Effect<never, HttpError, never>;
+/**
+ * Check if the request prefers JSON response.
+ */
+export declare const prefersJson: Effect.Effect<boolean, never, RequestService>;
+/**
+ * Return JSON if client prefers it, otherwise render Honertia component.
+ */
+export declare const jsonOrRender: <T extends object>(component: string, data: T) => Effect.Effect<Response, never, RequestService | HonertiaService | ResponseFactoryService>;
+/**
+ * Share data with all Honertia responses.
+ */
+export declare const share: (key: string, value: unknown) => Effect.Effect<void, never, HonertiaService>;
+//# sourceMappingURL=responses.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"responses.d.ts","sourceRoot":"","sources":["../../src/effect/responses.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,EACL,eAAe,EACf,sBAAsB,EACtB,cAAc,EACf,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAEhF;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GAAI,KAAK,MAAM,EAAE,SAAQ,GAAG,GAAG,GAAS,KAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,KAAK,EAAE,KAAK,CACrD,CAAA;AAE/C;;;;;GAKG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,SAAS,MAAM,EACrC,WAAW,MAAM,EACjB,QAAQ,CAAC,KACR,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,KAAK,EAAE,eAAe,CAI7C,CAAA;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,MAAM,EAC/C,WAAW,MAAM,EACjB,QAAQ,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC9B,QAAQ,CAAC,KACR,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,KAAK,EAAE,eAAe,CAK7C,CAAA;AAEJ;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,EAAE,MAAM,CAAC,EAAE,eAAY,KAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,KAAK,EAAE,sBAAsB,CAIjG,CAAA;AAEJ;;GAEG;AACH,eAAO,MAAM,IAAI,GAAI,MAAM,MAAM,EAAE,eAAY,KAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,KAAK,EAAE,sBAAsB,CAInG,CAAA;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GAAI,UAAU,MAAM,EAAE,KAAK,MAAM,GAAG,MAAM,KAAG,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,CACzD,CAAA;AAElD;;;;;GAKG;AACH,eAAO,MAAM,SAAS,GAAI,gBAAqB,KAAG,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,cAAc,EAAE,KAAK,CAC9C,CAAA;AAE9C;;GAEG;AACH,eAAO,MAAM,SAAS,GACpB,QAAQ,MAAM,EACd,SAAS,MAAM,EACf,OAAO,OAAO,KACb,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,CACe,CAAA;AAEvD;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,cAAc,CAWlE,CAAA;AAEJ;;GAEG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,MAAM,EAC3C,WAAW,MAAM,EACjB,MAAM,CAAC,KACN,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,KAAK,EAAE,cAAc,GAAG,eAAe,GAAG,sBAAsB,CAOvF,CAAA;AAEJ;;GAEG;AACH,eAAO,MAAM,KAAK,GAAI,KAAK,MAAM,EAAE,OAAO,OAAO,KAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,eAAe,CAI1F,CAAA"}

package/dist/effect/responses.js

@@ -0,0 +1,104 @@
+/**
+ * Effect Response Helpers
+ *
+ * Utility functions for creating responses within Effect computations.
+ */
+import { Effect } from 'effect';
+import { HonertiaService, ResponseFactoryService, RequestService, } from './services.js';
+import { Redirect, NotFoundError, ForbiddenError, HttpError } from './errors.js';
+/**
+ * Create a redirect response.
+ *
+ * @example
+ * return yield* redirect('/projects')
+ * return yield* redirect('/login', 302)
+ */
+export const redirect = (url, status = 303) => Effect.succeed(new Redirect({ url, status }));
+/**
+ * Render a Honertia component.
+ *
+ * @example
+ * return yield* render('Dashboard/Index', { projects })
+ */
+export const render = (component, props) => Effect.gen(function* () {
+    const honertia = yield* HonertiaService;
+    return yield* Effect.promise(() => honertia.render(component, props));
+});
+/**
+ * Render a Honertia component with validation errors pre-set.
+ *
+ * @example
+ * return yield* renderWithErrors('Auth/Login', { email: 'Invalid' })
+ */
+export const renderWithErrors = (component, errors, props) => Effect.gen(function* () {
+    const honertia = yield* HonertiaService;
+    honertia.setErrors(errors);
+    return yield* Effect.promise(() => honertia.render(component, props));
+});
+/**
+ * Return a JSON response.
+ *
+ * @example
+ * return yield* json({ success: true })
+ * return yield* json({ error: 'Not found' }, 404)
+ */
+export const json = (data, status = 200) => Effect.gen(function* () {
+    const factory = yield* ResponseFactoryService;
+    return factory.json(data, status);
+});
+/**
+ * Return a text response.
+ */
+export const text = (data, status = 200) => Effect.gen(function* () {
+    const factory = yield* ResponseFactoryService;
+    return factory.text(data, status);
+});
+/**
+ * Fail with a not found error.
+ *
+ * @example
+ * if (!project) return yield* notFound('Project')
+ */
+export const notFound = (resource, id) => Effect.fail(new NotFoundError({ resource, id }));
+/**
+ * Fail with a forbidden error.
+ *
+ * @example
+ * if (!canEdit) return yield* forbidden('You cannot edit this resource')
+ */
+export const forbidden = (message = 'Forbidden') => Effect.fail(new ForbiddenError({ message }));
+/**
+ * Fail with a custom HTTP error.
+ */
+export const httpError = (status, message, body) => Effect.fail(new HttpError({ status, message, body }));
+/**
+ * Check if the request prefers JSON response.
+ */
+export const prefersJson = Effect.gen(function* () {
+    const request = yield* RequestService;
+    const isInertia = request.header('X-Inertia') === 'true';
+    if (isInertia)
+        return false;
+    const accept = request.header('Accept') || '';
+    if (accept.includes('application/json'))
+        return true;
+    const contentType = request.header('Content-Type') || '';
+    return contentType.includes('application/json');
+});
+/**
+ * Return JSON if client prefers it, otherwise render Honertia component.
+ */
+export const jsonOrRender = (component, data) => Effect.gen(function* () {
+    const wantsJson = yield* prefersJson;
+    if (wantsJson) {
+        return yield* json(data);
+    }
+    return yield* render(component, data);
+});
+/**
+ * Share data with all Honertia responses.
+ */
+export const share = (key, value) => Effect.gen(function* () {
+    const honertia = yield* HonertiaService;
+    honertia.share(key, value);
+});