@bluelibs/runner 1.0.0 → 1.2.0

package/src/__tests__/run.test.ts

@@ -5,6 +5,7 @@ import {
   defineMiddleware,
 } from "../define";
 import { run } from "../run";
+import { globalResources } from "../globalResources";
 
 describe("run", () => {
   // Tasks
@@ -603,7 +604,6 @@ describe("run", () => {
       dependencies: () => ({ middle }),
       register: () => [middle, testTask],
       async init(_, { middle }) {
-        console.log(middle.toString());
         expect(await middle()).toBe("middle");
       },
     });
@@ -611,4 +611,31 @@ describe("run", () => {
     await run(app);
     expect(mockFn).toHaveBeenCalled();
   });
+
+  describe("disposal", () => {
+    it("should be able to dispose of a resource", async () => {
+      const disposeFn = jest.fn();
+      const testResource = defineResource({
+        id: "test.resource",
+        dispose: disposeFn,
+        init: async () => "Resource Value",
+      });
+
+      const app = defineResource({
+        id: "app",
+        register: [testResource],
+        dependencies: { testResource, store: globalResources.store },
+        async init(_, { testResource, store }) {
+          expect(testResource).toBe("Resource Value");
+
+          return {
+            dispose: () => store.dispose(),
+          };
+        },
+      });
+
+      const result = await run(app);
+      await result.dispose();
+    });
+  });
 });

package/src/define.ts

@@ -10,6 +10,8 @@ import {
   DependencyMapType,
   DependencyValuesType,
   IMiddleware,
+  IHookDefinition,
+  IEvent,
 } from "./defs";
 import { Errors } from "./errors";
 
@@ -21,14 +23,6 @@ export function defineTask<
 >(
   config: ITaskDefinition<Input, Output, Deps, Test>
 ): ITask<Input, Output, Deps, Test> {
-  const autorun: any = {};
-  // if (config.autorun) {
-  //   if (config.autorun.on) {
-  //     autorun.on = Array.isArray(config.autorun.on);
-  //     autorun.schedule = config.autorun.schedule;
-  //   }
-  // }
-
   return {
     [symbols.task]: true,
     id: config.id,
@@ -63,7 +57,9 @@ export function defineResource<
     id: constConfig.id,
     dependencies: constConfig.dependencies,
     hooks: constConfig.hooks || [],
+    dispose: constConfig.dispose,
     register: constConfig.register || [],
+    overrides: constConfig.overrides || [],
     init: constConfig.init,
     with: function (config: TConfig) {
       return {

package/src/defs.ts

@@ -21,7 +21,7 @@ export interface IMiddlewareMeta extends IMeta {}
 // DependencyMap types
 export type DependencyMapType = Record<
   string,
-  ITask | IResource | IEventDefinition
+  ITask | IResource | IEventDefinition | IResourceWithConfig<any, any>
 >;
 
 export type DependencyValueType<T> = T extends ITask<
@@ -132,7 +132,21 @@ export interface IResourceDefinintion<
     config: TConfig,
     dependencies: DependencyValuesType<TDependencies>
   ) => Promise<TValue>;
+  /**
+   * Clean-up function for the resource. This is called when the resource is no longer needed.
+   *
+   * @param value The value of the resource
+   * @param config The configuration it received
+   * @param dependencies The dependencies it needed
+   * @returns
+   */
+  dispose?: (
+    value: TValue,
+    config: TConfig,
+    dependencies: DependencyValuesType<TDependencies>
+  ) => Promise<TValue>;
   meta?: IResourceMeta;
+  overrides?: Array<IResource | ITask | IMiddleware | IResourceWithConfig>;
 }
 
 export interface IResource<
@@ -155,6 +169,8 @@ export interface IResource<
   hooks:
     | IHookDefinition<TDependencies>[]
     | ((config: TConfig) => IHookDefinition<TDependencies>[]);
+
+  overrides: Array<IResource | ITask | IMiddleware | IResourceWithConfig>;
 }
 
 export interface IResourceWithConfig<
@@ -212,10 +228,10 @@ export interface IMiddlewareExecutionInput {
   next: (input?: any) => Promise<any>;
 }
 
-export interface IHookDefinition<D extends DependencyMapType = {}> {
-  event: IEventDefinition;
+export interface IHookDefinition<D extends DependencyMapType = {}, T = any> {
+  event: IEventDefinition<T>;
   run: (
-    event: IEvent,
+    event: IEvent<T>,
     dependencies: DependencyValuesType<D>
   ) => Promise<void> | void;
 }

package/src/errors.ts

@@ -19,4 +19,10 @@ export const Errors = {
 
   middlewareAlreadyGlobal: (id: string) =>
     new Error("Cannot call global on a global middleware: " + id),
+
+  locked: (what: string) =>
+    new Error(`Cannot modify the ${what} when it is locked.`),
+
+  storeAlreadyInitialized: () =>
+    new Error("Store already initialized. Cannot reinitialize."),
 };

package/src/globalEvents.ts

@@ -1,5 +1,6 @@
 import { defineEvent } from "./define";
 import { ITask, IResource } from "./defs";
+import { ILog } from "./models/Logger";
 
 export const globalEvents = {
   beforeInit: defineEvent({
@@ -8,6 +9,9 @@ export const globalEvents = {
   afterInit: defineEvent({
     id: "global.afterInit",
   }),
+  log: defineEvent<ILog>({
+    id: "global.log",
+  }),
   tasks: {
     beforeRun: defineEvent<{
       task: ITask<any, any, any>;

package/src/globalResources.ts

@@ -1,19 +1,26 @@
 import { defineResource } from "./define";
-import { EventManager } from "./EventManager";
-import { Store } from "./Store";
-import { TaskRunner } from "./TaskRunner";
+import { EventManager } from "./models/EventManager";
+import { Logger } from "./models/Logger";
+import { Store } from "./models/Store";
+import { TaskRunner } from "./models/TaskRunner";
+
+const store = defineResource({
+  id: "global.store",
+  init: async (store: Store) => store,
+});
 
 export const globalResources = {
-  store: defineResource<Store>({
-    id: "global.store",
-    init: async (store) => store,
-  }),
-  eventManager: defineResource<EventManager>({
+  store,
+  eventManager: defineResource({
     id: "global.eventManager",
-    init: async (em) => em,
+    init: async (em: EventManager) => em,
   }),
-  taskRunner: defineResource<TaskRunner>({
+  taskRunner: defineResource({
     id: "global.taskRunner",
-    init: async (runner) => runner,
+    init: async (runner: TaskRunner) => runner,
+  }),
+  logger: defineResource({
+    id: "global.logger",
+    init: async (logger: Logger) => logger,
   }),
 };

package/src/index.ts

@@ -23,6 +23,6 @@ export {
 };
 
 export * as definitions from "./defs";
-export { Store } from "./Store";
-export { EventManager } from "./EventManager";
-export { TaskRunner } from "./TaskRunner";
+export { Store } from "./models/Store";
+export { EventManager } from "./models/EventManager";
+export { TaskRunner } from "./models/TaskRunner";

package/src/{DependencyProcessor.ts → models/DependencyProcessor.ts}

@@ -5,13 +5,13 @@ import {
   IResource,
   IHookDefinition,
   IEventDefinition,
-} from "./defs";
+} from "../defs";
 import { ResourceStoreElementType, Store } from "./Store";
-import * as utils from "./define";
+import * as utils from "../define";
 import { EventManager } from "./EventManager";
 import { ResourceInitializer } from "./ResourceInitializer";
 import { TaskRunner } from "./TaskRunner";
-import { Errors } from "./errors";
+import { Errors } from "../errors";
 
 /**
  * This class is responsible of setting up dependencies with their respective computedValues.
@@ -113,11 +113,11 @@ export class DependencyProcessor {
    * Processes all hooks, should run before emission of any event.
    * @returns
    */
-  public processHooks() {
+  public attachHooks() {
     // iterate through resources and send them to processHooks
     for (const resource of this.store.resources.values()) {
       if (resource.resource.hooks) {
-        this.processHooksForResource(resource);
+        this.attachHooksToResource(resource);
       }
     }
   }
@@ -127,7 +127,7 @@ export class DependencyProcessor {
    * @param hooks
    * @param deps
    */
-  public processHooksForResource(
+  public attachHooksToResource(
     resourceStoreElement: ResourceStoreElementType<any, any, {}>
   ) {
     let hooks = resourceStoreElement.resource.hooks;

package/src/{EventManager.ts → models/EventManager.ts}

@@ -1,4 +1,5 @@
-import { EventHandlerType, IEvent, IEventDefinition } from "./defs";
+import { EventHandlerType, IEvent, IEventDefinition } from "../defs";
+import { Errors } from "../errors";
 
 const HandlerOptionsDefaults = { order: 0 };
 
@@ -16,6 +17,21 @@ export interface IEventHandlerOptions<T = any> {
 export class EventManager {
   private listeners: Map<string, IListenerStorage[]> = new Map();
   private globalListeners: IListenerStorage[] = [];
+  #isLocked = false;
+
+  get isLocked() {
+    return this.#isLocked;
+  }
+
+  lock() {
+    this.#isLocked = true;
+  }
+
+  checkLock() {
+    if (this.#isLocked) {
+      throw Errors.locked("EventManager");
+    }
+  }
 
   async emit<TInput>(
     eventDefinition: IEventDefinition<TInput>,
@@ -46,6 +62,8 @@ export class EventManager {
     handler: EventHandlerType<T>,
     options: IEventHandlerOptions<T> = HandlerOptionsDefaults
   ): void {
+    this.checkLock();
+
     if (Array.isArray(event)) {
       event.forEach((id) => this.addListener(id, handler, options));
     } else {
@@ -66,6 +84,8 @@ export class EventManager {
     handler: EventHandlerType,
     options: IEventHandlerOptions = HandlerOptionsDefaults
   ): void {
+    this.checkLock();
+
     const newListener: IListenerStorage = {
       handler,
       order: options.order || 0,

package/src/models/Logger.ts

@@ -0,0 +1,100 @@
+import { globalEvents } from "../globalEvents";
+import { EventManager } from "./EventManager";
+
+export type LogLevels =
+  | "trace"
+  | "debug"
+  | "info"
+  | "warn"
+  | "error"
+  | "critical";
+
+export interface ILog {
+  level: string;
+  context?: string;
+  data: any;
+  timestamp: Date;
+}
+
+export class Logger {
+  public static defaultContext = "app";
+
+  public severity = {
+    trace: 0,
+    debug: 1,
+    info: 2,
+    warn: 3,
+    error: 4,
+    critical: 5,
+  };
+
+  constructor(private eventManager: EventManager) {}
+
+  /**
+   * @param level
+   * @param message
+   */
+  public async log(level: LogLevels, data: any): Promise<void> {
+    const log: ILog = {
+      level,
+      data,
+      timestamp: new Date(),
+    };
+
+    await this.eventManager.emit(globalEvents.log, log);
+  }
+
+  public async print(log: ILog) {
+    // Extract the relevant information from the log
+    const { level, context, data, timestamp } = log;
+
+    // Format the timestamp to a more readable format
+    const formattedTimestamp = timestamp.toISOString();
+
+    // Format the log level for better visibility
+    const levelStr = `[${level.toUpperCase()}]`;
+
+    // Format the context, if provided
+    const contextStr = context ? `(${context})` : "";
+
+    // Handle different data types, especially if it's an error
+    let dataStr: string;
+    if (data instanceof Error) {
+      dataStr = `Error: ${data.name} - ${data.message}\nStack Trace:\n${data.stack}`;
+    } else if (typeof data === "object") {
+      dataStr = JSON.stringify(data, null, 2); // Pretty-print JSON objects
+    } else {
+      dataStr = String(data); // Convert any other type to string
+    }
+
+    // Construct the final log message
+    const logMessage = `${formattedTimestamp} ${levelStr} ${contextStr} - ${dataStr}`;
+
+    // Print the log message
+    console.log(logMessage);
+  }
+
+  public async info(data: any) {
+    await this.log("info", data);
+  }
+
+  public async error(data: any) {
+    await this.log("error", data);
+  }
+
+  public async warn(data: any) {
+    await this.log("warn", data);
+  }
+
+  public async debug(data: any) {
+    await this.log("debug", data);
+  }
+
+  public async trace(data: any) {
+    await this.log("trace", data);
+  }
+
+  public async critical(data: any) {
+    await this.log("critical", data);
+  }
+}

package/src/{ResourceInitializer.ts → models/ResourceInitializer.ts}

@@ -3,9 +3,9 @@ import {
   DependencyValuesType,
   ITask,
   IResource,
-} from "./defs";
+} from "../defs";
 import { EventManager } from "./EventManager";
-import { globalEvents } from "./globalEvents";
+import { globalEvents } from "../globalEvents";
 import { Store } from "./Store";
 
 export class ResourceInitializer {