@dismissible/nestjs-dismissible 0.0.2-canary.c91edbc.0 → 0.0.2-canary.d2f56d7.0

package/src/core/hook-runner.service.spec.ts

@@ -2,12 +2,11 @@ import { mock } from 'ts-jest-mocker';
 import { ForbiddenException } from '@nestjs/common';
 import { HookRunner } from './hook-runner.service';
 import { IDismissibleLifecycleHook } from './lifecycle-hook.interface';
-import { BaseMetadata } from '@dismissible/nestjs-dismissible-item';
 import { createTestItem, createTestContext } from '../testing/factories';
 import { IDismissibleLogger } from '@dismissible/nestjs-logger';
 
 describe('HookRunner', () => {
-  let hookRunner: HookRunner<BaseMetadata>;
+  let hookRunner: HookRunner;
   let mockLogger: jest.Mocked<IDismissibleLogger>;
 
   const testUserId = 'test-user-id';
@@ -45,7 +44,7 @@ describe('HookRunner', () => {
     it('should execute hooks in priority order (low to high) for pre-hooks', async () => {
       const executionOrder: number[] = [];
 
-      const hook1: IDismissibleLifecycleHook<BaseMetadata> = {
+      const hook1: IDismissibleLifecycleHook = {
         priority: 10,
         onBeforeRequest: jest.fn(async () => {
           executionOrder.push(10);
@@ -53,7 +52,7 @@ describe('HookRunner', () => {
         }),
       };
 
-      const hook2: IDismissibleLifecycleHook<BaseMetadata> = {
+      const hook2: IDismissibleLifecycleHook = {
         priority: 5,
         onBeforeRequest: jest.fn(async () => {
           executionOrder.push(5);
@@ -61,7 +60,7 @@ describe('HookRunner', () => {
         }),
       };
 
-      const hook3: IDismissibleLifecycleHook<BaseMetadata> = {
+      const hook3: IDismissibleLifecycleHook = {
         priority: 15,
         onBeforeRequest: jest.fn(async () => {
           executionOrder.push(15);
@@ -78,21 +77,21 @@ describe('HookRunner', () => {
     it('should execute hooks in reverse priority order for post-hooks', async () => {
       const executionOrder: number[] = [];
 
-      const hook1: IDismissibleLifecycleHook<BaseMetadata> = {
+      const hook1: IDismissibleLifecycleHook = {
         priority: 10,
         onAfterRequest: jest.fn(async () => {
           executionOrder.push(10);
         }),
       };
 
-      const hook2: IDismissibleLifecycleHook<BaseMetadata> = {
+      const hook2: IDismissibleLifecycleHook = {
         priority: 5,
         onAfterRequest: jest.fn(async () => {
           executionOrder.push(5);
         }),
       };
 
-      const hook3: IDismissibleLifecycleHook<BaseMetadata> = {
+      const hook3: IDismissibleLifecycleHook = {
         priority: 15,
         onAfterRequest: jest.fn(async () => {
           executionOrder.push(15);
@@ -106,7 +105,7 @@ describe('HookRunner', () => {
     });
 
     it('should block operation when pre-hook returns proceed: false', async () => {
-      const blockingHook: IDismissibleLifecycleHook<BaseMetadata> = {
+      const blockingHook: IDismissibleLifecycleHook = {
         onBeforeRequest: jest.fn(async () => ({
           proceed: false,
           reason: 'Rate limit exceeded',
@@ -121,7 +120,7 @@ describe('HookRunner', () => {
     });
 
     it('should apply mutations from pre-hooks', async () => {
-      const mutatingHook: IDismissibleLifecycleHook<BaseMetadata> = {
+      const mutatingHook: IDismissibleLifecycleHook = {
         onBeforeRequest: jest.fn(async () => ({
           proceed: true,
           mutations: {
@@ -139,7 +138,7 @@ describe('HookRunner', () => {
     });
 
     it('should pass mutations through multiple hooks', async () => {
-      const hook1: IDismissibleLifecycleHook<BaseMetadata> = {
+      const hook1: IDismissibleLifecycleHook = {
         priority: 1,
         onBeforeRequest: jest.fn(async (itemId) => ({
           proceed: true,
@@ -147,7 +146,7 @@ describe('HookRunner', () => {
         })),
       };
 
-      const hook2: IDismissibleLifecycleHook<BaseMetadata> = {
+      const hook2: IDismissibleLifecycleHook = {
         priority: 2,
         onBeforeRequest: jest.fn(async (itemId) => ({
           proceed: true,
@@ -160,11 +159,70 @@ describe('HookRunner', () => {
 
       expect(result.id).toBe('original-hook1-hook2');
     });
+
+    it('should apply context mutations from pre-hooks', async () => {
+      const context = createTestContext();
+
+      const mutatingHook: IDismissibleLifecycleHook = {
+        onBeforeRequest: jest.fn(async () => ({
+          proceed: true,
+          mutations: {
+            context: { authorizationHeader: 'Bearer mutated-token' },
+          },
+        })),
+      };
+
+      hookRunner = new HookRunner([mutatingHook], mockLogger);
+      const result = await hookRunner.runPreRequest('test-id', testUserId, context);
+
+      expect(result.context).toEqual({ ...context, authorizationHeader: 'Bearer mutated-token' });
+    });
+
+    it('should ignore context mutation when no context provided', async () => {
+      const mutatingHook: IDismissibleLifecycleHook = {
+        onBeforeRequest: jest.fn(async () => ({
+          proceed: true,
+          mutations: {
+            context: { authorizationHeader: 'Bearer token' },
+          },
+        })),
+      };
+
+      hookRunner = new HookRunner([mutatingHook], mockLogger);
+      const result = await hookRunner.runPreRequest('test-id', testUserId, undefined);
+
+      expect(result.context).toBeUndefined();
+    });
+
+    it('should handle hooks with default priority (undefined)', async () => {
+      const executionOrder: string[] = [];
+
+      const hook1: IDismissibleLifecycleHook = {
+        priority: 5,
+        onBeforeRequest: jest.fn(async () => {
+          executionOrder.push('priority-5');
+          return { proceed: true };
+        }),
+      };
+
+      const hook2: IDismissibleLifecycleHook = {
+        // No priority - defaults to 0
+        onBeforeRequest: jest.fn(async () => {
+          executionOrder.push('priority-default');
+          return { proceed: true };
+        }),
+      };
+
+      hookRunner = new HookRunner([hook1, hook2], mockLogger);
+      await hookRunner.runPreRequest('test-id', testUserId, createTestContext());
+
+      expect(executionOrder).toEqual(['priority-default', 'priority-5']);
+    });
   });
 
   describe('error handling', () => {
     it('should throw error from pre-hook', async () => {
-      const errorHook: IDismissibleLifecycleHook<BaseMetadata> = {
+      const errorHook: IDismissibleLifecycleHook = {
         onBeforeRequest: jest.fn(async () => {
           throw new Error('Hook error');
         }),
@@ -179,8 +237,24 @@ describe('HookRunner', () => {
       expect(mockLogger.error).toHaveBeenCalled();
     });
 
+    it('should throw non-Error from pre-hook', async () => {
+      const errorHook: IDismissibleLifecycleHook = {
+        onBeforeRequest: jest.fn(async () => {
+          throw 'string error';
+        }),
+      };
+
+      hookRunner = new HookRunner([errorHook], mockLogger);
+
+      await expect(
+        hookRunner.runPreRequest('test-id', testUserId, createTestContext()),
+      ).rejects.toBe('string error');
+
+      expect(mockLogger.error).toHaveBeenCalled();
+    });
+
     it('should log but not throw errors from post-hooks', async () => {
-      const errorHook: IDismissibleLifecycleHook<BaseMetadata> = {
+      const errorHook: IDismissibleLifecycleHook = {
         onAfterRequest: jest.fn(async () => {
           throw new Error('Post-hook error');
         }),
@@ -194,6 +268,22 @@ describe('HookRunner', () => {
 
       expect(mockLogger.error).toHaveBeenCalled();
     });
+
+    it('should log but not throw non-Error from post-hooks', async () => {
+      const errorHook: IDismissibleLifecycleHook = {
+        onAfterRequest: jest.fn(async () => {
+          throw 'string post-hook error';
+        }),
+      };
+
+      hookRunner = new HookRunner([errorHook], mockLogger);
+
+      await expect(
+        hookRunner.runPostRequest('test-id', createTestItem(), testUserId, createTestContext()),
+      ).resolves.not.toThrow();
+
+      expect(mockLogger.error).toHaveBeenCalled();
+    });
   });
 
   describe('throwIfBlocked', () => {
@@ -209,6 +299,17 @@ describe('HookRunner', () => {
       ).toThrow(ForbiddenException);
     });
 
+    it('should throw ForbiddenException with default reason when blocked without reason', () => {
+      expect(() =>
+        HookRunner.throwIfBlocked({
+          proceed: false,
+          id: 'test',
+          userId: testUserId,
+          context: createTestContext(),
+        }),
+      ).toThrow('Operation blocked by lifecycle hook');
+    });
+
     it('should not throw when not blocked', () => {
       expect(() =>
         HookRunner.throwIfBlocked({
@@ -226,7 +327,7 @@ describe('HookRunner', () => {
       const item = createTestItem();
       const context = createTestContext();
 
-      const hook: IDismissibleLifecycleHook<BaseMetadata> = {
+      const hook: IDismissibleLifecycleHook = {
         onBeforeGet: jest.fn().mockResolvedValue({ proceed: true }),
       };
 
@@ -240,7 +341,7 @@ describe('HookRunner', () => {
       const item = createTestItem();
       const context = createTestContext();
 
-      const blockingHook: IDismissibleLifecycleHook<BaseMetadata> = {
+      const blockingHook: IDismissibleLifecycleHook = {
         onBeforeGet: jest.fn().mockResolvedValue({
           proceed: false,
           reason: 'Item is in invalid state',
@@ -258,7 +359,7 @@ describe('HookRunner', () => {
       const item = createTestItem();
       const context = createTestContext();
 
-      const hook: IDismissibleLifecycleHook<BaseMetadata> = {
+      const hook: IDismissibleLifecycleHook = {
         onAfterGet: jest.fn(),
       };
 
@@ -272,7 +373,7 @@ describe('HookRunner', () => {
       const item = createTestItem();
       const context = createTestContext();
 
-      const mutatingHook: IDismissibleLifecycleHook<BaseMetadata> = {
+      const mutatingHook: IDismissibleLifecycleHook = {
         onBeforeGet: jest.fn().mockResolvedValue({
           proceed: true,
           mutations: {
@@ -286,10 +387,259 @@ describe('HookRunner', () => {
 
       expect(result.id).toBe('mutated-id');
     });
+
+    it('should apply userId mutation from onBeforeGet hook', async () => {
+      const item = createTestItem();
+      const context = createTestContext();
+
+      const mutatingHook: IDismissibleLifecycleHook = {
+        onBeforeGet: jest.fn().mockResolvedValue({
+          proceed: true,
+          mutations: {
+            userId: 'mutated-user-id',
+          },
+        }),
+      };
+
+      hookRunner = new HookRunner([mutatingHook], mockLogger);
+      const result = await hookRunner.runPreGet('test-id', item, testUserId, context);
+
+      expect(result.userId).toBe('mutated-user-id');
+    });
+
+    it('should apply context mutation from onBeforeGet hook', async () => {
+      const item = createTestItem();
+      const context = createTestContext();
+
+      const mutatingHook: IDismissibleLifecycleHook = {
+        onBeforeGet: jest.fn().mockResolvedValue({
+          proceed: true,
+          mutations: {
+            context: { authorizationHeader: 'Bearer custom-token' },
+          },
+        }),
+      };
+
+      hookRunner = new HookRunner([mutatingHook], mockLogger);
+      const result = await hookRunner.runPreGet('test-id', item, testUserId, context);
+
+      expect(result.context).toEqual({ ...context, authorizationHeader: 'Bearer custom-token' });
+    });
+
+    it('should ignore context mutation when no context provided to onBeforeGet', async () => {
+      const item = createTestItem();
+
+      const mutatingHook: IDismissibleLifecycleHook = {
+        onBeforeGet: jest.fn().mockResolvedValue({
+          proceed: true,
+          mutations: {
+            context: { authorizationHeader: 'Bearer token' },
+          },
+        }),
+      };
+
+      hookRunner = new HookRunner([mutatingHook], mockLogger);
+      const result = await hookRunner.runPreGet('test-id', item, testUserId, undefined);
+
+      expect(result.context).toBeUndefined();
+    });
+
+    it('should throw error from onBeforeGet hook', async () => {
+      const item = createTestItem();
+      const context = createTestContext();
+
+      const errorHook: IDismissibleLifecycleHook = {
+        onBeforeGet: jest.fn().mockRejectedValue(new Error('Get hook error')),
+      };
+
+      hookRunner = new HookRunner([errorHook], mockLogger);
+
+      await expect(hookRunner.runPreGet('test-id', item, testUserId, context)).rejects.toThrow(
+        'Get hook error',
+      );
+
+      expect(mockLogger.error).toHaveBeenCalled();
+    });
+
+    it('should throw non-Error from onBeforeGet hook', async () => {
+      const item = createTestItem();
+      const context = createTestContext();
+
+      const errorHook: IDismissibleLifecycleHook = {
+        onBeforeGet: jest.fn().mockRejectedValue('string error'),
+      };
+
+      hookRunner = new HookRunner([errorHook], mockLogger);
+
+      await expect(hookRunner.runPreGet('test-id', item, testUserId, context)).rejects.toBe(
+        'string error',
+      );
+
+      expect(mockLogger.error).toHaveBeenCalled();
+    });
+  });
+
+  describe('runPreCreate, runPreDismiss, runPreRestore mutations', () => {
+    it('should apply mutations from onBeforeCreate hook', async () => {
+      const context = createTestContext();
+
+      const mutatingHook: IDismissibleLifecycleHook = {
+        onBeforeCreate: jest.fn().mockResolvedValue({
+          proceed: true,
+          mutations: {
+            id: 'mutated-create-id',
+            userId: 'mutated-create-user',
+          },
+        }),
+      };
+
+      hookRunner = new HookRunner([mutatingHook], mockLogger);
+      const result = await hookRunner.runPreCreate('original-id', testUserId, context);
+
+      expect(result.id).toBe('mutated-create-id');
+      expect(result.userId).toBe('mutated-create-user');
+    });
+
+    it('should apply context mutation from onBeforeCreate when context is provided', async () => {
+      const context = createTestContext();
+
+      const mutatingHook: IDismissibleLifecycleHook = {
+        onBeforeCreate: jest.fn().mockResolvedValue({
+          proceed: true,
+          mutations: {
+            context: { authorizationHeader: 'Bearer create-token' },
+          },
+        }),
+      };
+
+      hookRunner = new HookRunner([mutatingHook], mockLogger);
+      const result = await hookRunner.runPreCreate('test-id', testUserId, context);
+
+      expect(result.context).toEqual({ ...context, authorizationHeader: 'Bearer create-token' });
+    });
+
+    it('should block operation when onBeforeDismiss returns proceed: false', async () => {
+      const blockingHook: IDismissibleLifecycleHook = {
+        onBeforeDismiss: jest.fn().mockResolvedValue({
+          proceed: false,
+          reason: 'Cannot dismiss this item',
+        }),
+      };
+
+      hookRunner = new HookRunner([blockingHook], mockLogger);
+      const result = await hookRunner.runPreDismiss('test-id', testUserId, createTestContext());
+
+      expect(result.proceed).toBe(false);
+      expect(result.reason).toBe('Cannot dismiss this item');
+    });
+
+    it('should apply mutations from onBeforeRestore hook', async () => {
+      const context = createTestContext();
+
+      const mutatingHook: IDismissibleLifecycleHook = {
+        onBeforeRestore: jest.fn().mockResolvedValue({
+          proceed: true,
+          mutations: {
+            id: 'mutated-restore-id',
+          },
+        }),
+      };
+
+      hookRunner = new HookRunner([mutatingHook], mockLogger);
+      const result = await hookRunner.runPreRestore('original-id', testUserId, context);
+
+      expect(result.id).toBe('mutated-restore-id');
+    });
+
+    it('should throw error from onBeforeCreate hook', async () => {
+      const errorHook: IDismissibleLifecycleHook = {
+        onBeforeCreate: jest.fn().mockRejectedValue(new Error('Create hook error')),
+      };
+
+      hookRunner = new HookRunner([errorHook], mockLogger);
+
+      await expect(
+        hookRunner.runPreCreate('test-id', testUserId, createTestContext()),
+      ).rejects.toThrow('Create hook error');
+
+      expect(mockLogger.error).toHaveBeenCalled();
+    });
+
+    it('should throw non-Error from onBeforeDismiss hook', async () => {
+      const errorHook: IDismissibleLifecycleHook = {
+        onBeforeDismiss: jest.fn().mockRejectedValue('dismiss string error'),
+      };
+
+      hookRunner = new HookRunner([errorHook], mockLogger);
+
+      await expect(
+        hookRunner.runPreDismiss('test-id', testUserId, createTestContext()),
+      ).rejects.toBe('dismiss string error');
+
+      expect(mockLogger.error).toHaveBeenCalled();
+    });
+  });
+
+  describe('post-hook error handling', () => {
+    it('should log but not throw Error from onAfterCreate', async () => {
+      const errorHook: IDismissibleLifecycleHook = {
+        onAfterCreate: jest.fn().mockRejectedValue(new Error('After create error')),
+      };
+
+      hookRunner = new HookRunner([errorHook], mockLogger);
+
+      await expect(
+        hookRunner.runPostCreate('test-id', createTestItem(), testUserId, createTestContext()),
+      ).resolves.not.toThrow();
+
+      expect(mockLogger.error).toHaveBeenCalled();
+    });
+
+    it('should log but not throw non-Error from onAfterDismiss', async () => {
+      const errorHook: IDismissibleLifecycleHook = {
+        onAfterDismiss: jest.fn().mockRejectedValue('dismiss post error'),
+      };
+
+      hookRunner = new HookRunner([errorHook], mockLogger);
+
+      await expect(
+        hookRunner.runPostDismiss('test-id', createTestItem(), testUserId, createTestContext()),
+      ).resolves.not.toThrow();
+
+      expect(mockLogger.error).toHaveBeenCalled();
+    });
+
+    it('should log but not throw Error from onAfterRestore', async () => {
+      const errorHook: IDismissibleLifecycleHook = {
+        onAfterRestore: jest.fn().mockRejectedValue(new Error('After restore error')),
+      };
+
+      hookRunner = new HookRunner([errorHook], mockLogger);
+
+      await expect(
+        hookRunner.runPostRestore('test-id', createTestItem(), testUserId, createTestContext()),
+      ).resolves.not.toThrow();
+
+      expect(mockLogger.error).toHaveBeenCalled();
+    });
+
+    it('should log but not throw non-Error from onAfterGet', async () => {
+      const errorHook: IDismissibleLifecycleHook = {
+        onAfterGet: jest.fn().mockRejectedValue('get post error'),
+      };
+
+      hookRunner = new HookRunner([errorHook], mockLogger);
+
+      await expect(
+        hookRunner.runPostGet('test-id', createTestItem(), testUserId, createTestContext()),
+      ).resolves.not.toThrow();
+
+      expect(mockLogger.error).toHaveBeenCalled();
+    });
   });
 
   describe('all hook methods', () => {
-    let allMethodsHook: IDismissibleLifecycleHook<BaseMetadata>;
+    let allMethodsHook: IDismissibleLifecycleHook;
 
     beforeEach(() => {
       allMethodsHook = {

package/src/core/hook-runner.service.ts

@@ -5,7 +5,7 @@ import {
   IHookResult,
 } from './lifecycle-hook.interface';
 import { DISMISSIBLE_LOGGER, IDismissibleLogger } from '@dismissible/nestjs-logger';
-import { BaseMetadata, DismissibleItemDto } from '@dismissible/nestjs-dismissible-item';
+import { DismissibleItemDto } from '@dismissible/nestjs-dismissible-item';
 import { IRequestContext } from '../request/request-context.interface';
 
 /**
@@ -32,13 +32,13 @@ export interface IHookRunResult {
  * Service responsible for running lifecycle hooks.
  */
 @Injectable()
-export class HookRunner<TMetadata extends BaseMetadata = BaseMetadata> {
-  private readonly sortedHooks: IDismissibleLifecycleHook<TMetadata>[];
+export class HookRunner {
+  private readonly sortedHooks: IDismissibleLifecycleHook[];
 
   constructor(
     @Optional()
     @Inject(DISMISSIBLE_HOOKS)
-    hooks: IDismissibleLifecycleHook<TMetadata>[] = [],
+    hooks: IDismissibleLifecycleHook[] = [],
     @Inject(DISMISSIBLE_LOGGER)
     private readonly logger: IDismissibleLogger,
   ) {
@@ -68,7 +68,7 @@ export class HookRunner<TMetadata extends BaseMetadata = BaseMetadata> {
    */
   async runPostRequest(
     itemId: string,
-    item: DismissibleItemDto<TMetadata>,
+    item: DismissibleItemDto,
     userId: string,
     context?: IRequestContext,
   ): Promise<void> {
@@ -85,7 +85,7 @@ export class HookRunner<TMetadata extends BaseMetadata = BaseMetadata> {
    */
   async runPreGet(
     itemId: string,
-    item: DismissibleItemDto<TMetadata>,
+    item: DismissibleItemDto,
     userId: string,
     context?: IRequestContext,
   ): Promise<IHookRunResult> {
@@ -97,7 +97,7 @@ export class HookRunner<TMetadata extends BaseMetadata = BaseMetadata> {
    */
   async runPostGet(
     itemId: string,
-    item: DismissibleItemDto<TMetadata>,
+    item: DismissibleItemDto,
     userId: string,
     context?: IRequestContext,
   ): Promise<void> {
@@ -124,7 +124,7 @@ export class HookRunner<TMetadata extends BaseMetadata = BaseMetadata> {
    */
   async runPostCreate(
     itemId: string,
-    item: DismissibleItemDto<TMetadata>,
+    item: DismissibleItemDto,
     userId: string,
     context?: IRequestContext,
   ): Promise<void> {
@@ -151,7 +151,7 @@ export class HookRunner<TMetadata extends BaseMetadata = BaseMetadata> {
    */
   async runPostDismiss(
     itemId: string,
-    item: DismissibleItemDto<TMetadata>,
+    item: DismissibleItemDto,
     userId: string,
     context?: IRequestContext,
   ): Promise<void> {
@@ -178,7 +178,7 @@ export class HookRunner<TMetadata extends BaseMetadata = BaseMetadata> {
    */
   async runPostRestore(
     itemId: string,
-    item: DismissibleItemDto<TMetadata>,
+    item: DismissibleItemDto,
     userId: string,
     context?: IRequestContext,
   ): Promise<void> {
@@ -189,7 +189,7 @@ export class HookRunner<TMetadata extends BaseMetadata = BaseMetadata> {
    * Internal method to run pre-hooks.
    */
   private async runPreHooks(
-    hookName: keyof IDismissibleLifecycleHook<TMetadata>,
+    hookName: keyof IDismissibleLifecycleHook,
     itemId: string,
     userId: string,
     context?: IRequestContext,
@@ -266,9 +266,9 @@ export class HookRunner<TMetadata extends BaseMetadata = BaseMetadata> {
    * Unlike standard pre-hooks, these receive the item for inspection/access control.
    */
   private async runPreHooksWithItem(
-    hookName: keyof IDismissibleLifecycleHook<TMetadata>,
+    hookName: keyof IDismissibleLifecycleHook,
     itemId: string,
-    item: DismissibleItemDto<TMetadata>,
+    item: DismissibleItemDto,
     userId: string,
     context?: IRequestContext,
   ): Promise<IHookRunResult> {
@@ -280,7 +280,7 @@ export class HookRunner<TMetadata extends BaseMetadata = BaseMetadata> {
       const hookFn = hook[hookName] as
         | ((
             itemId: string,
-            item: DismissibleItemDto<TMetadata>,
+            item: DismissibleItemDto,
             userId: string,
             context?: IRequestContext,
           ) => Promise<IHookResult> | IHookResult)
@@ -345,9 +345,9 @@ export class HookRunner<TMetadata extends BaseMetadata = BaseMetadata> {
    * Post-hooks run in reverse priority order.
    */
   private async runPostHooks(
-    hookName: keyof IDismissibleLifecycleHook<TMetadata>,
+    hookName: keyof IDismissibleLifecycleHook,
     itemId: string,
-    item: DismissibleItemDto<TMetadata>,
+    item: DismissibleItemDto,
     userId: string,
     context?: IRequestContext,
   ): Promise<void> {
@@ -358,7 +358,7 @@ export class HookRunner<TMetadata extends BaseMetadata = BaseMetadata> {
       const hookFn = hook[hookName] as
         | ((
             itemId: string,
-            item: DismissibleItemDto<TMetadata>,
+            item: DismissibleItemDto,
             userId: string,
             context?: IRequestContext,
           ) => Promise<void> | void)

package/src/core/index.ts

@@ -3,4 +3,3 @@ export * from './service-responses.interface';
 export * from './dismissible-core.service';
 export * from './hook-runner.service';
 export * from './dismissible.service';
-export * from './create-options';