patch(refactor): octo hook names simplified.

Author: rash805115

packages/octo/src/decorators/enable-hook.decorator.ts

@@ -1,7 +1,7 @@
 import { AHook } from '../functions/hook/hook.abstract.js';
 import { Container } from './container.js';
 
-type Hook = 'PostModelActionHandleHook' | 'PreCommitHandleHook';
+type Hook = 'PostModelActionHook' | 'PreCommitHook';
 
 export function EnableHook(hook: Hook): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void {
   return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {

packages/octo/src/decorators/module.decorator.ts

@@ -1,6 +1,6 @@
 import { Constructable } from '../app.type.js';
-import { PostModelActionCallback, PostModelActionHandleHook } from '../functions/hook/post-model-action-handle.hook.js';
-import { PreCommitCallback, PreCommitHandleHook } from '../functions/hook/pre-commit-handle.hook.js';
+import { PostModelActionCallback, PostModelActionHook } from '../functions/hook/post-model-action.hook.js';
+import { PreCommitCallback, PreCommitHook } from '../functions/hook/pre-commit.hook.js';
 import { Container } from './container.js';
 
 export function Module({
@@ -14,7 +14,7 @@ export function Module({
 }): (constructor: any) => void {
   return function (constructor: any) {
     if (postModelActionHandles.length > 0) {
-      Container.get(PostModelActionHandleHook)
+      Container.get(PostModelActionHook)
         .then((aHook) => {
           aHook.register(constructor.name, { imports, postModelActionHandles });
         })
@@ -24,7 +24,7 @@ export function Module({
     }
 
     if (preCommitHandles.length > 0) {
-      Container.get(PreCommitHandleHook)
+      Container.get(PreCommitHook)
         .then((aHook) => {
           aHook.register(constructor.name, { imports, preCommitHandles });
         })

packages/octo/src/functions/hook/post-model-action-handle.hook.ts renamed to packages/octo/src/functions/hook/post-model-action.hook.ts

@@ -5,7 +5,7 @@ import { AHook } from './hook.abstract.js';
 
 export type PostModelActionCallback = (output: ActionOutputs) => Promise<ActionOutputs>;
 
-export class PostModelActionHandleHook extends AHook {
+export class PostModelActionHook extends AHook {
   private readonly callbacks: { [key: string]: PostModelActionCallback[] } = {};
 
   private isInstanceOfModelAction(instance: any): instance is IModelAction {
@@ -25,13 +25,13 @@ export class PostModelActionHandleHook extends AHook {
 
   override registrar(constructor: Constructable<unknown>, propertyKey: string, descriptor: PropertyDescriptor): void {
     if (!this.isInstanceOfModelAction(constructor.prototype)) {
-      throw new Error('PostModelActionHandleHook can only be used with ModelAction!');
+      throw new Error('PostModelActionHook can only be used with ModelAction!');
     }
 
     const originalMethod = descriptor.value;
     const self = this; // eslint-disable-line @typescript-eslint/no-this-alias
 
-    // `self` here references PostModelActionHandleHook, vs `this` references the original method.
+    // `self` here references this class, vs `this` references the original method.
     descriptor.value = async function (...args: any[]): Promise<ActionOutputs> {
       let output: ActionOutputs = await originalMethod!.apply(this, args);
       for (const callback of self.callbacks[constructor.name] || []) {
@@ -42,13 +42,13 @@ export class PostModelActionHandleHook extends AHook {
   }
 }
 
-@Factory<PostModelActionHandleHook>(PostModelActionHandleHook)
-export class PostModelActionHandleHookFactory {
-  private static instance: PostModelActionHandleHook;
+@Factory<PostModelActionHook>(PostModelActionHook)
+export class PostModelActionHookFactory {
+  private static instance: PostModelActionHook;
 
-  static async create(): Promise<PostModelActionHandleHook> {
+  static async create(): Promise<PostModelActionHook> {
     if (!this.instance) {
-      this.instance = new PostModelActionHandleHook();
+      this.instance = new PostModelActionHook();
     }
     return this.instance;
   }

packages/octo/src/functions/hook/pre-commit-handle.hook.ts renamed to packages/octo/src/functions/hook/pre-commit.hook.ts

@@ -4,7 +4,7 @@ import { AHook } from './hook.abstract.js';
 
 export type PreCommitCallback = (...args: any[]) => Promise<void>;
 
-export class PreCommitHandleHook extends AHook {
+export class PreCommitHook extends AHook {
   private readonly callbacks: PreCommitCallback[] = [];
 
   override generateCallbacks(): void {
@@ -19,7 +19,7 @@ export class PreCommitHandleHook extends AHook {
     const originalMethod = descriptor.value;
     const self = this; // eslint-disable-line @typescript-eslint/no-this-alias
 
-    // `self` here references PreCommitHandleHook, vs `this` references the original method.
+    // `self` here references this class, vs `this` references the original method.
     descriptor.value = async function (...args: any[]): Promise<any> {
       for (const callback of self.callbacks) {
         await callback.apply(this, args);
@@ -30,13 +30,13 @@ export class PreCommitHandleHook extends AHook {
   }
 }
 
-@Factory<PreCommitHandleHook>(PreCommitHandleHook)
-export class PreCommitHandleHookFactory {
-  private static instance: PreCommitHandleHook;
+@Factory<PreCommitHook>(PreCommitHook)
+export class PreCommitHookFactory {
+  private static instance: PreCommitHook;
 
-  static async create(): Promise<PreCommitHandleHook> {
+  static async create(): Promise<PreCommitHook> {
     if (!this.instance) {
-      this.instance = new PreCommitHandleHook();
+      this.instance = new PreCommitHook();
     }
     return this.instance;
   }