glasswork 0.6.0 → 0.6.2

package/dist/authorization/service-proxy.d.ts

@@ -1,59 +0,0 @@
-import type { AuthorizedServiceOptions, BaseAbility, ServiceAuthMetadata } from './types.js';
-/**
- * Creates a transparent proxy around a service that automatically
- * checks CASL permissions before executing methods.
- *
- * **⚠️ DEPRECATED: Use the hooks system instead!**
- *
- * This function is deprecated in favor of the more flexible hooks system.
- * Instead of manually wrapping services, configure authorization globally:
- *
- * ```typescript
- * // NEW APPROACH (Recommended):
- * import { authorizationHook, defineServiceMetadata, defineAuthorize } from 'glasswork';
- *
- * const authServiceMeta = defineServiceMetadata({
- *   deleteSession: {
- *     authorize: defineAuthorize('delete', 'Session')
- *   }
- * });
- *
- * bootstrap(AppModule, {
- *   serviceHooks: [authorizationHook],
- *   serviceMetadata: { authService: authServiceMeta }
- * });
- *
- * // In routes - services are automatically authorized!
- * await services.authService.deleteSession(token);
- * ```
- *
- * @deprecated Use hooks system with authorizationHook instead
- * @see {@link https://github.com/rolandboon/glasswork/blob/main/HOOKS_SYSTEM.md}
- *
- * @param service - The service instance to wrap
- * @param options - Authorization configuration
- * @returns Proxied service with automatic authorization
- */
-export declare function withAuthorization<T extends object>(service: T, options: AuthorizedServiceOptions): T;
-/**
- * Helper to define service authorization metadata.
- *
- * **⚠️ DEPRECATED: Use `defineServiceMetadata` and `defineAuthorize` from hooks system instead!**
- *
- * @deprecated Use `defineServiceMetadata` with `defineAuthorize` from hooks module
- * @param metadata - Service authorization metadata
- * @returns The same metadata (identity function)
- */
-export declare function defineServiceAuth(metadata: ServiceAuthMetadata): ServiceAuthMetadata;
-/**
- * Creates a factory function that wraps services with authorization.
- *
- * **⚠️ DEPRECATED: Use hooks system configured in bootstrap instead!**
- *
- * @deprecated Configure authorization globally with serviceHooks in bootstrap
- * @param ability - The CASL ability to use
- * @param metadataMap - Map of service names to their authorization metadata
- * @returns Function that wraps services with authorization
- */
-export declare function createServiceWrapper<T extends BaseAbility = BaseAbility>(ability: T, metadataMap: Record<string, ServiceAuthMetadata>): <S extends object>(serviceName: string, service: S) => S;
-//# sourceMappingURL=service-proxy.d.ts.map

package/dist/authorization/service-proxy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"service-proxy.d.ts","sourceRoot":"","sources":["../../src/authorization/service-proxy.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,wBAAwB,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAE7F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,MAAM,EAChD,OAAO,EAAE,CAAC,EACV,OAAO,EAAE,wBAAwB,GAChC,CAAC,CAmDH;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,mBAAmB,GAAG,mBAAmB,CAEpF;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,EACtE,OAAO,EAAE,CAAC,EACV,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,GAC/C,CAAC,CAAC,SAAS,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,KAAK,CAAC,CAW1D"}

package/dist/authorization/service-proxy.js

@@ -1,110 +0,0 @@
-import { ForbiddenError, subject } from '@casl/ability';
-/**
- * Creates a transparent proxy around a service that automatically
- * checks CASL permissions before executing methods.
- *
- * **⚠️ DEPRECATED: Use the hooks system instead!**
- *
- * This function is deprecated in favor of the more flexible hooks system.
- * Instead of manually wrapping services, configure authorization globally:
- *
- * ```typescript
- * // NEW APPROACH (Recommended):
- * import { authorizationHook, defineServiceMetadata, defineAuthorize } from 'glasswork';
- *
- * const authServiceMeta = defineServiceMetadata({
- *   deleteSession: {
- *     authorize: defineAuthorize('delete', 'Session')
- *   }
- * });
- *
- * bootstrap(AppModule, {
- *   serviceHooks: [authorizationHook],
- *   serviceMetadata: { authService: authServiceMeta }
- * });
- *
- * // In routes - services are automatically authorized!
- * await services.authService.deleteSession(token);
- * ```
- *
- * @deprecated Use hooks system with authorizationHook instead
- * @see {@link https://github.com/rolandboon/glasswork/blob/main/HOOKS_SYSTEM.md}
- *
- * @param service - The service instance to wrap
- * @param options - Authorization configuration
- * @returns Proxied service with automatic authorization
- */
-export function withAuthorization(service, options) {
-    const { ability, metadata, onUnauthorized } = options;
-    return new Proxy(service, {
-        get(target, prop) {
-            // Only intercept function calls
-            if (typeof prop !== 'string') {
-                return Reflect.get(target, prop);
-            }
-            const originalMethod = Reflect.get(target, prop);
-            // If it's not a function, return as-is
-            if (typeof originalMethod !== 'function') {
-                return originalMethod;
-            }
-            // Check if this method has authorization metadata
-            const authMeta = metadata[prop];
-            // If no metadata, return original method (no authorization)
-            if (!authMeta) {
-                return originalMethod.bind(target);
-            }
-            // Return wrapped method with authorization
-            return function (...args) {
-                const { action, subject: subjectType, getSubject } = authMeta;
-                // Get subject data if extractor provided
-                const subjectData = getSubject ? getSubject(...args) : undefined;
-                // Check authorization using CASL
-                try {
-                    ForbiddenError.from(ability).throwUnlessCan(action, subject(subjectType, subjectData || {}));
-                }
-                catch (error) {
-                    if (onUnauthorized) {
-                        onUnauthorized(prop, args);
-                        throw error; // Still throw after custom handler
-                    }
-                    throw error;
-                }
-                // Authorization passed - execute original method
-                return originalMethod.apply(target, args);
-            };
-        },
-    });
-}
-/**
- * Helper to define service authorization metadata.
- *
- * **⚠️ DEPRECATED: Use `defineServiceMetadata` and `defineAuthorize` from hooks system instead!**
- *
- * @deprecated Use `defineServiceMetadata` with `defineAuthorize` from hooks module
- * @param metadata - Service authorization metadata
- * @returns The same metadata (identity function)
- */
-export function defineServiceAuth(metadata) {
-    return metadata;
-}
-/**
- * Creates a factory function that wraps services with authorization.
- *
- * **⚠️ DEPRECATED: Use hooks system configured in bootstrap instead!**
- *
- * @deprecated Configure authorization globally with serviceHooks in bootstrap
- * @param ability - The CASL ability to use
- * @param metadataMap - Map of service names to their authorization metadata
- * @returns Function that wraps services with authorization
- */
-export function createServiceWrapper(ability, metadataMap) {
-    return (serviceName, service) => {
-        const metadata = metadataMap[serviceName];
-        if (!metadata) {
-            // No metadata, return unwrapped service
-            return service;
-        }
-        return withAuthorization(service, { ability, metadata });
-    };
-}
-//# sourceMappingURL=service-proxy.js.map

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

@@ -1 +0,0 @@
-{"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

@@ -1,58 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,7 +0,0 @@
-/**
- * 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

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

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

@@ -1,100 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,93 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,54 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,55 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,82 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}