@bluelibs/runner 1.1.0 → 1.2.0

package/dist/run.js

@@ -1,21 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.run = run;
-const TaskRunner_1 = require("./TaskRunner");
-const DependencyProcessor_1 = require("./DependencyProcessor");
-const EventManager_1 = require("./EventManager");
+const TaskRunner_1 = require("./models/TaskRunner");
+const DependencyProcessor_1 = require("./models/DependencyProcessor");
+const EventManager_1 = require("./models/EventManager");
 const globalEvents_1 = require("./globalEvents");
-const Store_1 = require("./Store");
+const Store_1 = require("./models/Store");
 const findCircularDependencies_1 = require("./tools/findCircularDependencies");
 const errors_1 = require("./errors");
 const globalResources_1 = require("./globalResources");
+const Logger_1 = require("./models/Logger");
 async function run(resource, config) {
     const eventManager = new EventManager_1.EventManager();
     const store = new Store_1.Store(eventManager);
     const taskRunner = new TaskRunner_1.TaskRunner(store, eventManager);
     const processor = new DependencyProcessor_1.DependencyProcessor(store, eventManager, taskRunner);
+    const logger = new Logger_1.Logger(eventManager);
     // In the registration phase we register deeply all the resources, tasks, middleware and events
     store.initializeStore(resource, config);
+    store.storeGenericItem(globalResources_1.globalResources.logger.with(logger));
     store.storeGenericItem(globalResources_1.globalResources.taskRunner.with(taskRunner));
     // We verify that there isn't any circular dependencies before we begin computing the dependencies
     const dependentNodes = store.getDependentNodes();
@@ -23,11 +26,14 @@ async function run(resource, config) {
     if (circularDependencies.cycles.length > 0) {
         throw errors_1.Errors.circularDependencies(circularDependencies.cycles);
     }
-    await processor.processHooks();
+    await store.processOverrides();
+    // a form of hooking, we store the events for all tasks
+    await store.storeEventsForAllTasks();
+    await processor.attachHooks();
+    await processor.computeAllDependencies();
     // Now we can safely compute dependencies without being afraid of an infinite loop.
     // The hooking part is done here.
     await eventManager.emit(globalEvents_1.globalEvents.beforeInit);
-    await processor.computeAllDependencies();
     // leftovers that were registered but not depended upon, except root
     await processor.initializeUninitializedResources();
     // Now we can initialise the root resource

package/dist/run.js.map

@@ -1 +1 @@
-{"version":3,"file":"run.js","sourceRoot":"","sources":["../src/run.ts"],"names":[],"mappings":";;AA2DA,kBAwCC;AAnGD,6CAA0C;AAU1C,+DAA4D;AAC5D,iDAA8C;AAC9C,iDAA8C;AAC9C,mCAAgC;AAChC,+EAA4E;AAC5E,qCAAkC;AAClC,uDAAoD;AA2C7C,KAAK,UAAU,GAAG,CACvB,QAAyB,EACzB,MAAU;IAEV,MAAM,YAAY,GAAG,IAAI,2BAAY,EAAE,CAAC;IACxC,MAAM,KAAK,GAAG,IAAI,aAAK,CAAC,YAAY,CAAC,CAAC;IACtC,MAAM,UAAU,GAAG,IAAI,uBAAU,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;IACvD,MAAM,SAAS,GAAG,IAAI,yCAAmB,CAAC,KAAK,EAAE,YAAY,EAAE,UAAU,CAAC,CAAC;IAE3E,+FAA+F;IAC/F,KAAK,CAAC,eAAe,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IACxC,KAAK,CAAC,gBAAgB,CAAC,iCAAe,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;IAEpE,kGAAkG;IAClG,MAAM,cAAc,GAAG,KAAK,CAAC,iBAAiB,EAAE,CAAC;IACjD,MAAM,oBAAoB,GAAG,IAAA,mDAAwB,EAAC,cAAc,CAAC,CAAC;IACtE,IAAI,oBAAoB,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC3C,MAAM,eAAM,CAAC,oBAAoB,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC;IACjE,CAAC;IAED,MAAM,SAAS,CAAC,YAAY,EAAE,CAAC;IAE/B,mFAAmF;IACnF,iCAAiC;IACjC,MAAM,YAAY,CAAC,IAAI,CAAC,2BAAY,CAAC,UAAU,CAAC,CAAC;IAEjD,MAAM,SAAS,CAAC,sBAAsB,EAAE,CAAC;IAEzC,oEAAoE;IACpE,MAAM,SAAS,CAAC,gCAAgC,EAAE,CAAC;IAEnD,0CAA0C;IAC1C,MAAM,SAAS,CAAC,cAAc,EAAE,CAAC;IAEjC,MAAM,YAAY,CAAC,IAAI,CAAC,2BAAY,CAAC,SAAS,CAAC,CAAC;IAEhD,0CAA0C;IAC1C,KAAK,CAAC,IAAI,EAAE,CAAC;IAEb,OAAO,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC;AAC1B,CAAC"}
+{"version":3,"file":"run.js","sourceRoot":"","sources":["../src/run.ts"],"names":[],"mappings":";;AA4DA,kBA6CC;AAzGD,oDAAiD;AAUjD,sEAAmE;AACnE,wDAAqD;AACrD,iDAA8C;AAC9C,0CAAuC;AACvC,+EAA4E;AAC5E,qCAAkC;AAClC,uDAAoD;AACpD,4CAAyC;AA2ClC,KAAK,UAAU,GAAG,CACvB,QAAyB,EACzB,MAAU;IAEV,MAAM,YAAY,GAAG,IAAI,2BAAY,EAAE,CAAC;IACxC,MAAM,KAAK,GAAG,IAAI,aAAK,CAAC,YAAY,CAAC,CAAC;IACtC,MAAM,UAAU,GAAG,IAAI,uBAAU,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;IACvD,MAAM,SAAS,GAAG,IAAI,yCAAmB,CAAC,KAAK,EAAE,YAAY,EAAE,UAAU,CAAC,CAAC;IAC3E,MAAM,MAAM,GAAG,IAAI,eAAM,CAAC,YAAY,CAAC,CAAC;IAExC,+FAA+F;IAC/F,KAAK,CAAC,eAAe,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IACxC,KAAK,CAAC,gBAAgB,CAAC,iCAAe,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAC5D,KAAK,CAAC,gBAAgB,CAAC,iCAAe,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;IAEpE,kGAAkG;IAClG,MAAM,cAAc,GAAG,KAAK,CAAC,iBAAiB,EAAE,CAAC;IACjD,MAAM,oBAAoB,GAAG,IAAA,mDAAwB,EAAC,cAAc,CAAC,CAAC;IACtE,IAAI,oBAAoB,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC3C,MAAM,eAAM,CAAC,oBAAoB,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC;IACjE,CAAC;IAED,MAAM,KAAK,CAAC,gBAAgB,EAAE,CAAC;IAE/B,uDAAuD;IACvD,MAAM,KAAK,CAAC,sBAAsB,EAAE,CAAC;IACrC,MAAM,SAAS,CAAC,WAAW,EAAE,CAAC;IAC9B,MAAM,SAAS,CAAC,sBAAsB,EAAE,CAAC;IAEzC,mFAAmF;IACnF,iCAAiC;IACjC,MAAM,YAAY,CAAC,IAAI,CAAC,2BAAY,CAAC,UAAU,CAAC,CAAC;IAEjD,oEAAoE;IACpE,MAAM,SAAS,CAAC,gCAAgC,EAAE,CAAC;IAEnD,0CAA0C;IAC1C,MAAM,SAAS,CAAC,cAAc,EAAE,CAAC;IAEjC,MAAM,YAAY,CAAC,IAAI,CAAC,2BAAY,CAAC,SAAS,CAAC,CAAC;IAEhD,0CAA0C;IAC1C,KAAK,CAAC,IAAI,EAAE,CAAC;IAEb,OAAO,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC;AAC1B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bluelibs/runner",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "BlueLibs Runner",
   "main": "dist/index.js",
   "repository": {

package/src/__tests__/index.ts

@@ -1,9 +1,13 @@
-import "./EventManager.test";
+import "./models/EventManager.test";
+import "./models/ResourceInitializer.test";
+import "./models/TaskRunner.test";
+import "./models/Store.test";
+import "./models/Logger.test";
+
 import "./tools/findCircularDependencies.test";
-import "./ResourceInitializer.test";
+
 import "./run.test";
 import "./run.hooks.test";
-import "./TaskRunner.test";
+import "./run.overrides.test";
 import "./globalEvents.test";
-import "./Store.test";
 import "./errors.test";

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

@@ -1,6 +1,6 @@
-import { IEvent, IEventDefinition } from "../defs";
-import { Errors } from "../errors";
-import { EventManager } from "../EventManager";
+import { IEvent, IEventDefinition } from "../../defs";
+import { Errors } from "../../errors";
+import { EventManager } from "../../models/EventManager";
 
 describe("EventManager", () => {
   let eventManager: EventManager;

package/src/__tests__/models/Logger.test.ts

@@ -0,0 +1,140 @@
+import { Logger, ILog, LogLevels } from "../../models/Logger";
+import { EventManager } from "../../models/EventManager";
+import { globalEvents } from "../../globalEvents";
+import { mock } from "node:test";
+
+describe("Logger", () => {
+  let logger: Logger;
+  let mockEventManager: jest.Mocked<EventManager>;
+
+  beforeEach(() => {
+    mockEventManager = new EventManager() as jest.Mocked<EventManager>;
+    logger = new Logger(mockEventManager);
+  });
+
+  describe("log method", () => {
+    it("should emit a log event with correct data", async () => {
+      const testData = "Test log message";
+      const testLevel = "info";
+      mockEventManager.emit = jest.fn();
+
+      await logger.log(testLevel, testData);
+
+      expect(mockEventManager.emit).toHaveBeenCalledWith(
+        globalEvents.log,
+        expect.objectContaining({
+          level: testLevel,
+          data: testData,
+          timestamp: expect.any(Date),
+        })
+      );
+    });
+
+    it("should handle different log levels", async () => {
+      const levels: Array<LogLevels> = [
+        "trace",
+        "debug",
+        "info",
+        "warn",
+        "error",
+        "critical",
+      ];
+
+      mockEventManager.emit = jest.fn();
+
+      for (const level of levels) {
+        await logger.log(level, `Test ${level} message`);
+
+        expect(mockEventManager.emit).toHaveBeenCalledWith(
+          globalEvents.log,
+          expect.objectContaining({
+            level,
+            data: `Test ${level} message`,
+            timestamp: expect.any(Date),
+          })
+        );
+      }
+    });
+  });
+
+  describe("print method", () => {
+    let consoleLogSpy: jest.SpyInstance;
+
+    beforeEach(() => {
+      consoleLogSpy = jest.spyOn(console, "log").mockImplementation();
+    });
+
+    afterEach(() => {
+      consoleLogSpy.mockRestore();
+    });
+
+    it("should print log messages correctly", async () => {
+      const testLog: ILog = {
+        level: "info",
+        context: "test",
+        data: "Test log message",
+        timestamp: new Date("2023-01-01T00:00:00Z"),
+      };
+
+      await logger.print(testLog);
+
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining("[INFO] (test) - Test log message")
+      );
+    });
+
+    it("should handle Error objects in log data", async () => {
+      const testError = new Error("Test error");
+      const testLog: ILog = {
+        level: "error",
+        data: testError,
+        timestamp: new Date("2023-01-01T00:00:00Z"),
+      };
+
+      await logger.print(testLog);
+
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining("Error: Error - Test error")
+      );
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining("Stack Trace:")
+      );
+    });
+
+    it("should pretty-print JSON objects in log data", async () => {
+      const testObject = { key: "value", nested: { foo: "bar" } };
+      const testLog: ILog = {
+        level: "debug",
+        data: testObject,
+        timestamp: new Date("2023-01-01T00:00:00Z"),
+      };
+
+      await logger.print(testLog);
+
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining(JSON.stringify(testObject, null, 2))
+      );
+    });
+  });
+
+  describe("log level methods", () => {
+    const testLevels: Array<LogLevels> = [
+      "trace",
+      "debug",
+      "info",
+      "warn",
+      "error",
+      "critical",
+    ];
+
+    for (const level of testLevels) {
+      it(`should call log method with ${level} level`, async () => {
+        const logSpy = jest.spyOn(logger, "log").mockImplementation();
+
+        await logger[level]("Test log message");
+
+        expect(logSpy).toHaveBeenCalledWith(level, "Test log message");
+      });
+    }
+  });
+});

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

@@ -1,7 +1,7 @@
-import { ResourceInitializer } from "../ResourceInitializer";
-import { Store } from "../Store";
-import { EventManager } from "../EventManager";
-import { defineResource } from "../define";
+import { ResourceInitializer } from "../../models/ResourceInitializer";
+import { Store } from "../../models/Store";
+import { EventManager } from "../../models/EventManager";
+import { defineResource } from "../../define";
 
 describe("ResourceInitializer", () => {
   let store: Store;

package/src/__tests__/{Store.test.ts → models/Store.test.ts}

@@ -1,12 +1,12 @@
-import { Store } from "../Store";
-import { EventManager } from "../EventManager";
+import { Store } from "../../models/Store";
+import { EventManager } from "../../models/EventManager";
 import {
   defineResource,
   defineTask,
   defineMiddleware,
   defineEvent,
-} from "../define";
-import { globalResources } from "../globalResources";
+} from "../../define";
+import { globalResources } from "../../globalResources";
 
 describe("Store", () => {
   let eventManager: EventManager;

package/src/__tests__/{TaskRunner.test.ts → models/TaskRunner.test.ts}

@@ -1,8 +1,8 @@
-import { TaskRunner } from "../TaskRunner";
-import { Store } from "../Store";
-import { EventManager } from "../EventManager";
-import { defineTask, defineResource, defineMiddleware } from "../define";
-import { ITask } from "../defs";
+import { TaskRunner } from "../../models/TaskRunner";
+import { Store } from "../../models/Store";
+import { EventManager } from "../../models/EventManager";
+import { defineTask, defineResource, defineMiddleware } from "../../define";
+import { ITask } from "../../defs";
 
 describe("TaskRunner", () => {
   let store: Store;

package/src/__tests__/run.overrides.test.ts

@@ -0,0 +1,392 @@
+import { definitions } from "..";
+import {
+  defineTask,
+  defineResource,
+  defineEvent,
+  defineMiddleware,
+} from "../define";
+import { Errors } from "../errors";
+import { run } from "../run";
+
+describe("run.overrides", () => {
+  // Tasks
+  it("Should work with a simple override", async () => {
+    const task = defineTask({
+      id: "task",
+      run: async () => "Task executed",
+    });
+
+    const override = defineTask({
+      id: "task",
+      run: async () => "Task overridden",
+    });
+
+    const app = defineResource({
+      id: "app",
+      register: [task],
+      dependencies: {
+        task,
+      },
+      overrides: [override],
+      async init(_, deps) {
+        return await deps.task();
+      },
+    });
+
+    const result = await run(app);
+    expect(result).toBe("Task overridden");
+  });
+
+  it("Should work with a deep override", async () => {
+    const task = defineTask({
+      id: "task",
+      run: async () => "Task executed",
+    });
+
+    const override = defineTask({
+      id: "task",
+      run: async () => "Task overridden",
+    });
+
+    const middle = defineResource({
+      id: "app",
+      register: [task],
+      overrides: [override],
+    });
+
+    const root = defineResource({
+      id: "root",
+      register: [middle],
+      dependencies: { task },
+      async init(_, deps) {
+        return await deps.task();
+      },
+    });
+
+    const result = await run(root);
+    expect(result).toBe("Task overridden");
+  });
+
+  it("Should work with a deep override with config", async () => {
+    const task = defineTask({
+      id: "task",
+      run: async () => "Task executed",
+    });
+
+    const override = defineTask({
+      id: "task",
+      run: async () => "Task overridden",
+    });
+
+    const middle = defineResource<{ test: string }>({
+      id: "app",
+      register: [task],
+      overrides: [override],
+    });
+
+    const root = defineResource({
+      id: "root",
+      register: [middle.with({ test: "ok" })],
+      dependencies: { task },
+      async init(_, deps) {
+        return await deps.task();
+      },
+    });
+
+    const result = await run(root);
+    expect(result).toBe("Task overridden");
+  });
+
+  it("Should work with a override that has an override", async () => {
+    const task = defineTask({
+      id: "task",
+      run: async () => "Task executed",
+    });
+
+    const override = defineTask({
+      id: "task",
+      run: async () => "Task overridden",
+    });
+
+    const resource = defineResource({
+      id: "resource",
+    });
+
+    const resourceOverride = {
+      ...resource,
+      overrides: [override],
+    };
+
+    const middle = defineResource({
+      id: "app",
+      register: [task],
+      overrides: [resourceOverride],
+    });
+
+    const root = defineResource({
+      id: "root",
+      register: [middle, resource],
+      dependencies: { task },
+      async init(_, deps) {
+        return await deps.task();
+      },
+    });
+
+    const result = await run(root);
+    expect(result).toBe("Task overridden");
+  });
+
+  it("Should work with a override that has an override with config", async () => {
+    const task = defineTask({
+      id: "task",
+      run: async () => "Task executed",
+    });
+
+    const override = defineTask({
+      id: "task",
+      run: async () => "Task overridden",
+    });
+
+    const resource = defineResource({
+      id: "resource",
+    });
+
+    const resourceOverride: definitions.IResource<any> = {
+      ...resource,
+      overrides: [override],
+      async init(config: { test: string }) {
+        return "Resource init";
+      },
+    };
+
+    const middle = defineResource({
+      id: "app",
+      register: [task],
+      overrides: [resourceOverride.with({ test: "ok" })],
+    });
+
+    const root = defineResource({
+      id: "root",
+      register: [middle, resource],
+      dependencies: { task },
+      async init(_, deps) {
+        return await deps.task();
+      },
+    });
+
+    const result = await run(root);
+    expect(result).toBe("Task overridden");
+  });
+
+  it("should work overriding a middleware", async () => {
+    const middleware = defineMiddleware({
+      id: "middleware",
+      run: async ({ next }) => {
+        return `Middleware: ${await next()}`;
+      },
+    });
+
+    const override = defineMiddleware({
+      id: "middleware",
+      run: async ({ next }) => {
+        return `Override: ${await next()}`;
+      },
+    });
+
+    const task = defineTask({
+      id: "task",
+      middleware: [middleware],
+      run: async () => "Task executed",
+    });
+
+    const resource = defineResource({
+      id: "resource",
+      register: [middleware, task],
+      dependencies: { task },
+      overrides: [override],
+      async init(_, deps) {
+        return deps.task();
+      },
+    });
+
+    const result = await run(resource);
+    expect(result).toBe("Override: Task executed");
+  });
+
+  it("should throw, when you try to override something unregistered", async () => {
+    const task = defineTask({
+      id: "task",
+      run: async () => "Task executed",
+    });
+
+    const override = defineTask({
+      id: "task2",
+      run: async () => "Task overridden",
+    });
+
+    const app = defineResource({
+      id: "app",
+      dependencies: {
+        task,
+      },
+      overrides: [override],
+      async init(_, deps) {
+        return await deps.task();
+      },
+    });
+
+    await expect(run(app)).rejects.toThrowError(
+      Errors.dependencyNotFound("task2").message
+    );
+  });
+
+  it("should throw, when you try to override something unregistered but with resources with config", async () => {
+    const r1 = defineResource({
+      id: "override",
+      init: async () => "Task executed",
+    });
+    const r2 = defineResource({
+      id: "override2",
+      init: async () => "Task executed",
+    });
+
+    const app = defineResource({
+      id: "app",
+      dependencies: {
+        r1,
+      },
+      overrides: [r2.with()],
+      async init(_, r1) {
+        return r1;
+      },
+    });
+
+    await expect(run(app)).rejects.toThrowError(
+      Errors.dependencyNotFound("override2").message
+    );
+  });
+
+  it("should have an override priority, the deeper you are, the less priority you have in the override", async () => {
+    const task = defineTask({
+      id: "task",
+      run: async () => "Task executed",
+    });
+
+    const override = defineTask({
+      id: "task2",
+      run: async () => "Task overridden",
+    });
+
+    const override2 = defineTask({
+      id: "task",
+      run: async () => "Task super-overridden",
+    });
+
+    const middle = defineResource({
+      id: "app",
+      register: [task],
+      overrides: [override],
+    });
+
+    const app = defineResource({
+      id: "app",
+      dependencies: {
+        task,
+      },
+      register: [middle],
+      overrides: [override2],
+      async init(_, deps) {
+        return await deps.task();
+      },
+    });
+
+    const result = await run(app);
+    expect(result).toBe("Task super-overridden");
+  });
+
+  it("should override if I have a previously registered normal resource with a resource with config", async () => {
+    const r1 = defineResource({
+      id: "override",
+      init: async () => "Task executed",
+    });
+    const r2 = defineResource({
+      id: "override",
+      init: async () => "Task overriden.",
+    });
+
+    const app = defineResource({
+      id: "app",
+      dependencies: {
+        r1,
+      },
+      register: [r1],
+      overrides: [r2.with()],
+      async init(_, deps) {
+        return deps.r1;
+      },
+    });
+
+    await expect(run(app)).resolves.toBe("Task overriden.");
+  });
+
+  it("should override if I have a previously registered normal resource with a resource with config", async () => {
+    const r1 = defineResource({
+      id: "override",
+      init: async () => "Task executed",
+    });
+    const r2 = defineResource({
+      id: "override",
+      init: async () => "Task overriden.",
+    });
+
+    const app = defineResource({
+      id: "app",
+      dependencies: {
+        r1,
+      },
+      register: [r1.with()],
+      overrides: [r2.with()],
+      async init(_, deps) {
+        return deps.r1;
+      },
+    });
+
+    await expect(run(app)).resolves.toBe("Task overriden.");
+  });
+
+  it("should override something deeply registered, with a with config", async () => {
+    const r1 = defineResource({
+      id: "override",
+      init: async () => "Task executed",
+    });
+
+    const middle = defineResource({
+      id: "app.m1",
+      register: [r1],
+    });
+
+    const middle2 = defineResource({
+      id: "app.m2",
+      register: [middle],
+    });
+
+    const r2 = defineResource({
+      id: "override",
+      init: async () => "Task overriden.",
+    });
+
+    const app = defineResource({
+      id: "app",
+      dependencies: {
+        r1,
+      },
+      register: [middle2],
+      overrides: [r2.with()],
+      async init(_, deps) {
+        return deps.r1;
+      },
+    });
+
+    await expect(run(app)).resolves.toBe("Task overriden.");
+  });
+});

package/src/define.ts

@@ -10,6 +10,8 @@ import {
   DependencyMapType,
   DependencyValuesType,
   IMiddleware,
+  IHookDefinition,
+  IEvent,
 } from "./defs";
 import { Errors } from "./errors";
 
@@ -57,6 +59,7 @@ export function defineResource<
     hooks: constConfig.hooks || [],
     dispose: constConfig.dispose,
     register: constConfig.register || [],
+    overrides: constConfig.overrides || [],
     init: constConfig.init,
     with: function (config: TConfig) {
       return {