clever-queue 0.1.2 → 0.2.1

package/src/engine/index.ts

@@ -1,13 +1,13 @@
 // clever-queue
 
 import * as _ from "../helpers";
-import * as Queue from "../queue";
-import * as Runner from "../runner";
-import * as Task from "../task";
+import * as cqQueue from "../queues";
+import * as cqRunner from "../runners";
+import * as cqTask from "../tasks";
 
 type Status = "unknown" | "initialiazing" | "running" | "stopping" | "destroying";
 
-const TICK_START = 42;
+const TICK_START = 42; // RANDOM ? ;-) value to avoid zero division
 
 import { Options, Statistics, ErrorsList } from "./interfaces";
 
@@ -19,18 +19,21 @@ const defaultOptions: Options = {
 
 class Engine {
   status: Status = "unknown";
-  readonly runners: Runner.Runner[] = [];
-  readonly queues: Queue.Queue[] = [];
+  readonly options: Options;
+  tags: { [key: string]: string | number | boolean } = {};
+  readonly runners: cqRunner.Runner[] = [];
+  readonly queues: cqQueue.Queue[] = [];
 
   constructor(opt: Options) {
     this.status = "initialiazing";
-    const options = { ...defaultOptions, ...opt };
-    this.#checkOptionsConsistancy(options);
+    this.options = { ...defaultOptions, ...opt };
+    if (!this.options.id) this.options.id = _.Id.generate();
+    this.#checkOptionsConsistancy(this.options);
 
     // create runners
-    for (let index = 0; index < (options.bestEffortRunners ?? 0); index++) this.createRunner({ priority: Runner.Priorities.BestEffort });
-    if (options.logFunction) options.logFunction({ body: "engine has been initialized" });
-    if (options.autostart) this.start();
+    for (let index = 0; index < (this.options.bestEffortRunners ?? 0); index++) this.createRunner({ priority: cqRunner.Priorities.BestEffort });
+    if (this.options.logFunction) this.options.logFunction({ body: "engine has been initialized" });
+    if (this.options.autostart) this.start();
   }
 
   start(): void {
@@ -43,21 +46,21 @@ class Engine {
     for (const runner of this.runners) runner.stop();
   }
 
-  createQueue(options: Queue.Options): Queue.Queue {
-    const queue = new Queue.Queue({ logFunction: options.logFunction, ...options });
+  createQueue(options: cqQueue.Options = { priority: cqQueue.Priorities.Standard, weight: cqQueue.Weights.Default }): cqQueue.Queue {
+    const queue = new cqQueue.Queue({ logFunction: options.logFunction, ...options });
     this.queues.push(queue);
     this.#resetLastTick(options.priority);
     return queue;
   }
 
-  createRunner(options: Runner.Options): Runner.Runner {
-    const runner = new Runner.Runner({ logFunction: options.logFunction, ...options }, this);
+  createRunner(options: cqRunner.Options): cqRunner.Runner {
+    const runner = new cqRunner.Runner({ logFunction: options.logFunction, ...options }, this);
     this.runners.push(runner);
     return runner;
   }
 
-  createTask(function_: Task.FunctionToExecute, options: Task.Options): Task.Task {
-    return new Task.Task(function_, { logFunction: options.logFunction, ...options });
+  createTask(function_: cqTask.FunctionToExecute, options: cqTask.Options): cqTask.Task {
+    return new cqTask.Task(function_, { logFunction: options.logFunction, ...options });
   }
 
   #checkOptionsConsistancy(options: Options): void {
@@ -65,19 +68,25 @@ class Engine {
     if (!options.bestEffortRunners || options.bestEffortRunners < 1) throw new _.Errors.CQError(ErrorsList.bestEffortRunnersOptionMustBeGreaterThanZero);
   }
 
-  #getSumWeightFunction: Queue.GetSumWeightFunction = (priority: number): number => {
+  #getSumWeightFunction: cqQueue.GetSumWeightFunction = (priority: number): number => {
     let result = 0;
     for (const q of this.queues) if (q.options.priority === priority) result += q.options.weight;
     return result;
   };
 
   #resetLastTick(priority: number): void {
-    for (const q of this.queues) if (q.options.priority === priority) q.tick = TICK_START;
+    for (let i = 0; i < this.queues.length; i++) {
+      const q = this.queues[i];
+      if (q.options.priority === priority)
+        q.tick = TICK_START
+          + this.#getSumWeightFunction(priority) / q.options.weight // set tick to max weight / queue weight to favorize low weight queues
+          + i / 255; // slight increment to favorize first created queues
+    }
   }
 
-  #getNextWeightedQueue(priority: number): Queue.Queue | undefined {
+  #getNextWeightedQueue(priority: number): cqQueue.Queue | undefined {
     let minTick = Infinity;
-    let result: Queue.Queue | undefined = undefined;
+    let result: cqQueue.Queue | undefined = undefined;
     for (const q of this.queues)
       if (q.options.priority === priority && q.tick <= minTick) {
         minTick = q.tick;
@@ -91,32 +100,12 @@ class Engine {
     for (const q of this.queues) if (q.options.priority === priority) result += q.tasks.length;
     return result;
   }
-  /*
-   async getNextTask(priorityGreaterOrEqualTo: number): Promise<Task.Task> {
-    for (let priority = Queue.Priorities.Absolute; priority <= priorityGreaterOrEqualTo; priority++) {
-      // Iterate on Each PriorityLevel From Absolute to param function
-      while (this.#howMuchTasksWaitingInQueues(priority) > 0) {
-        let task: Task.Task | undefined;
-        while (!task) {
-          const nextPriorityQueue = this.#getNextQueue(priority); // Find Next Priority Queue to process
-          if (nextPriorityQueue) {
-            nextPriorityQueue.tick += this.#getSumWeightFunction(priority) / nextPriorityQueue.options.weight; // Update tick with related weight
-            if (nextPriorityQueue.tasks.length > 0) {
-              task = nextPriorityQueue.tasks.shift(); // If queue is not empty, this is our next Task to process
-              if (task) task.runner();
-              console.log(nextPriorityQueue.options.name, nextPriorityQueue.tick);
-            }
-          }
-        }
-      }
-    }
-  }
-  */
 
-  async getNextTask(priorityGreaterOrEqualTo: number): Promise<Task.Task | undefined> {
-    let task: Task.Task | undefined = undefined;
+  async getNextTask(priorityGreaterOrEqualTo: number): Promise<cqTask.Task | undefined> {
+    if (this.status !== "running") return undefined;
+    let task: cqTask.Task | undefined = undefined;
     // Iterate on Each PriorityLevel From Absolute to parameter
-    for (let priority = Queue.Priorities.Absolute; priority <= priorityGreaterOrEqualTo; priority++) {
+    for (let priority = cqQueue.Priorities.Absolute; priority >= priorityGreaterOrEqualTo; priority--) {
       // Check if there is task waiting of this priority level
       while (this.#howMuchTasksWaitingInQueues(priority) > 0) {
         // Find Next Weighted Queue of this priority level to check
@@ -138,8 +127,8 @@ class Engine {
 
   statistics(): Statistics {
     let taskCount = 0;
-    const runners: Runner.Statistics[] = [];
-    const queues: Queue.Statistics[] = [];
+    const runners: cqRunner.Statistics[] = [];
+    const queues: cqQueue.Statistics[] = [];
     for (const runner of this.runners) {
       if (runner.status == "running") taskCount += 1;
       runners.push(runner.statistics());
@@ -162,5 +151,5 @@ class Engine {
   }
 }
 
-export { Options, Statistics, ErrorsList } from "./interfaces";
+export { Options, Statistics, ErrorsList, LogFunction } from "./interfaces";
 export { Engine };

package/src/engine/interfaces.ts

@@ -1,9 +1,10 @@
 import * as _ from "../helpers";
 
-import * as Runner from "../runner/interfaces";
-import * as Queue from "../runner/interfaces";
+import * as Runner from "../runners/interfaces";
+import * as Queue from "../runners/interfaces";
 
 interface Options {
+  id?: string;
   autostart?: boolean;
   bestEffortRunners?: number;
   logFunction?: _.Logs.LogFunction;

package/src/helpers/id.ts

@@ -0,0 +1,4 @@
+function generate(): string {
+  return Math.floor(Math.random() * Date.now()).toString(16);
+}
+export { generate };

package/src/helpers/index.ts

@@ -1,3 +1,4 @@
 export * as Errors from "./errors";
 export * as Logs from "./logs";
 export * as Traces from "./traces";
+export * as Id from "./id";

package/src/index.ts

@@ -1,13 +1,13 @@
 // clever-queue
-import * as Engine from "./engine";
+import * as engine from "./engine";
 
-function createEngine(options: Engine.Options): Engine.Engine {
-  return new Engine.Engine(options);
+function createEngine(options: engine.Options = {}): engine.Engine {
+  return new engine.Engine(options);
 }
 
-export * as Engine from "./engine/interfaces";
-export * as Runner from "./runner/interfaces";
-export * as Queue from "./queue/interfaces";
-export * as Task from "./task/interfaces";
+export * as engine from "./engine";
+export * as runners from "./runners";
+export * as queues from "./queues";
+export * as tasks from "./tasks";
 
 export { createEngine };

package/src/{queue → queues}/index.ts

@@ -1,7 +1,7 @@
 // clever-queue
 
 import * as _ from "../helpers";
-import * as Task from "../task";
+import * as cqTask from "../tasks";
 import { Options, Statistics, ErrorsList, Priorities } from "./interfaces";
 
 type GetSumWeightFunction = (priority: number) => number;
@@ -18,12 +18,15 @@ const defaultOptions: Options = {
 class Queue {
   status: Status = "unknown";
   readonly options: Options;
+  tags: { [key: string]: string | number | boolean } = {};
+
   tick: number = 0;
-  tasks: Task.Task[] = [];
+  tasks: cqTask.Task[] = [];
 
   constructor(opt: Options) {
     this.status = "initialiazing";
     this.options = this.#checkOptionsConsistancy({ ...defaultOptions, ...opt });
+    if (!this.options.id) this.options.id = _.Id.generate();
     if (this.options.autostart) this.start();
   }
 
@@ -43,34 +46,14 @@ class Queue {
     this.status = "stopping";
   }
 
-  /*
-  async createTask(function_: Task._function): Promise<unknown> {
-    if (typeof function_ !== "function") {
-      console.error("raisong Task.ErrorsList.FunctionIsNotAFunction", Task.ErrorsList.FunctionIsNotAFunction);
-      throw new _.Errors.CQError(Task.ErrorsList.FunctionIsNotAFunction);
-    }
-    return new Promise((resolve, reject) => {
-      try {
-        const taskRunner = async (): Promise<void> => {
-          console.log("running Task");
-          const result = await function_();
-          console.log("task runned", result);
-          resolve(result);
-        };
-        const task = new Task.Task(taskRunner, {});
-        this.tasks.push(task);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  }
-*/
-  async createTaskAndEnqueue(function_: Task.FunctionToExecute, options: Task.Options): Promise<unknown> {
-    const task = new Task.Task(function_, options);
+  async createTaskAndEnqueue(function_: cqTask.FunctionToExecute, options: cqTask.Options = {}): Promise<unknown> {
+    const task = new cqTask.Task(function_, options);
     return this.enqueue(task);
   }
 
-  async enqueue(task: Task.Task): Promise<unknown> {
+  async enqueue(task: cqTask.Task): Promise<unknown> {
+    task.status = "queued";
+    task.queueId = this.options.id; // store queue that handle task for future references
     return new Promise((resolve, reject) => {
       task.resolver = resolve;
       task.rejecter = reject;
@@ -89,5 +72,5 @@ class Queue {
   }
 }
 
-export { Options, Statistics, ErrorsList, Priorities } from "./interfaces";
+export { Options, Statistics, ErrorsList, Priorities, Weights } from "./interfaces";
 export { Queue, GetSumWeightFunction };

package/src/{queue → queues}/interfaces.ts

@@ -1,9 +1,10 @@
 import * as _ from "../helpers";
 
-const Priorities = { Absolute: 0, Standard: 128, BestEffort: 255 };
+const Priorities = { BestEffort: 0, Standard: 128,  Absolute: 255};
+const Weights = { Lowest: 0, Default: 128, Highest: 255 };
 
 interface Options {
-  name?: string;
+  id?: string;
   priority: number;
   weight: number;
   autostart?: boolean;
@@ -35,4 +36,4 @@ const ErrorsList: {
   NoOptionsOnQueueInitialization: { name: "NoOptionsOnQueueInitialization", message: "You must provide an options parameter to Queue" },
 };
 
-export { Options, Statistics, ErrorsList, Priorities };
+export { Options, Statistics, ErrorsList, Priorities, Weights };

package/src/{runner → runners}/index.ts

@@ -2,11 +2,11 @@
 
 import * as _ from "../helpers";
 import { Options, Statistics, ErrorsList, Priorities } from "./interfaces";
-import { Engine } from "../engine";
+import * as cqEngine from "../engine";
 
 export * from "./interfaces";
 
-type Status = "unknown" | "initialiazing" | "running" | "stopping" | "destroying";
+type Status = "unknown" | "initialiazing" | "idle" | "running" | "stopping" | "destroying";
 
 const defaultOptions: Options = {
   priority: Priorities.BestEffort,
@@ -16,14 +16,16 @@ const defaultOptions: Options = {
 
 class Runner {
   status: Status = "unknown";
-  readonly #options: Options;
-  readonly #engine: Engine;
+  readonly options: Options;
+  tags: { [key: string]: string | number | boolean } = {};
+  readonly #engine: cqEngine.Engine;
 
-  constructor(opt: Options, engine: Engine) {
+  constructor(opt: Options, engine: cqEngine.Engine) {
     this.status = "initialiazing";
-    this.#options = this.#checkOptionsConsistancy({ ...defaultOptions, ...opt });
+    this.options = this.#checkOptionsConsistancy({ ...defaultOptions, ...opt });
+    if (!this.options.id) this.options.id = _.Id.generate();
     this.#engine = engine; // Store parent engine for later callbacks
-    if (this.#options.autostart) this.start();
+    if (this.options.autostart) this.start();
   }
 
   #checkOptionsConsistancy(options: Options): Options {
@@ -32,18 +34,21 @@ class Runner {
   }
 
   async #run(): Promise<void> {
-    while (this.status === "running") {
+    while (["idle", "running"].includes(this.status)) {
       await new Promise((resolve) => setTimeout(resolve, 10)); // Do not freeze the event loop with infinite loop.
       // get the next task to run according to this runner priority
-      const task = await this.#engine.getNextTask(this.#options.priority);
+      const task = await this.#engine.getNextTask(this.options.priority);
       if (task) {
-        await task.runner();
+        if (this.status === "idle") this.status = "running";
+        task.runnerId = this.options.id; // store runner that handle task for future references
+        await task.run();
+        if (this.status === "running") this.status = "idle";
       }
     }
   }
 
   start(): void {
-    this.status = "running";
+    this.status = "idle";
     this.#run();
   }
 
@@ -54,7 +59,7 @@ class Runner {
   statistics(): Statistics {
     const stat: Statistics = {
       status: this.status,
-      priority: this.#options.priority,
+      priority: this.options.priority,
     };
     return stat;
   }

package/src/{runner → runners}/interfaces.ts

@@ -1,6 +1,7 @@
 import * as _ from "../helpers";
 
 interface Options {
+  id?: string;
   autostart?: boolean;
   priority: number;
   logFunction?: _.Logs.LogFunction;
@@ -20,5 +21,5 @@ const ErrorsList: {
   },
 };
 
-export { Priorities } from "../queue/interfaces";
+export { Priorities } from "../queues/interfaces";
 export { Options, Statistics, ErrorsList };

package/src/{task → tasks}/index.ts

@@ -3,7 +3,7 @@
 import * as _ from "../helpers";
 import { Options, Statistics, ErrorsList, FunctionToExecute } from "./interfaces";
 
-type Status = "unknown" | "initialiazing" | "running" | "stopping" | "exception" | "destroying";
+type Status = "unknown" | "initialiazing" | "queued" | "running" | "runned" | "exception" | "destroying";
 
 const defaultOptions: Options = {
   logFunction: undefined,
@@ -11,10 +11,14 @@ const defaultOptions: Options = {
 
 class Task {
   status: Status = "unknown";
-  readonly #options: Options;
+  readonly options: Options;
+  tags: { [key: string]: string | number | boolean } = {};
+  queueId: string | undefined;
+  runnerId: string | undefined;
+
   #functionToExecute: FunctionToExecute;
   result: unknown | undefined = undefined;
-  readonly runner: () => Promise<unknown>;
+  readonly run: () => Promise<unknown>;
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   resolver: (value: any | PromiseLike<any>) => void;
@@ -30,24 +34,21 @@ class Task {
 
   constructor(function_: FunctionToExecute, opt: Options) {
     this.status = "initialiazing";
-    this.#options = this.#checkOptionsConsistancy({ ...defaultOptions, ...opt });
-
+    this.options = this.#checkOptionsConsistancy({ ...defaultOptions, ...opt });
+    if (!this.options.id) this.options.id = _.Id.generate();
     if (typeof function_ !== "function") throw new _.Errors.CQError(ErrorsList.FunctionIsNotAFunction);
 
     this.resolver = this.#defaultResolver;
     this.rejecter = this.#defaultRejecter;
     this.#functionToExecute = function_;
 
-    this.runner = async (): Promise<void> => {
+    this.run = async (): Promise<void> => {
       this.status = "running";
-      // console.log("running Task");
       try {
         this.result = await this.#functionToExecute();
-        // console.log("task runned", this.result);
-        this.status = "stopping";
+        this.status = "runned";
         this.resolver(this.result);
       } catch (error) {
-        // console.log("task error", this.result);
         this.status = "exception";
         this.rejecter(new _.Errors.CQError(ErrorsList.FunctionRaisedAnHundledException));
       }

package/src/{task → tasks}/interfaces.ts

@@ -4,6 +4,7 @@ import * as _ from "../helpers";
 type FunctionToExecute = (...arguments_: any[]) => Promise<any> | void;
 
 interface Options {
+  id?: string;
   timeout?: number;
   logFunction?: _.Logs.LogFunction;
 }

package/test/issues/00001.mjs

@@ -20,7 +20,7 @@ describe("Issue #1", () => {
     const engine = cleverQueue.createEngine(engineOptions);
     const queue1 = engine.createQueue({
       name: "A",
-      priority: cleverQueue.Queue.Priorities.Absolute,
+      priority: cleverQueue.queues.Priorities.Absolute,
       weight: 50,
     });
     assert.rejects(

package/test/miscellaneous/test.mjs

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 
-import * as CleverQueue from "../../dist/index.js";
+import * as cleverQueue from "../../dist/index.js";
 
 const engineOptions = {
   bestEffortRunners: 3,
@@ -10,22 +10,22 @@ const engineOptions = {
 
 describe("Scheduler Unit Tests", () => {
   it("Priority Test", () => {
-    const engine = CleverQueue.createEngine(engineOptions);
+    const engine = cleverQueue.createEngine(engineOptions);
     const queue1 = engine.createQueue({
       name: "A",
-      priority: CleverQueue.Queue.Priorities.Absolute,
+      priority: cleverQueue.queues.Priorities.Absolute,
       weight: 50,
     });
     for (let index = 0; index < 100; index++) queue1.enqueue(engine.createTask(() => {}, {}));
     const queue2 = engine.createQueue({
       name: "B",
-      priority: CleverQueue.Queue.Priorities.Standard,
+      priority: cleverQueue.queues.Priorities.Standard,
       weight: 50,
     });
     for (let index = 0; index < 100; index++) queue2.enqueue(engine.createTask(() => {}, {}));
     const queue3 = engine.createQueue({
       name: "C",
-      priority: CleverQueue.Queue.Priorities.BestEffort,
+      priority: cleverQueue.queues.Priorities.BestEffort,
       weight: 50,
     });
     for (let index = 0; index < 100; index++) queue3.enqueue(engine.createTask(() => {}, {}));
@@ -36,22 +36,22 @@ describe("Scheduler Unit Tests", () => {
   });
 
   it("Weighted Test", () => {
-    const engine = CleverQueue.createEngine(engineOptions);
+    const engine = cleverQueue.createEngine(engineOptions);
     const queue1 = engine.createQueue({
       name: "A",
-      priority: CleverQueue.Queue.Priorities.Absolute,
+      priority: cleverQueue.queues.Priorities.Absolute,
       weight: 80,
     });
     for (let index = 0; index < 100; index++) queue1.enqueue(engine.createTask(() => {}, {}));
     const queue2 = engine.createQueue({
       name: "B",
-      priority: CleverQueue.Queue.Priorities.Absolute,
+      priority: cleverQueue.queues.Priorities.Absolute,
       weight: 50,
     });
     for (let index = 0; index < 100; index++) queue2.enqueue(engine.createTask(() => {}, {}));
     const queue3 = engine.createQueue({
       name: "C",
-      priority: CleverQueue.Queue.Priorities.Absolute,
+      priority: cleverQueue.queues.Priorities.Absolute,
       weight: 20,
     });
     for (let index = 0; index < 100; index++) queue3.enqueue(engine.createTask(() => {}, {}));
@@ -62,25 +62,25 @@ describe("Scheduler Unit Tests", () => {
   });
 
   it("Combine Test", () => {
-    const engine = CleverQueue.createEngine(engineOptions);
+    const engine = cleverQueue.createEngine(engineOptions);
 
     const queue1 = engine.createQueue({
       name: "A - Absolute - 80",
-      priority: CleverQueue.Queue.Priorities.Absolute,
+      priority: cleverQueue.queues.Priorities.Absolute,
       weight: 80,
     });
     for (let index = 0; index < 100; index++) queue1.enqueue(engine.createTask(() => {}, {}));
 
     const queue2 = engine.createQueue({
       name: "B - Standard - 50",
-      priority: CleverQueue.Queue.Priorities.Standard,
+      priority: cleverQueue.queues.Priorities.Standard,
       weight: 50,
     });
     for (let index = 0; index < 100; index++) queue2.enqueue(engine.createTask(() => {}, {}));
 
     const queue3 = engine.createQueue({
       name: "C- Standard - 20",
-      priority: CleverQueue.Queue.Priorities.Standard,
+      priority: cleverQueue.queues.Priorities.Standard,
       weight: 20,
     });
     for (let index = 0; index < 100; index++) queue3.enqueue(engine.createTask(() => {}, {}));

package/test/units/engine.mjs

@@ -1,11 +1,11 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 
-import * as CleverQueue from "../../dist/index.js";
+import * as cleverQueue from "../../dist/index.js";
 
 describe("Engine Class Unit Tests", () => {
   it("Successfull Initialisation without any option (use hardcoded default options)", () => {
-    const engine = CleverQueue.createEngine();
+    const engine = cleverQueue.createEngine();
     const statistics = engine.statistics();
     assert.equal(statistics.engine.runners, 1);
     assert.equal(statistics.engine.queues, 0);
@@ -15,10 +15,10 @@ describe("Engine Class Unit Tests", () => {
   it("Exception with stupid bestEffortRunners Options", () => {
     assert.throws(
       () =>
-        CleverQueue.createEngine({
+        cleverQueue.createEngine({
           bestEffortRunners: -1,
         }),
-      { name: CleverQueue.Engine.ErrorsList.bestEffortRunnersOptionMustBeGreaterThanZero.name },
+      { name: cleverQueue.engine.ErrorsList.bestEffortRunnersOptionMustBeGreaterThanZero.name },
     );
   });
 
@@ -26,7 +26,7 @@ describe("Engine Class Unit Tests", () => {
     const engineOptions = {
       bestEffortRunners: 3,
     };
-    const engine = CleverQueue.createEngine(engineOptions);
+    const engine = cleverQueue.createEngine(engineOptions);
     const statistics = engine.statistics();
     assert.equal(statistics.engine.runners, engineOptions.bestEffortRunners);
     assert.equal(statistics.engine.queues, 0);

package/test/units/queue.mjs

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 
-import * as CleverQueue from "../../dist/index.js";
+import * as cleverQueue from "../../dist/index.js";
 
 const engineOptions = {
   bestEffortRunners: 3,
@@ -10,7 +10,7 @@ const engineOptions = {
 
 describe("Queue Class Unit Tests", () => {
   it("Successfull Initialisation without any option (use hardcoded default options)", () => {
-    const engine = CleverQueue.createEngine();
+    const engine = cleverQueue.createEngine();
     const statistics = engine.statistics();
     assert.equal(statistics.engine.runners, 1);
     assert.equal(statistics.engine.queues, 0);
@@ -18,9 +18,9 @@ describe("Queue Class Unit Tests", () => {
   });
 
   it("Successfull Initialisation", () => {
-    const engine = CleverQueue.createEngine(engineOptions);
+    const engine = cleverQueue.createEngine(engineOptions);
     const queueOptions = {
-      priority: CleverQueue.Queue.Priorities.Standard,
+      priority: cleverQueue.queues.Priorities.Standard,
       weight: 50,
     };
     const queue = engine.createQueue(queueOptions);

package/test/units/task.mjs

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 
-import * as CleverQueue from "../../dist/index.js";
+import * as cleverQueue from "../../dist/index.js";
 
 const engineOptions = {
   bestEffortRunners: 3,
@@ -17,10 +17,10 @@ const task = async (string_) => {
 
 describe("Scheduler Unit Tests", () => {
   it("Exception if function passed is not a function (but a result of an executed function)", () => {
-    const engine = CleverQueue.createEngine(engineOptions);
+    const engine = cleverQueue.createEngine(engineOptions);
     const queue1 = engine.createQueue({
       name: "A",
-      priority: CleverQueue.Queue.Priorities.Absolute,
+      priority: cleverQueue.queues.Priorities.Absolute,
       weight: 50,
     });
     assert.rejects(
@@ -28,16 +28,16 @@ describe("Scheduler Unit Tests", () => {
         const myTask = engine.createTask(task("myTask"), {});
         await queue1.enqueue(myTask);
       },
-      { name: CleverQueue.Task.ErrorsList.FunctionIsNotAFunction.name },
+      { name: cleverQueue.tasks.ErrorsList.FunctionIsNotAFunction.name },
     );
     engine.stop();
   });
 
   it("Priority Test", () => {
-    const engine = CleverQueue.createEngine(engineOptions);
+    const engine = cleverQueue.createEngine(engineOptions);
     const queue1 = engine.createQueue({
       name: "A",
-      priority: CleverQueue.Queue.Priorities.Absolute,
+      priority: cleverQueue.queues.Priorities.Absolute,
       weight: 50,
     });