glasswork 0.2.0 → 0.2.2

package/dist/authorization/service-proxy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-proxy.js","sourceRoot":"","sources":["../../src/authorization/service-proxy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAGxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,UAAU,iBAAiB,CAC/B,OAAU,EACV,OAAiC;IAEjC,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,GAAG,OAAO,CAAC;IAEtD,OAAO,IAAI,KAAK,CAAC,OAAO,EAAE;QACxB,GAAG,CAAC,MAAM,EAAE,IAAqB;YAC/B,gCAAgC;YAChC,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;gBAC7B,OAAO,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;YACnC,CAAC;YAED,MAAM,cAAc,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;YAEjD,uCAAuC;YACvC,IAAI,OAAO,cAAc,KAAK,UAAU,EAAE,CAAC;gBACzC,OAAO,cAAc,CAAC;YACxB,CAAC;YAED,kDAAkD;YAClD,MAAM,QAAQ,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;YAEhC,4DAA4D;YAC5D,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACd,OAAO,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACrC,CAAC;YAED,2CAA2C;YAC3C,OAAO,UAAyB,GAAG,IAAe;gBAChD,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,GAAG,QAAQ,CAAC;gBAE9D,yCAAyC;gBACzC,MAAM,WAAW,GAAG,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;gBAEjE,iCAAiC;gBACjC,IAAI,CAAC;oBACH,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,cAAc,CACzC,MAAM,EACN,OAAO,CAAC,WAAW,EAAE,WAAW,IAAI,EAAE,CAAC,CACxC,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,IAAI,cAAc,EAAE,CAAC;wBACnB,cAAc,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;wBAC3B,MAAM,KAAK,CAAC,CAAC,mCAAmC;oBAClD,CAAC;oBACD,MAAM,KAAK,CAAC;gBACd,CAAC;gBAED,iDAAiD;gBACjD,OAAO,cAAc,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;YAC5C,CAAC,CAAC;QACJ,CAAC;KACF,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,iBAAiB,CAAC,QAA6B;IAC7D,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,oBAAoB,CAClC,OAAU,EACV,WAAgD;IAEhD,OAAO,CAAmB,WAAmB,EAAE,OAAU,EAAK,EAAE;QAC9D,MAAM,QAAQ,GAAG,WAAW,CAAC,WAAW,CAAC,CAAC;QAE1C,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,wCAAwC;YACxC,OAAO,OAAO,CAAC;QACjB,CAAC;QAED,OAAO,iBAAiB,CAAC,OAAO,EAAE,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,CAAC;IAC3D,CAAC,CAAC;AACJ,CAAC"}

package/dist/authorization/types.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Authorization types for CASL integration.
+ *
+ * This file contains core types for ability configuration and middleware.
+ */
+import type { PureAbility } from '@casl/ability';
+import type { Context } from 'hono';
+/**
+ * Base CASL ability type that applications can extend.
+ * This type is re-exported from @casl/ability to maintain transparency.
+ *
+ * @example
+ * ```typescript
+ * import { createPrismaAbility } from '@casl/prisma';
+ * import { AbilityBuilder } from '@casl/ability';
+ *
+ * type AppAbility = PureAbility<[Action, Subject]>;
+ *
+ * function defineAbility() {
+ *   const { can, build } = new AbilityBuilder<AppAbility>(createPrismaAbility);
+ *   can('read', 'User');
+ *   return build();
+ * }
+ * ```
+ */
+export type BaseAbility = PureAbility<[string, string | object]>;
+/**
+ * Factory function that creates an ability based on user context.
+ * This function receives the full Hono context, allowing access to
+ * user data, request information, etc.
+ *
+ * @example
+ * ```typescript
+ * const abilityFactory: AbilityFactory<AppAbility> = (c) => {
+ *   const user = c.get('user');
+ *   if (user.role === 'admin') {
+ *     return new AdminAbility();
+ *   }
+ *   return new UserAbility(user);
+ * };
+ * ```
+ */
+export type AbilityFactory<T extends BaseAbility = BaseAbility> = (context: Context) => T | Promise<T>;
+/**
+ * Configuration for ability-based authorization in routes.
+ */
+export interface AbilityConfig<T extends BaseAbility = BaseAbility> {
+    /**
+     * Factory function to create the ability from request context.
+     */
+    factory: AbilityFactory<T>;
+    /**
+     * Optional key to store the ability in context variables.
+     * @default 'ability'
+     */
+    contextKey?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/authorization/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/authorization/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAEpC;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,WAAW,GAAG,WAAW,CAAC,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC;AAEjE;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,IAAI,CAChE,OAAO,EAAE,OAAO,KACb,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAEpB;;GAEG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW;IAChE;;OAEG;IACH,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC;IAE3B;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB"}

package/dist/authorization/types.js

@@ -0,0 +1,7 @@
+/**
+ * Authorization types for CASL integration.
+ *
+ * This file contains core types for ability configuration and middleware.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/authorization/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/authorization/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/hooks/authorization-hook.d.ts

@@ -0,0 +1,100 @@
+import type { ServiceHook } from './types.js';
+/**
+ * Authorization metadata for a service method.
+ * Defines what CASL action/subject to check before the method executes.
+ */
+export interface AuthorizationMetadata {
+    /**
+     * CASL action (e.g., 'create', 'read', 'update', 'delete')
+     */
+    action: string;
+    /**
+     * CASL subject type (e.g., 'User', 'Post', 'Session')
+     */
+    subject: string;
+    /**
+     * Optional function to extract subject data from method arguments.
+     * Used for field-level and instance-level authorization.
+     *
+     * @param args - The arguments passed to the service method
+     * @returns The subject data to check against CASL rules
+     *
+     * @example
+     * ```typescript
+     * getSubjectData: (userId, updates) => ({ id: userId, ...updates })
+     * ```
+     */
+    getSubjectData?: (...args: unknown[]) => object | undefined;
+}
+/**
+ * Service hook that performs CASL authorization before method execution.
+ *
+ * This hook checks for `authorize` metadata on service methods and calls
+ * the CASL `authorize()` function before allowing the method to execute.
+ *
+ * **Usage:**
+ * 1. Define authorization metadata for your service methods
+ * 2. Include this hook when wrapping services
+ * 3. Ensure ability middleware is configured in your routes
+ *
+ * @example
+ * ```typescript
+ * import { authorizationHook, defineServiceMetadata } from 'glasswork';
+ *
+ * // Define metadata
+ * export const authServiceMetadata = defineServiceMetadata({
+ *   deleteSession: {
+ *     authorize: {
+ *       action: 'delete',
+ *       subject: 'Session'
+ *     }
+ *   },
+ *   updateUser: {
+ *     authorize: {
+ *       action: 'update',
+ *       subject: 'User',
+ *       getSubjectData: (userId, data) => ({ id: userId, ...data })
+ *     }
+ *   }
+ * });
+ *
+ * // Use in routes
+ * router.delete('/session', async (c) => {
+ *   const services = withServiceHooks(
+ *     { authService },
+ *     {
+ *       hooks: [authorizationHook],
+ *       metadata: authServiceMetadata
+ *     },
+ *     c
+ *   );
+ *
+ *   // This automatically checks authorization before executing
+ *   await services.authService.deleteSession(token);
+ * });
+ * ```
+ */
+export declare const authorizationHook: ServiceHook;
+/**
+ * Helper to define authorization metadata for service methods.
+ * Provides better type inference for the authorize property.
+ *
+ * @param action - CASL action
+ * @param subject - CASL subject type
+ * @param getSubjectData - Optional function to extract subject data
+ * @returns Authorization metadata object
+ *
+ * @example
+ * ```typescript
+ * export const userServiceMetadata = defineServiceMetadata({
+ *   update: {
+ *     authorize: defineAuthorize('update', 'User', (id, data) => ({ id, ...data }))
+ *   },
+ *   delete: {
+ *     authorize: defineAuthorize('delete', 'User', (id) => ({ id }))
+ *   }
+ * });
+ * ```
+ */
+export declare function defineAuthorize(action: string, subject: string, getSubjectData?: (...args: unknown[]) => object | undefined): AuthorizationMetadata;
+//# sourceMappingURL=authorization-hook.d.ts.map

package/dist/hooks/authorization-hook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authorization-hook.d.ts","sourceRoot":"","sources":["../../src/hooks/authorization-hook.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;;;;;;;;;OAWG;IACH,cAAc,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,MAAM,GAAG,SAAS,CAAC;CAC7D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,eAAO,MAAM,iBAAiB,EAAE,WAkB/B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,cAAc,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,MAAM,GAAG,SAAS,GAC1D,qBAAqB,CAMvB"}

package/dist/hooks/authorization-hook.js

@@ -0,0 +1,93 @@
+import { authorize } from '../authorization/route-helpers.js';
+/**
+ * Service hook that performs CASL authorization before method execution.
+ *
+ * This hook checks for `authorize` metadata on service methods and calls
+ * the CASL `authorize()` function before allowing the method to execute.
+ *
+ * **Usage:**
+ * 1. Define authorization metadata for your service methods
+ * 2. Include this hook when wrapping services
+ * 3. Ensure ability middleware is configured in your routes
+ *
+ * @example
+ * ```typescript
+ * import { authorizationHook, defineServiceMetadata } from 'glasswork';
+ *
+ * // Define metadata
+ * export const authServiceMetadata = defineServiceMetadata({
+ *   deleteSession: {
+ *     authorize: {
+ *       action: 'delete',
+ *       subject: 'Session'
+ *     }
+ *   },
+ *   updateUser: {
+ *     authorize: {
+ *       action: 'update',
+ *       subject: 'User',
+ *       getSubjectData: (userId, data) => ({ id: userId, ...data })
+ *     }
+ *   }
+ * });
+ *
+ * // Use in routes
+ * router.delete('/session', async (c) => {
+ *   const services = withServiceHooks(
+ *     { authService },
+ *     {
+ *       hooks: [authorizationHook],
+ *       metadata: authServiceMetadata
+ *     },
+ *     c
+ *   );
+ *
+ *   // This automatically checks authorization before executing
+ *   await services.authService.deleteSession(token);
+ * });
+ * ```
+ */
+export const authorizationHook = {
+    before: async (context, args) => {
+        // Check if this method has authorization metadata
+        const metadata = context.metadata;
+        if (!metadata?.authorize) {
+            // No authorization required for this method
+            return;
+        }
+        const { action, subject, getSubjectData } = metadata.authorize;
+        // Extract subject data if function provided
+        const subjectData = getSubjectData ? getSubjectData(...args) : undefined;
+        // Call CASL authorize - this will throw ForbiddenError if not allowed
+        authorize(context.honoContext, action, subject, subjectData);
+    },
+};
+/**
+ * Helper to define authorization metadata for service methods.
+ * Provides better type inference for the authorize property.
+ *
+ * @param action - CASL action
+ * @param subject - CASL subject type
+ * @param getSubjectData - Optional function to extract subject data
+ * @returns Authorization metadata object
+ *
+ * @example
+ * ```typescript
+ * export const userServiceMetadata = defineServiceMetadata({
+ *   update: {
+ *     authorize: defineAuthorize('update', 'User', (id, data) => ({ id, ...data }))
+ *   },
+ *   delete: {
+ *     authorize: defineAuthorize('delete', 'User', (id) => ({ id }))
+ *   }
+ * });
+ * ```
+ */
+export function defineAuthorize(action, subject, getSubjectData) {
+    return {
+        action,
+        subject,
+        getSubjectData,
+    };
+}
+//# sourceMappingURL=authorization-hook.js.map

package/dist/hooks/authorization-hook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"authorization-hook.js","sourceRoot":"","sources":["../../src/hooks/authorization-hook.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AAiC9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAgB;IAC5C,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE;QAC9B,kDAAkD;QAClD,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAiD,CAAC;QAE3E,IAAI,CAAC,QAAQ,EAAE,SAAS,EAAE,CAAC;YACzB,4CAA4C;YAC5C,OAAO;QACT,CAAC;QAED,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,EAAE,GAAG,QAAQ,CAAC,SAAS,CAAC;QAE/D,4CAA4C;QAC5C,MAAM,WAAW,GAAG,cAAc,CAAC,CAAC,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAEzE,sEAAsE;QACtE,SAAS,CAAC,OAAO,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,CAAC,CAAC;IAC/D,CAAC;CACF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,eAAe,CAC7B,MAAc,EACd,OAAe,EACf,cAA2D;IAE3D,OAAO;QACL,MAAM;QACN,OAAO;QACP,cAAc;KACf,CAAC;AACJ,CAAC"}

package/dist/hooks/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Service hooks system for wrapping service method calls with before/after/error hooks.
+ *
+ * This module provides a flexible hook system that can be used for:
+ * - Authorization (using CASL)
+ * - Audit logging
+ * - Metrics and tracing
+ * - Error handling
+ * - Retry logic
+ * - Timeouts
+ * - Response transformation
+ *
+ * Hooks are transparent - they wrap service methods without modifying the service
+ * implementation, keeping business logic clean and framework-agnostic.
+ *
+ * @module hooks
+ *
+ * @example Basic Usage
+ * ```typescript
+ * import { authorizationHook, defineServiceMetadata } from 'glasswork';
+ *
+ * // Define metadata for service methods
+ * export const authServiceMetadata = defineServiceMetadata({
+ *   deleteSession: {
+ *     authorize: {
+ *       action: 'delete',
+ *       subject: 'Session'
+ *     }
+ *   }
+ * });
+ *
+ * // Configure hooks globally in bootstrap
+ * bootstrap({
+ *   serviceHooks: [authorizationHook],
+ *   serviceMetadata: {
+ *     authService: authServiceMetadata
+ *   }
+ * });
+ *
+ * // In routes, service calls are automatically wrapped
+ * export const authRoutes = createRoutes((router, { authService }) => {
+ *   router.delete('/session', ...route({
+ *     handler: async ({ context }) => {
+ *       // This automatically checks authorization before executing!
+ *       await authService.deleteSession(token);
+ *     }
+ *   }));
+ * });
+ * ```
+ */
+export { type AuthorizationMetadata, authorizationHook, defineAuthorize, } from './authorization-hook.js';
+export { defineServiceMetadata, withServiceHooks, withServiceHooksMany, } from './service-hooks.js';
+export type { ServiceAfterHook, ServiceBeforeHook, ServiceErrorHook, ServiceHook, ServiceHookContext, ServiceHooksConfig, ServiceMethodMetadata, ServicesRegistry, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAGH,OAAO,EACL,KAAK,qBAAqB,EAC1B,iBAAiB,EACjB,eAAe,GAChB,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EACL,qBAAqB,EACrB,gBAAgB,EAChB,oBAAoB,GACrB,MAAM,oBAAoB,CAAC;AAE5B,YAAY,EACV,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,WAAW,EACX,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,EACrB,gBAAgB,GACjB,MAAM,YAAY,CAAC"}

package/dist/hooks/index.js

@@ -0,0 +1,55 @@
+/**
+ * Service hooks system for wrapping service method calls with before/after/error hooks.
+ *
+ * This module provides a flexible hook system that can be used for:
+ * - Authorization (using CASL)
+ * - Audit logging
+ * - Metrics and tracing
+ * - Error handling
+ * - Retry logic
+ * - Timeouts
+ * - Response transformation
+ *
+ * Hooks are transparent - they wrap service methods without modifying the service
+ * implementation, keeping business logic clean and framework-agnostic.
+ *
+ * @module hooks
+ *
+ * @example Basic Usage
+ * ```typescript
+ * import { authorizationHook, defineServiceMetadata } from 'glasswork';
+ *
+ * // Define metadata for service methods
+ * export const authServiceMetadata = defineServiceMetadata({
+ *   deleteSession: {
+ *     authorize: {
+ *       action: 'delete',
+ *       subject: 'Session'
+ *     }
+ *   }
+ * });
+ *
+ * // Configure hooks globally in bootstrap
+ * bootstrap({
+ *   serviceHooks: [authorizationHook],
+ *   serviceMetadata: {
+ *     authService: authServiceMetadata
+ *   }
+ * });
+ *
+ * // In routes, service calls are automatically wrapped
+ * export const authRoutes = createRoutes((router, { authService }) => {
+ *   router.delete('/session', ...route({
+ *     handler: async ({ context }) => {
+ *       // This automatically checks authorization before executing!
+ *       await authService.deleteSession(token);
+ *     }
+ *   }));
+ * });
+ * ```
+ */
+// Built-in hooks
+export { authorizationHook, defineAuthorize, } from './authorization-hook.js';
+// Hook system
+export { defineServiceMetadata, withServiceHooks, withServiceHooksMany, } from './service-hooks.js';
+//# sourceMappingURL=index.js.map

package/dist/hooks/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH,iBAAiB;AACjB,OAAO,EAEL,iBAAiB,EACjB,eAAe,GAChB,MAAM,yBAAyB,CAAC;AAEjC,cAAc;AACd,OAAO,EACL,qBAAqB,EACrB,gBAAgB,EAChB,oBAAoB,GACrB,MAAM,oBAAoB,CAAC"}

package/dist/hooks/service-hooks.d.ts

@@ -0,0 +1,82 @@
+import type { Context } from 'hono';
+import type { ServiceHooksConfig, ServiceMethodMetadata } from './types.js';
+/**
+ * Wraps a service with hooks that run before/after/on-error for method calls.
+ * This creates a transparent proxy that intercepts method calls and runs hooks
+ * while preserving all service functionality.
+ *
+ * **Note:** Hooks only run for method calls, not property access.
+ *
+ * @param service - The service instance to wrap
+ * @param config - Hook configuration
+ * @param honoContext - The current Hono request context
+ * @returns Proxied service with hooks
+ *
+ * @example
+ * ```typescript
+ * const authHook: ServiceHook = {
+ *   before: async (context) => {
+ *     if (context.metadata?.authorize) {
+ *       authorize(context.honoContext, ...);
+ *     }
+ *   }
+ * };
+ *
+ * const wrappedService = withServiceHooks(authService, {
+ *   hooks: [authHook],
+ *   metadata: {
+ *     deleteSession: {
+ *       authorize: { action: 'delete', subject: 'Session' }
+ *     }
+ *   }
+ * }, honoContext);
+ *
+ * // Hooks automatically run when calling methods
+ * await wrappedService.deleteSession(token);
+ * ```
+ */
+export declare function withServiceHooks<T extends object>(service: T, config: ServiceHooksConfig, honoContext: Context): T;
+/**
+ * Wraps multiple services with the same hooks configuration.
+ * Useful when you want to apply the same hooks to all services in a container.
+ *
+ * @param services - Object containing service instances
+ * @param config - Hook configuration (can be a function for per-service config)
+ * @param honoContext - The current Hono request context
+ * @returns Object with all services wrapped with hooks
+ *
+ * @example
+ * ```typescript
+ * const wrappedServices = withServiceHooksMany(
+ *   { authService, userService },
+ *   (serviceName) => ({
+ *     hooks: [authHook, auditHook],
+ *     metadata: serviceMetadataRegistry[serviceName],
+ *     serviceName,
+ *   }),
+ *   honoContext
+ * );
+ * ```
+ */
+export declare function withServiceHooksMany<T extends Record<string, object>>(services: T, config: ServiceHooksConfig | ((serviceName: string, service: unknown) => ServiceHooksConfig), honoContext: Context): T;
+/**
+ * Helper to define service method metadata with better type inference.
+ * This is just an identity function that helps TypeScript understand the structure.
+ *
+ * @param metadata - Service method metadata mapping
+ * @returns The same metadata (identity function)
+ *
+ * @example
+ * ```typescript
+ * export const authServiceMetadata = defineServiceMetadata({
+ *   deleteSession: {
+ *     authorize: { action: 'delete', subject: 'Session' }
+ *   },
+ *   findById: {
+ *     authorize: { action: 'read', subject: 'User' }
+ *   }
+ * });
+ * ```
+ */
+export declare function defineServiceMetadata(metadata: Record<string, ServiceMethodMetadata>): Record<string, ServiceMethodMetadata>;
+//# sourceMappingURL=service-hooks.d.ts.map

package/dist/hooks/service-hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-hooks.d.ts","sourceRoot":"","sources":["../../src/hooks/service-hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,OAAO,KAAK,EAGV,kBAAkB,EAClB,qBAAqB,EACtB,MAAM,YAAY,CAAC;AAkDpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,EAC/C,OAAO,EAAE,CAAC,EACV,MAAM,EAAE,kBAAkB,EAC1B,WAAW,EAAE,OAAO,GACnB,CAAC,CAqCH;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACnE,QAAQ,EAAE,CAAC,EACX,MAAM,EAAE,kBAAkB,GAAG,CAAC,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,kBAAkB,CAAC,EAC5F,WAAW,EAAE,OAAO,GACnB,CAAC,CAcH;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,GAC9C,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAEvC"}

package/dist/hooks/service-hooks.js

@@ -0,0 +1,158 @@
+/**
+ * Execute a method with hooks (before/after/error).
+ * Extracted as a helper to reduce complexity.
+ */
+async function executeWithHooks(hookContext, hooks, 
+// biome-ignore lint/suspicious/noExplicitAny: Function type requires any
+originalMethod, target, args) {
+    try {
+        // Run all before hooks
+        for (const hook of hooks) {
+            if (hook.before) {
+                await hook.before(hookContext, args);
+            }
+        }
+        // Execute original method
+        let result = await originalMethod.apply(target, args);
+        // Run all after hooks (in order)
+        for (const hook of hooks) {
+            if (hook.after) {
+                const hookResult = await hook.after(hookContext, args, result);
+                // If hook returns a value, use it as the new result
+                if (hookResult !== undefined) {
+                    result = hookResult;
+                }
+            }
+        }
+        return result;
+    }
+    catch (error) {
+        // Run all error hooks
+        for (const hook of hooks) {
+            if (hook.onError) {
+                await hook.onError(hookContext, args, error);
+            }
+        }
+        // Re-throw the error after hooks
+        throw error;
+    }
+}
+/**
+ * Wraps a service with hooks that run before/after/on-error for method calls.
+ * This creates a transparent proxy that intercepts method calls and runs hooks
+ * while preserving all service functionality.
+ *
+ * **Note:** Hooks only run for method calls, not property access.
+ *
+ * @param service - The service instance to wrap
+ * @param config - Hook configuration
+ * @param honoContext - The current Hono request context
+ * @returns Proxied service with hooks
+ *
+ * @example
+ * ```typescript
+ * const authHook: ServiceHook = {
+ *   before: async (context) => {
+ *     if (context.metadata?.authorize) {
+ *       authorize(context.honoContext, ...);
+ *     }
+ *   }
+ * };
+ *
+ * const wrappedService = withServiceHooks(authService, {
+ *   hooks: [authHook],
+ *   metadata: {
+ *     deleteSession: {
+ *       authorize: { action: 'delete', subject: 'Session' }
+ *     }
+ *   }
+ * }, honoContext);
+ *
+ * // Hooks automatically run when calling methods
+ * await wrappedService.deleteSession(token);
+ * ```
+ */
+export function withServiceHooks(service, config, honoContext) {
+    const { hooks, metadata = {}, serviceName } = config;
+    // Try to determine service name
+    const inferredServiceName = serviceName || service.constructor?.name || 'UnknownService';
+    return new Proxy(service, {
+        get(target, prop) {
+            // Only intercept string properties (method names)
+            if (typeof prop !== 'string') {
+                return Reflect.get(target, prop);
+            }
+            const originalValue = Reflect.get(target, prop);
+            // If it's not a function, return as-is
+            if (typeof originalValue !== 'function') {
+                return originalValue;
+            }
+            // Get metadata for this method
+            const methodMetadata = metadata[prop];
+            // Return wrapped function with hooks
+            return async function (...args) {
+                const hookContext = {
+                    honoContext,
+                    serviceName: inferredServiceName,
+                    methodName: prop,
+                    metadata: methodMetadata,
+                };
+                // biome-ignore lint/suspicious/noExplicitAny: originalValue is guaranteed to be a function by the check above
+                return executeWithHooks(hookContext, hooks, originalValue, target, args);
+            };
+        },
+    });
+}
+/**
+ * Wraps multiple services with the same hooks configuration.
+ * Useful when you want to apply the same hooks to all services in a container.
+ *
+ * @param services - Object containing service instances
+ * @param config - Hook configuration (can be a function for per-service config)
+ * @param honoContext - The current Hono request context
+ * @returns Object with all services wrapped with hooks
+ *
+ * @example
+ * ```typescript
+ * const wrappedServices = withServiceHooksMany(
+ *   { authService, userService },
+ *   (serviceName) => ({
+ *     hooks: [authHook, auditHook],
+ *     metadata: serviceMetadataRegistry[serviceName],
+ *     serviceName,
+ *   }),
+ *   honoContext
+ * );
+ * ```
+ */
+export function withServiceHooksMany(services, config, honoContext) {
+    const result = {};
+    for (const [serviceName, service] of Object.entries(services)) {
+        const serviceConfig = typeof config === 'function' ? config(serviceName, service) : config;
+        result[serviceName] = withServiceHooks(service, { ...serviceConfig, serviceName }, honoContext);
+    }
+    return result;
+}
+/**
+ * Helper to define service method metadata with better type inference.
+ * This is just an identity function that helps TypeScript understand the structure.
+ *
+ * @param metadata - Service method metadata mapping
+ * @returns The same metadata (identity function)
+ *
+ * @example
+ * ```typescript
+ * export const authServiceMetadata = defineServiceMetadata({
+ *   deleteSession: {
+ *     authorize: { action: 'delete', subject: 'Session' }
+ *   },
+ *   findById: {
+ *     authorize: { action: 'read', subject: 'User' }
+ *   }
+ * });
+ * ```
+ */
+export function defineServiceMetadata(metadata) {
+    return metadata;
+}
+//# sourceMappingURL=service-hooks.js.map

package/dist/hooks/service-hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-hooks.js","sourceRoot":"","sources":["../../src/hooks/service-hooks.ts"],"names":[],"mappings":"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"}