glasswork 0.9.2 → 0.11.0

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"}

package/dist/hooks/service-hooks.js

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

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

package/dist/hooks/types.d.ts

@@ -1,151 +0,0 @@
-import type { Context } from 'hono';
-/**
- * Context passed to service hooks containing the current Hono request context
- * and any additional metadata about the service call.
- */
-export interface ServiceHookContext {
-    /**
-     * The Hono request context, providing access to request data,
-     * response helpers, and context variables (like user, ability, etc.)
-     */
-    honoContext: Context;
-    /**
-     * The name of the service being called (e.g., 'authService', 'userService')
-     */
-    serviceName: string;
-    /**
-     * The name of the method being called (e.g., 'deleteSession', 'findById')
-     */
-    methodName: string;
-    /**
-     * Optional metadata associated with this service method.
-     * Can be used to pass configuration like authorization rules, audit info, etc.
-     */
-    metadata?: unknown;
-}
-/**
- * Hook function that runs before a service method is executed.
- * Can be used for authorization, validation, logging, etc.
- *
- * @param context - Hook context with Hono context and service info
- * @param args - Arguments being passed to the service method
- * @throws Error to prevent the service method from executing
- *
- * @example
- * ```typescript
- * const authorizationHook: ServiceBeforeHook = async (context, args) => {
- *   const { honoContext, metadata } = context;
- *   if (metadata?.authorize) {
- *     authorize(honoContext, metadata.authorize.action, metadata.authorize.subject);
- *   }
- * };
- * ```
- */
-export type ServiceBeforeHook = (context: ServiceHookContext, args: unknown[]) => Promise<void> | void;
-/**
- * Hook function that runs after a service method successfully executes.
- * Can be used for audit logging, metrics, response transformation, etc.
- *
- * @param context - Hook context with Hono context and service info
- * @param args - Arguments that were passed to the service method
- * @param result - The result returned by the service method
- * @returns Optionally return a transformed result
- *
- * @example
- * ```typescript
- * const auditHook: ServiceAfterHook = async (context, args, result) => {
- *   await auditLog.create({
- *     service: context.serviceName,
- *     method: context.methodName,
- *     args,
- *     timestamp: new Date(),
- *   });
- * };
- * ```
- */
-export type ServiceAfterHook = (context: ServiceHookContext, args: unknown[], result: unknown) => Promise<unknown | undefined> | unknown | undefined;
-/**
- * Hook function that runs when a service method throws an error.
- * Can be used for error logging, error transformation, retries, etc.
- *
- * @param context - Hook context with Hono context and service info
- * @param args - Arguments that were passed to the service method
- * @param error - The error that was thrown
- * @throws Error to propagate or throw a different error
- *
- * @example
- * ```typescript
- * const errorLoggingHook: ServiceErrorHook = async (context, args, error) => {
- *   logger.error('Service error', {
- *     service: context.serviceName,
- *     method: context.methodName,
- *     error,
- *   });
- *   // Re-throw to propagate
- *   throw error;
- * };
- * ```
- */
-export type ServiceErrorHook = (context: ServiceHookContext, args: unknown[], error: unknown) => undefined | never | Promise<undefined | never>;
-/**
- * A service hook that can define before, after, and error handlers.
- */
-export interface ServiceHook {
-    /**
-     * Optional hook that runs before the service method executes.
-     */
-    before?: ServiceBeforeHook;
-    /**
-     * Optional hook that runs after the service method successfully executes.
-     */
-    after?: ServiceAfterHook;
-    /**
-     * Optional hook that runs when the service method throws an error.
-     */
-    onError?: ServiceErrorHook;
-}
-/**
- * Metadata that can be attached to service methods to configure hook behavior.
- */
-export type ServiceMethodMetadata = Record<string, unknown>;
-/**
- * Configuration for applying hooks to a service.
- */
-export interface ServiceHooksConfig {
-    /**
-     * Array of hooks to apply to the service.
-     * Hooks run in the order they're defined.
-     */
-    hooks: ServiceHook[];
-    /**
-     * Optional metadata for service methods.
-     * Keys are method names, values are metadata objects.
-     *
-     * @example
-     * ```typescript
-     * {
-     *   deleteSession: {
-     *     authorize: { action: 'delete', subject: 'Session' }
-     *   },
-     *   findById: {
-     *     authorize: { action: 'read', subject: 'User' },
-     *     cache: { ttl: 300 }
-     *   }
-     * }
-     * ```
-     */
-    metadata?: Record<string, ServiceMethodMetadata>;
-    /**
-     * Optional service name for better debugging.
-     * If not provided, will try to infer from the service constructor name.
-     */
-    serviceName?: string;
-}
-/**
- * Services registry that maps service names to their wrapped instances.
- * This is used internally by the route context to provide hooked services.
- */
-export type ServicesRegistry<T = unknown> = {
-    [K in keyof T]: T[K];
-};
-//# sourceMappingURL=types.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/hooks/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAEpC;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,WAAW,EAAE,OAAO,CAAC;IAErB;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAC9B,OAAO,EAAE,kBAAkB,EAC3B,IAAI,EAAE,OAAO,EAAE,KACZ,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAE1B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAC7B,OAAO,EAAE,kBAAkB,EAC3B,IAAI,EAAE,OAAO,EAAE,EACf,MAAM,EAAE,OAAO,KACZ,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,GAAG,OAAO,GAAG,SAAS,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAC7B,OAAO,EAAE,kBAAkB,EAC3B,IAAI,EAAE,OAAO,EAAE,EACf,KAAK,EAAE,OAAO,KACX,SAAS,GAAG,KAAK,GAAG,OAAO,CAAC,SAAS,GAAG,KAAK,CAAC,CAAC;AAEpD;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAE3B;;OAEG;IACH,KAAK,CAAC,EAAE,gBAAgB,CAAC;IAEzB;;OAEG;IACH,OAAO,CAAC,EAAE,gBAAgB,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE5D;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,KAAK,EAAE,WAAW,EAAE,CAAC;IAErB;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC;IAEjD;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;GAGG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,GAAG,OAAO,IAAI;KACzC,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CACrB,CAAC"}

package/dist/openapi/hooks.d.ts

@@ -1,14 +0,0 @@
-import type { OpenAPIResponseHook } from '../core/types.js';
-/**
- * Create a hook that adds CORS headers to responses
- */
-export declare function createCorsHeadersHook(enabled: boolean): OpenAPIResponseHook;
-/**
- * Create a hook that adds rate limiting headers to responses
- */
-export declare function createRateLimitHeadersHook(enabled: boolean): OpenAPIResponseHook;
-/**
- * Create a hook that adds pagination headers to 200 responses
- */
-export declare function createPaginationHeadersHook(): OpenAPIResponseHook;
-//# sourceMappingURL=hooks.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/openapi/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAE5D;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,mBAAmB,CAc3E;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,OAAO,GAAG,mBAAmB,CAgChF;AAED;;GAEG;AACH,wBAAgB,2BAA2B,IAAI,mBAAmB,CA4BjE"}