@tsed/pulse 8.0.1 → 8.0.3

package/package.json

@@ -2,13 +2,14 @@
   "name": "@tsed/pulse",
   "description": "@pulsecron/pulse package for Ts.ED framework",
   "type": "module",
-  "version": "8.0.1",
+  "version": "8.0.3",
   "source": "./src/index.ts",
   "main": "./lib/esm/index.js",
   "module": "./lib/esm/index.js",
   "typings": "./lib/types/index.d.ts",
   "exports": {
     ".": {
+      "@tsed/source": "./src/index.ts",
       "types": "./lib/types/index.d.ts",
       "import": "./lib/esm/index.js",
       "default": "./lib/esm/index.js"
@@ -26,11 +27,11 @@
   },
   "devDependencies": {
     "@pulsecron/pulse": "^1.6.3",
-    "@tsed/barrels": "8.0.1",
-    "@tsed/core": "8.0.1",
-    "@tsed/di": "8.0.1",
-    "@tsed/platform-http": "8.0.1",
-    "@tsed/typescript": "8.0.1",
+    "@tsed/barrels": "8.0.3",
+    "@tsed/core": "8.0.3",
+    "@tsed/di": "8.0.3",
+    "@tsed/platform-http": "8.0.3",
+    "@tsed/typescript": "8.0.3",
     "eslint": "9.12.0",
     "typescript": "5.4.5",
     "vitest": "2.1.2"

package/src/PulseModule.spec.ts

@@ -0,0 +1,221 @@
+import type {Job} from "@pulsecron/pulse";
+import {Inject} from "@tsed/di";
+import {PlatformTest} from "@tsed/platform-http/testing";
+
+import {Define} from "./decorators/define.js";
+import {Every} from "./decorators/every.js";
+import {Pulse} from "./decorators/pulse.js";
+import {PulseModule} from "./PulseModule.js";
+
+vi.mock("@pulsecron/pulse", () => {
+  return {
+    Pulse: class {
+      close = vi.fn();
+      stop = vi.fn();
+      drain = vi.fn();
+      define = vi.fn();
+      every = vi.fn();
+      schedule = vi.fn();
+      now = vi.fn();
+      create = vi.fn().mockReturnValue({
+        repeatEvery: vi.fn().mockReturnThis(),
+        save: vi.fn()
+      });
+      start = vi.fn();
+    }
+  };
+});
+
+@Pulse({namespace: "test-nsp"})
+class CustomCampaign {
+  @Inject()
+  pulse: PulseModule;
+
+  job: Job;
+
+  $beforePulseStart() {
+    this.job = this.pulse.create("customName2", {
+      locale: "fr-FR"
+    });
+  }
+
+  $afterPulseStart() {
+    return this.job.repeatEvery("1 week").save();
+  }
+
+  @Every("60 seconds")
+  test(job: Job) {
+    // test
+    return "hello " + job.attrs.name;
+  }
+
+  @Define({name: "customName"})
+  test2(job: Job) {
+    // test
+    return "hello " + job.attrs.name;
+  }
+
+  @Define({name: "customName2"})
+  test3() {
+    // test
+  }
+}
+
+@Pulse({namespace: "test-nsp-2"})
+class CustomCampaign2 {
+  @Define({name: "customName"})
+  test(job: Job) {
+    // test
+    return "hello " + job.attrs.name;
+  }
+}
+
+@Pulse({namespace: "test-nsp-3"})
+class CustomCampaign3 {}
+
+describe("PulseModule", () => {
+  describe("when pulse is enabled", () => {
+    beforeEach(() =>
+      PlatformTest.create({
+        pulse: {
+          enabled: true
+        }
+      })
+    );
+    afterEach(() => PlatformTest.reset());
+
+    describe("$afterListen()", () => {
+      it("should load all jobs", async () => {
+        const pulseModule = PlatformTest.get<any>(PulseModule)!;
+        const campaign = PlatformTest.get<CustomCampaign>(CustomCampaign)!;
+
+        await pulseModule.$afterListen();
+
+        expect(pulseModule.pulse.define).toHaveBeenCalledWith("test-nsp.test", expect.any(Function), {});
+        expect(pulseModule.pulse.every).toHaveBeenCalledWith("60 seconds", "test-nsp.test", {}, {});
+        expect(pulseModule.pulse.start).toHaveBeenCalledWith();
+        expect(pulseModule.pulse.create).toHaveBeenCalledWith("customName2", {locale: "fr-FR"});
+
+        expect(campaign.job.repeatEvery).toHaveBeenCalledWith("1 week");
+        expect(campaign.job.save).toHaveBeenCalledWith();
+
+        const result = await pulseModule.pulse.define.mock.calls[0][1]({
+          attrs: {
+            name: "test-nsp.test"
+          }
+        });
+
+        expect(result).toEqual("hello test-nsp.test");
+      });
+    });
+    describe("schedule()", () => {
+      it("should schedule a job", async () => {
+        const pulseModule = PlatformTest.get<any>(PulseModule)!;
+
+        await pulseModule.schedule("now", "test-nsp.test", {});
+
+        expect(pulseModule.pulse.schedule).toHaveBeenCalledWith("now", "test-nsp.test", {});
+      });
+    });
+
+    describe("now()", () => {
+      it("should schedule a job", async () => {
+        const pulseModule = PlatformTest.get<any>(PulseModule)!;
+
+        await pulseModule.now("test-nsp.test", {});
+
+        expect(pulseModule.pulse.now).toHaveBeenCalledWith("test-nsp.test", {});
+      });
+    });
+    describe("$onDestroy()", () => {
+      it("should close pulse", async () => {
+        const pulseModule = PlatformTest.get<any>(PulseModule)!;
+
+        await pulseModule.$onDestroy();
+
+        expect(pulseModule.pulse.stop).toHaveBeenCalledWith();
+        expect(pulseModule.pulse.close).toHaveBeenCalledWith({force: true});
+      });
+    });
+  });
+  describe("when pulse is enabled and drainJobsBeforeClose = true", () => {
+    beforeEach(() =>
+      PlatformTest.create({
+        pulse: {
+          enabled: true,
+          drainJobsBeforeClose: true
+        }
+      })
+    );
+    afterEach(() => PlatformTest.reset());
+    describe("$onDestroy()", () => {
+      it("should close pulse", async () => {
+        const pulseModule = PlatformTest.get<any>(PulseModule)!;
+
+        await pulseModule.$onDestroy();
+
+        expect(pulseModule.pulse.drain).toHaveBeenCalledWith();
+        expect(pulseModule.pulse.close).toHaveBeenCalledWith({force: true});
+      });
+    });
+  });
+  describe("when pulse is enabled but disableJobProcessing = true", () => {
+    beforeEach(() =>
+      PlatformTest.create({
+        pulse: {
+          enabled: true,
+          disableJobProcessing: true
+        }
+      })
+    );
+    afterEach(() => PlatformTest.reset());
+
+    describe("$afterListen()", () => {
+      it("should load all jobs", async () => {
+        const pulseModule = PlatformTest.get<any>(PulseModule)!;
+        const campaign = PlatformTest.get<CustomCampaign>(CustomCampaign)!;
+
+        await pulseModule.$afterListen();
+
+        expect(pulseModule.pulse.define).not.toHaveBeenCalled();
+        expect(pulseModule.pulse.every).not.toHaveBeenCalled();
+        expect(pulseModule.pulse.start).toHaveBeenCalledWith();
+        expect(pulseModule.pulse.create).not.toHaveBeenCalled();
+
+        expect(campaign.job).toBeUndefined();
+      });
+    });
+  });
+
+  describe("when pulse is disabled", () => {
+    beforeEach(() =>
+      PlatformTest.create({
+        pulse: {
+          enabled: false
+        }
+      })
+    );
+    afterEach(() => PlatformTest.reset());
+
+    describe("$afterListen()", () => {
+      it("should load all jobs", async () => {
+        const pulseModule = PlatformTest.get<any>(PulseModule)!;
+        const campaign = PlatformTest.get<CustomCampaign>(CustomCampaign)!;
+
+        await pulseModule.$afterListen();
+
+        expect(pulseModule.pulse.define).toBeUndefined();
+
+        expect(campaign.job).toBeUndefined();
+      });
+    });
+
+    describe("$onDestroy()", () => {
+      it("should do nothing", async () => {
+        const pulseModule = PlatformTest.get<any>(PulseModule)!;
+
+        await pulseModule.$onDestroy();
+      });
+    });
+  });
+});

package/src/PulseModule.ts

@@ -0,0 +1,156 @@
+import {DefineOptions, Job, JobAttributesData, Processor} from "@pulsecron/pulse";
+import {Constant, DIContext, Inject, InjectorService, Module, OnDestroy, Provider, runInContext} from "@tsed/di";
+import {Logger} from "@tsed/logger";
+import {AfterListen} from "@tsed/platform-http";
+import {v4 as uuid} from "uuid";
+
+import {PROVIDER_TYPE_PULSE} from "./constants/constants.js";
+import {PulseStore} from "./interfaces/PulseStore.js";
+import {PulseService} from "./services/PulseFactory.js";
+
+@Module()
+export class PulseModule implements OnDestroy, AfterListen {
+  @Inject()
+  protected logger: Logger;
+
+  @Inject()
+  protected injector: InjectorService;
+
+  @Inject()
+  protected pulse: PulseService;
+
+  @Constant("pulse.enabled", false)
+  private enabled: boolean;
+
+  @Constant("pulse.drainJobsBeforeClose", false)
+  private drainJobsBeforeClose: boolean;
+
+  @Constant("pulse.disableJobProcessing", false)
+  private disableJobProcessing: boolean;
+
+  async $afterListen(): Promise<any> {
+    if (this.enabled) {
+      const providers = this.getProviders();
+
+      if (!this.disableJobProcessing) {
+        this.logger.info({
+          event: "PULSE_ADD_DEFINITIONS",
+          message: "Pulse add definitions"
+        });
+        providers.forEach((provider) => this.addPulseDefinitionsForProvider(provider));
+
+        await this.injector.emit("$beforePulseStart");
+      }
+
+      await this.pulse.start();
+
+      if (!this.disableJobProcessing) {
+        this.logger.info({
+          event: "PULSE_ADD_JOBS",
+          message: "Pulse add scheduled jobs"
+        });
+        await Promise.all(providers.map((provider) => this.scheduleJobsForProvider(provider)));
+
+        await this.injector.emit("$afterPulseStart");
+      }
+    }
+  }
+
+  async $onDestroy(): Promise<any> {
+    if (this.enabled) {
+      if (this.drainJobsBeforeClose && "drain" in this.pulse) {
+        this.logger.info({
+          event: "PULSE_DRAIN",
+          message: "Pulse is draining all jobs before close"
+        });
+        await this.pulse.drain();
+      } else {
+        this.logger.info({
+          event: "PULSE_STOP",
+          message: "Pulse is stopping"
+        });
+        await this.pulse.stop();
+      }
+
+      await this.pulse.close({force: true});
+
+      this.logger.info({event: "PULSE_STOP", message: "Pulse stopped"});
+    }
+  }
+
+  define<T extends JobAttributesData>(name: string, processor: Processor<T>, options?: DefineOptions) {
+    return this.pulse.define(
+      name,
+      (job: Job<T>, ...rest) => {
+        const $ctx = new DIContext({
+          injector: this.injector,
+          id: uuid(),
+          logger: this.injector.logger
+        });
+
+        $ctx.set("job", job);
+
+        return runInContext($ctx, () => processor(job, ...rest));
+      },
+      options
+    );
+  }
+
+  every(interval: string, name: string, data?: any, options?: any) {
+    return this.pulse.every(interval, name, data, options);
+  }
+
+  schedule(when: Date | string, name: string, data?: any) {
+    return this.pulse.schedule(when, name, data);
+  }
+
+  now(name: string, data?: any) {
+    return this.pulse.now(name, data);
+  }
+
+  create(name: string, data?: any) {
+    return this.pulse.create(name, data);
+  }
+
+  protected getProviders(): Provider<any>[] {
+    return this.injector.getProviders(PROVIDER_TYPE_PULSE);
+  }
+
+  protected addPulseDefinitionsForProvider(provider: Provider): void {
+    const store = provider.store.get<PulseStore>("pulse", {});
+
+    if (!store.define) {
+      return;
+    }
+
+    Object.entries(store.define).forEach(([propertyKey, {name, ...options}]) => {
+      const instance = this.injector.get(provider.token);
+
+      const jobProcessor: Processor<never> = instance[propertyKey].bind(instance) as Processor<never>;
+      const jobName = this.getNameForJob(propertyKey, store.namespace, name);
+
+      this.define(jobName, jobProcessor, options);
+    });
+  }
+
+  protected async scheduleJobsForProvider(provider: Provider<any>): Promise<void> {
+    const store = provider.store.get<PulseStore>("pulse", {});
+
+    if (!store.every) {
+      return;
+    }
+
+    const promises = Object.entries(store.every).map(([propertyKey, {interval, name, ...options}]) => {
+      const jobName = this.getNameForJob(propertyKey, store.namespace, name);
+
+      return this.every(interval, jobName, {}, options);
+    });
+
+    await Promise.all(promises);
+  }
+
+  protected getNameForJob(propertyKey: string, namespace?: string, customName?: string): string {
+    const name = customName || propertyKey;
+    return namespace ? `${namespace}.${name}` : name;
+  }
+}

package/src/constants/constants.ts

@@ -0,0 +1 @@
+export const PROVIDER_TYPE_PULSE = "PROVIDER_TYPE_PULSE";

package/src/decorators/define.spec.ts

@@ -0,0 +1,49 @@
+import {Store} from "@tsed/core";
+
+import {Define} from "./define.js";
+import {Pulse} from "./pulse.js";
+
+describe("@Define()", () => {
+  it("should set empty metadata", () => {
+    @Pulse()
+    class Test {
+      @Define()
+      testDefineDecorator() {
+        // test
+      }
+
+      @Define()
+      testDefineDecorator2() {
+        // test 2
+      }
+    }
+
+    const store = Store.from(Test);
+
+    expect(store.get("pulse").define).toEqual({
+      testDefineDecorator: {},
+      testDefineDecorator2: {}
+    });
+  });
+
+  it("should set options metadata", () => {
+    @Pulse()
+    class Test {
+      @Define({
+        name: "testDefineDecoratorCustomName",
+        priority: "highest"
+      })
+      test() {
+        // test
+      }
+    }
+
+    const store = Store.from(Test);
+    expect(store.get("pulse").define).toEqual({
+      test: {
+        name: "testDefineDecoratorCustomName",
+        priority: "highest"
+      }
+    });
+  });
+});

package/src/decorators/define.ts

@@ -0,0 +1,15 @@
+import {Store} from "@tsed/core";
+
+import {DefineOptions, PulseStore} from "../interfaces/PulseStore.js";
+
+export function Define(options: DefineOptions = {}): MethodDecorator {
+  return (target: any, propertyKey: string) => {
+    const store: PulseStore = {
+      define: {
+        [propertyKey]: options
+      }
+    };
+
+    Store.from(target).merge("pulse", store);
+  };
+}

package/src/decorators/every.spec.ts

@@ -0,0 +1,37 @@
+import {Store} from "@tsed/core";
+
+import {Every} from "./every.js";
+import {Pulse} from "./pulse.js";
+
+describe("@Every()", () => {
+  it("should set metadata", () => {
+    @Pulse()
+    class Test {
+      @Every("60 seconds")
+      testEveryDecorator() {
+        // test
+      }
+
+      @Every("* * * * *")
+      testEveryDecorator2() {
+        // test 2
+      }
+    }
+
+    const store = Store.from(Test);
+
+    expect(store.get("pulse").define).toEqual({
+      testEveryDecorator: {},
+      testEveryDecorator2: {}
+    });
+
+    expect(store.get("pulse").every).toEqual({
+      testEveryDecorator: {
+        interval: "60 seconds"
+      },
+      testEveryDecorator2: {
+        interval: "* * * * *"
+      }
+    });
+  });
+});

package/src/decorators/every.ts

@@ -0,0 +1,15 @@
+import {Store, useDecorators} from "@tsed/core";
+
+import {EveryOptions, PulseStore} from "../interfaces/PulseStore.js";
+import {Define} from "./define.js";
+
+export function Every(interval: string, options: EveryOptions = {}): MethodDecorator {
+  return useDecorators(Define(options), (target: any, propertyKey: string) => {
+    const store: PulseStore = {
+      every: {
+        [propertyKey]: {...options, interval}
+      }
+    };
+    Store.from(target).merge("pulse", store);
+  });
+}

package/src/decorators/pulse.spec.ts

@@ -0,0 +1,22 @@
+import {Store} from "@tsed/core";
+
+import {Pulse} from "./pulse.js";
+
+describe("@Pulse()", () => {
+  it("should set empty metadata", () => {
+    @Pulse()
+    class Test {}
+
+    const store = Store.from(Test);
+    expect(store.get("pulse")).toEqual(undefined);
+  });
+  it("should set namespace metadata", () => {
+    @Pulse({namespace: "nsp1"})
+    class Test {}
+
+    const store = Store.from(Test);
+    expect(store.get("pulse")).toEqual({
+      namespace: "nsp1"
+    });
+  });
+});

package/src/decorators/pulse.ts

@@ -0,0 +1,17 @@
+import {StoreMerge, useDecorators} from "@tsed/core";
+import {Injectable} from "@tsed/di";
+
+import {PROVIDER_TYPE_PULSE} from "../constants/constants.js";
+
+interface PulseOptions {
+  namespace?: string;
+}
+
+export function Pulse(options?: PulseOptions): ClassDecorator {
+  return useDecorators(
+    options?.namespace && StoreMerge("pulse", options),
+    Injectable({
+      type: PROVIDER_TYPE_PULSE
+    })
+  );
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+/**
+ * @file Automatically generated by @tsed/barrels.
+ */
+export * from "./constants/constants.js";
+export * from "./decorators/define.js";
+export * from "./decorators/every.js";
+export * from "./decorators/pulse.js";
+export * from "./interfaces/interfaces.js";
+export * from "./interfaces/PulseStore.js";
+export * from "./PulseModule.js";
+export * from "./services/PulseFactory.js";

package/src/interfaces/PulseStore.ts

@@ -0,0 +1,13 @@
+import {DefineOptions as PulseDefineOptions, JobOptions} from "@pulsecron/pulse";
+
+export interface DefineOptions extends PulseDefineOptions {
+  name?: string;
+}
+
+export type EveryOptions = JobOptions & DefineOptions;
+
+export interface PulseStore {
+  namespace?: string;
+  define?: {[propertyKey: string]: DefineOptions};
+  every?: {[propertyKey: string]: EveryOptions & {interval: string}};
+}

package/src/interfaces/interfaces.ts

@@ -0,0 +1,16 @@
+import {PulseConfig} from "@pulsecron/pulse";
+
+declare global {
+  namespace TsED {
+    interface Configuration {
+      pulse?: {
+        /**
+         * Enable Pulse jobs. Default false.
+         */
+        enabled?: boolean;
+        disableJobProcessing?: boolean;
+        drainJobsBeforeClose?: boolean;
+      } & PulseConfig;
+    }
+  }
+}

package/src/services/PulseFactory.ts

@@ -0,0 +1,15 @@
+import {Pulse, PulseConfig} from "@pulsecron/pulse";
+import {Configuration, registerProvider} from "@tsed/di";
+
+// create Alias to avoid confusing import between Pulse from "@pulsecron/pulse" and Pulse decorator
+export const PulseService = Pulse;
+export type PulseService = Pulse;
+
+registerProvider({
+  token: Pulse,
+  deps: [Configuration],
+  useFactory(settings: Configuration) {
+    const opts = settings.get<PulseConfig & {enabled: boolean}>("pulse", {enabled: false});
+    return opts.enabled ? new Pulse(opts) : {};
+  }
+});