clever-queue 0.1.0

package/src/runner/index.ts

@@ -0,0 +1,64 @@
+// clever-queue
+
+import * as _ from "../helpers";
+import { Options, Statistics, ErrorsList, Priorities } from "./interfaces";
+import { Engine } from "../engine";
+
+export * from "./interfaces";
+
+type Status = "unknown" | "initialiazing" | "running" | "stopping" | "destroying";
+
+const defaultOptions: Options = {
+  priority: Priorities.BestEffort,
+  autostart: true,
+  logFunction: undefined,
+};
+
+class Runner {
+  status: Status = "unknown";
+  readonly #options: Options;
+  readonly #engine: Engine;
+
+  constructor(opt: Options, engine: Engine) {
+    this.status = "initialiazing";
+    this.#options = this.#checkOptionsConsistancy({ ...defaultOptions, ...opt });
+    this.#engine = engine; // Store parent engine for later callbacks
+    if (this.#options.autostart) this.start();
+  }
+
+  #checkOptionsConsistancy(options: Options): Options {
+    if (!options) throw new _.Errors.CQError(ErrorsList.NoOptionsOnRunnerInitialization);
+    return options;
+  }
+
+  async #run(): Promise<void> {
+    while (this.status === "running") {
+      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);
+      if (task) {
+        await task.runner();
+      }
+    }
+  }
+
+  start(): void {
+    this.status = "running";
+    this.#run();
+  }
+
+  stop(): void {
+    this.status = "stopping";
+  }
+
+  statistics(): Statistics {
+    const stat: Statistics = {
+      status: this.status,
+      priority: this.#options.priority,
+    };
+    return stat;
+  }
+}
+
+export { Options, Statistics, ErrorsList } from "./interfaces";
+export { Runner };

package/src/runner/interfaces.ts

@@ -0,0 +1,24 @@
+import * as _ from "../helpers";
+
+interface Options {
+  autostart?: boolean;
+  priority: number;
+  logFunction?: _.Logs.LogFunction;
+}
+interface Statistics {
+  status: string;
+  priority: number;
+}
+type ErrorListKeys = "NoOptionsOnRunnerInitialization";
+
+const ErrorsList: {
+  [index in ErrorListKeys]: { name: string; message: string };
+} = {
+  NoOptionsOnRunnerInitialization: {
+    name: "NoOptionsOnRunnerInitialization",
+    message: "NoOptionsOnRunnerInitialization",
+  },
+};
+
+export { Priorities } from "../queue/interfaces";
+export { Options, Statistics, ErrorsList };

package/src/task/index.ts

@@ -0,0 +1,65 @@
+// clever-queue
+
+import * as _ from "../helpers";
+import { Options, Statistics, ErrorsList, FunctionToExecute } from "./interfaces";
+
+type Status = "unknown" | "initialiazing" | "running" | "stopping" | "destroying";
+
+const defaultOptions: Options = {
+  logFunction: undefined,
+};
+
+class Task {
+  status: Status = "unknown";
+  readonly #options: Options;
+  #functionToExecute: FunctionToExecute;
+  result: unknown | undefined = undefined;
+  readonly runner: () => Promise<unknown>;
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  resolver: (value: any | PromiseLike<any>) => void;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  rejecter: (reason?: any) => void;
+
+  #defaultResolver(): void {
+    throw new _.Errors.CQError(ErrorsList.TaskRunnerNotInitialized);
+  }
+  #defaultRejecter(): void {
+    throw new _.Errors.CQError(ErrorsList.TaskRunnerNotInitialized);
+  }
+
+  constructor(function_: FunctionToExecute, opt: Options) {
+    this.status = "initialiazing";
+    this.#options = this.#checkOptionsConsistancy({ ...defaultOptions, ...opt });
+
+    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.status = "running";
+      // console.log("running Task");
+      this.result = await this.#functionToExecute();
+      // console.log("task runned", this.result);
+      this.status = "stopping";
+      this.resolver(this.result);
+    };
+  }
+
+  #checkOptionsConsistancy(options: Options): Options {
+    if (!options) throw new _.Errors.CQError(ErrorsList.NoOptionsOnTaskInitialization);
+    return options;
+  }
+
+  statistics(): Statistics {
+    const stat: Statistics = {
+      status: this.status,
+    };
+    return stat;
+  }
+}
+
+export { Options, Statistics, ErrorsList, FunctionToExecute } from "./interfaces";
+export { Task };

package/src/task/interfaces.ts

@@ -0,0 +1,34 @@
+import * as _ from "../helpers";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type FunctionToExecute = (...arguments_: any[]) => Promise<any> | void;
+
+interface Options {
+  timeout?: number;
+  logFunction?: _.Logs.LogFunction;
+}
+
+interface Statistics {
+  status: string;
+}
+
+type ErrorListKeys = "NoOptionsOnTaskInitialization" | "FunctionIsNotAFunction" | "TaskRunnerNotInitialized";
+
+const ErrorsList: {
+  [index in ErrorListKeys]: { name: string; message: string };
+} = {
+  NoOptionsOnTaskInitialization: {
+    name: "NoOptionsOnTaskInitialization",
+    message: "NoOptionsOnTaskInitialization",
+  },
+  FunctionIsNotAFunction: {
+    name: "FunctionIsNotAFunction",
+    message: "FunctionIsNotAFunction",
+  },
+  TaskRunnerNotInitialized: {
+    name: "TaskRunnerNotInitialized",
+    message: "TaskRunnerNotInitialized",
+  },
+};
+
+export { Options, Statistics, ErrorsList, FunctionToExecute };

package/src/tsconfig.json

@@ -0,0 +1,27 @@
+{
+    "compilerOptions": {
+      "module": "nodenext",
+      "moduleResolution":"nodenext",
+      "esModuleInterop": true,
+      "target": "es2022",
+      "sourceMap": true,
+      "outDir": "../dist",
+      "declaration": true,
+      "lib": [
+        "es2022"
+      ],
+      "strict": true,
+      "useUnknownInCatchVariables": true,
+      "noImplicitAny": true,
+      "strictNullChecks": true,
+      "strictFunctionTypes": true,
+      "strictBindCallApply": true,
+      "strictPropertyInitialization": true,
+      "noImplicitThis": true,
+      "alwaysStrict": true,
+      "forceConsistentCasingInFileNames": true
+    },
+    "$schema": "https://json.schemastore.org/tsconfig",
+    "display": "Recommended"
+  }
+  

package/test/miscellaneous/test.mjs

@@ -0,0 +1,92 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import * as CleverQueue from "../../dist/index.js";
+
+const engineOptions = {
+  bestEffortRunners: 3,
+  logFunction: undefined,
+};
+
+describe("Scheduler Unit Tests", () => {
+  it("Priority Test", () => {
+    const engine = CleverQueue.createEngine(engineOptions);
+    const queue1 = engine.createQueue({
+      name: "A",
+      priority: CleverQueue.Queue.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,
+      weight: 50,
+    });
+    for (let index = 0; index < 100; index++) queue2.enqueue(engine.createTask(() => {}, {}));
+    const queue3 = engine.createQueue({
+      name: "C",
+      priority: CleverQueue.Queue.Priorities.BestEffort,
+      weight: 50,
+    });
+    for (let index = 0; index < 100; index++) queue3.enqueue(engine.createTask(() => {}, {}));
+
+    const engineStatistics = engine.statistics();
+    assert.equal(engineStatistics.engine.queues, 3);
+    engine.stop();
+  });
+
+  it("Weighted Test", () => {
+    const engine = CleverQueue.createEngine(engineOptions);
+    const queue1 = engine.createQueue({
+      name: "A",
+      priority: CleverQueue.Queue.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,
+      weight: 50,
+    });
+    for (let index = 0; index < 100; index++) queue2.enqueue(engine.createTask(() => {}, {}));
+    const queue3 = engine.createQueue({
+      name: "C",
+      priority: CleverQueue.Queue.Priorities.Absolute,
+      weight: 20,
+    });
+    for (let index = 0; index < 100; index++) queue3.enqueue(engine.createTask(() => {}, {}));
+
+    const engineStatistics = engine.statistics();
+    assert.equal(engineStatistics.engine.queues, 3);
+    engine.stop();
+  });
+
+  it("Combine Test", () => {
+    const engine = CleverQueue.createEngine(engineOptions);
+
+    const queue1 = engine.createQueue({
+      name: "A - Absolute - 80",
+      priority: CleverQueue.Queue.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,
+      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,
+      weight: 20,
+    });
+    for (let index = 0; index < 100; index++) queue3.enqueue(engine.createTask(() => {}, {}));
+
+    const engineStatistics = engine.statistics();
+    assert.equal(engineStatistics.engine.queues, 3);
+    engine.stop();
+  });
+});

package/test/units/engine.mjs

@@ -0,0 +1,35 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+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 statistics = engine.statistics();
+    assert.equal(statistics.engine.runners, 1);
+    assert.equal(statistics.engine.queues, 0);
+    engine.stop();
+  });
+
+  it("Exception with stupid bestEffortRunners Options", () => {
+    assert.throws(
+      () =>
+        CleverQueue.createEngine({
+          bestEffortRunners: -1,
+        }),
+      { name: CleverQueue.Engine.ErrorsList.bestEffortRunnersOptionMustBeGreaterThanZero.name },
+    );
+  });
+
+  it("Successfull Initialisation with 3 Runners", () => {
+    const engineOptions = {
+      bestEffortRunners: 3,
+    };
+    const engine = CleverQueue.createEngine(engineOptions);
+    const statistics = engine.statistics();
+    assert.equal(statistics.engine.runners, engineOptions.bestEffortRunners);
+    assert.equal(statistics.engine.queues, 0);
+    engine.stop();
+  });
+});

package/test/units/queue.mjs

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

package/test/units/task.mjs

@@ -0,0 +1,50 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import * as CleverQueue from "../../dist/index.js";
+
+const engineOptions = {
+  bestEffortRunners: 3,
+  logFunction: undefined,
+};
+
+const task = async (string_) => {
+  //  console.log(string_, "Start", new Date());
+  await new Promise((resolve) => setTimeout(resolve, 2000));
+  //  console.log(string_, "End", new Date());
+  return 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 queue1 = engine.createQueue({
+      name: "A",
+      priority: CleverQueue.Queue.Priorities.Absolute,
+      weight: 50,
+    });
+    assert.rejects(
+      async () => {
+        const myTask = engine.createTask(task("myTask"), {});
+        await queue1.enqueue(myTask);
+      },
+      { name: CleverQueue.Task.ErrorsList.FunctionIsNotAFunction.name },
+    );
+    engine.stop();
+  });
+
+  it("Priority Test", () => {
+    const engine = CleverQueue.createEngine(engineOptions);
+    const queue1 = engine.createQueue({
+      name: "A",
+      priority: CleverQueue.Queue.Priorities.Absolute,
+      weight: 50,
+    });
+
+    for (let index = 0; index < 8; index++) queue1.enqueue(engine.createTask(() => task("Task " + index), {}));
+
+    const engineStatistics = engine.statistics();
+    assert.equal(engineStatistics.engine.queues, 1);
+    engine.stop();
+  });
+});