@tsed/pulse 8.11.2-rc.1 → 8.12.0-rc.1

package/lib/esm/decorators/pulse.js

@@ -1,8 +1,12 @@
 import { StoreMerge, useDecorators } from "@tsed/core";
 import { Injectable } from "@tsed/di";
 import { PROVIDER_TYPE_PULSE } from "../constants/constants.js";
-export function Pulse(options) {
+export function JobsController(options) {
     return useDecorators(options?.namespace && StoreMerge("pulse", options), Injectable({
         type: PROVIDER_TYPE_PULSE
     }));
 }
+/**
+ * @deprecated Use `JobsController` instead.
+ */
+export const Pulse = JobsController;

package/lib/esm/index.js

@@ -7,5 +7,4 @@ 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";
+export * from "./services/PulseService.js";

package/lib/esm/services/PulseService.js

@@ -0,0 +1,121 @@
+import { Pulse } from "@pulsecron/pulse";
+import { constant, DIContext, injectable, injector, logger, runInContext } from "@tsed/di";
+import { $asyncEmit } from "@tsed/hooks";
+import { v4 as uuid } from "uuid";
+import { PROVIDER_TYPE_PULSE } from "../constants/constants.js";
+function getOpts() {
+    return constant("pulse", { enabled: false });
+}
+function addPulseDefinitionsForProvider(pulse, provider) {
+    const store = provider.store.get("pulse", {});
+    if (!store.define) {
+        return;
+    }
+    Object.entries(store.define).forEach(([propertyKey, { name, ...options }]) => {
+        const instance = injector().get(provider.token);
+        const jobProcessor = instance[propertyKey].bind(instance);
+        const jobName = getNameForJob(propertyKey, store.namespace, name);
+        pulse.define(jobName, jobProcessor, options);
+    });
+}
+async function scheduleJobsForProvider(pulse, provider) {
+    const store = provider.store.get("pulse", {});
+    if (!store.every) {
+        return;
+    }
+    const promises = Object.entries(store.every).map(([propertyKey, { interval, name, ...options }]) => {
+        const jobName = getNameForJob(propertyKey, store.namespace, name);
+        return pulse.every(interval, jobName, {}, options);
+    });
+    await Promise.all(promises);
+}
+function getNameForJob(propertyKey, namespace, customName) {
+    const name = customName || propertyKey;
+    return namespace ? `${namespace}.${name}` : name;
+}
+async function afterListen(pulse) {
+    const opts = getOpts();
+    if (opts.enabled) {
+        const providers = injector().getProviders(PROVIDER_TYPE_PULSE);
+        if (!opts.disableJobProcessing) {
+            logger().info({
+                event: "PULSE_ADD_DEFINITIONS",
+                message: "Pulse add definitions"
+            });
+            providers.forEach((provider) => addPulseDefinitionsForProvider(pulse, provider));
+            await $asyncEmit("$beforePulseStart");
+        }
+        await pulse.start();
+        if (!opts.disableJobProcessing) {
+            logger().info({
+                event: "PULSE_ADD_JOBS",
+                message: "Pulse add scheduled jobs"
+            });
+            await Promise.all(providers.map((provider) => scheduleJobsForProvider(pulse, provider)));
+            await $asyncEmit("$afterPulseStart");
+        }
+    }
+}
+async function onDestroy(pulse) {
+    const opts = getOpts();
+    if (opts.enabled) {
+        if (opts.drainJobsBeforeClose && "drain" in pulse) {
+            logger().info({
+                event: "PULSE_DRAIN",
+                message: "Pulse is draining all jobs before close"
+            });
+            await pulse.drain();
+        }
+        else {
+            logger().info({
+                event: "PULSE_STOP",
+                message: "Pulse is stopping"
+            });
+            await pulse.stop();
+        }
+        await pulse.close({ force: true });
+        logger().info({ event: "PULSE_STOP", message: "Pulse stopped" });
+    }
+}
+export const PulseService = injectable(Pulse)
+    .factory(() => {
+    const opts = getOpts();
+    if (opts.enabled) {
+        const pulse = new Pulse(opts);
+        return new Proxy(pulse, {
+            set(target, prop, value) {
+                return Reflect.set(target, prop, value);
+            },
+            get(target, prop) {
+                if (prop === "pulse") {
+                    return target;
+                }
+                if (prop === "$define") {
+                    return Reflect.get(target, "define", target);
+                }
+                if (prop === "define") {
+                    return (name, processor, options) => {
+                        return target["define"](name, (job) => {
+                            const $ctx = new DIContext({
+                                id: uuid()
+                            });
+                            $ctx.set("job", job);
+                            return runInContext($ctx, () => processor(job));
+                        }, options);
+                    };
+                }
+                return Reflect.get(target, prop, target);
+            }
+        });
+    }
+    return new Proxy({}, { get: () => () => Promise.resolve() });
+})
+    .hooks({
+    $afterListen: afterListen,
+    $onDestroy: onDestroy
+})
+    .token();
+/**
+ * @deprecated Use `Pulse` from `pulse` instead.
+ */
+export const PulseModule = Pulse;

package/lib/types/decorators/pulse.d.ts

@@ -1,5 +1,9 @@
 interface PulseOptions {
     namespace?: string;
 }
-export declare function Pulse(options?: PulseOptions): ClassDecorator;
+export declare function JobsController(options?: PulseOptions): ClassDecorator;
+/**
+ * @deprecated Use `JobsController` instead.
+ */
+export declare const Pulse: typeof JobsController;
 export {};

package/lib/types/index.d.ts

@@ -7,5 +7,4 @@ 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";
+export * from "./services/PulseService.js";

package/lib/types/interfaces/interfaces.d.ts

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

package/lib/types/services/PulseService.d.ts

@@ -0,0 +1,13 @@
+import { Pulse } from "@pulsecron/pulse";
+export declare const PulseService: {
+    readonly __type: "token_factory";
+};
+/**
+ * @deprecated Use `Pulse` from `pulse` instead.
+ */
+export type PulseService = Pulse;
+/**
+ * @deprecated Use `Pulse` from `pulse` instead.
+ */
+export declare const PulseModule: typeof Pulse;
+export type PulseModule = Pulse;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tsed/pulse",
   "description": "@pulsecron/pulse package for Ts.ED framework",
   "type": "module",
-  "version": "8.11.2-rc.1",
+  "version": "8.12.0-rc.1",
   "source": "./src/index.ts",
   "main": "./lib/esm/index.js",
   "module": "./lib/esm/index.js",
@@ -27,11 +27,11 @@
   },
   "devDependencies": {
     "@pulsecron/pulse": "^1.6.3",
-    "@tsed/barrels": "8.11.2-rc.1",
-    "@tsed/core": "8.11.2-rc.1",
-    "@tsed/di": "8.11.2-rc.1",
-    "@tsed/platform-http": "8.11.2-rc.1",
-    "@tsed/typescript": "8.11.2-rc.1",
+    "@tsed/barrels": "8.12.0-rc.1",
+    "@tsed/core": "8.12.0-rc.1",
+    "@tsed/di": "8.12.0-rc.1",
+    "@tsed/platform-http": "8.12.0-rc.1",
+    "@tsed/typescript": "8.12.0-rc.1",
     "eslint": "9.12.0",
     "typescript": "5.4.5",
     "vitest": "3.1.4"

package/lib/esm/PulseModule.js

@@ -1,131 +0,0 @@
-import { __decorate, __metadata } from "tslib";
-import { Constant, DIContext, Inject, InjectorService, Module, runInContext } from "@tsed/di";
-import { Logger } from "@tsed/logger";
-import { v4 as uuid } from "uuid";
-import { PROVIDER_TYPE_PULSE } from "./constants/constants.js";
-import { PulseService } from "./services/PulseFactory.js";
-let PulseModule = class PulseModule {
-    async $afterListen() {
-        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() {
-        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(name, processor, options) {
-        return this.pulse.define(name, (job, ...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, name, data, options) {
-        return this.pulse.every(interval, name, data, options);
-    }
-    schedule(when, name, data) {
-        return this.pulse.schedule(when, name, data);
-    }
-    now(name, data) {
-        return this.pulse.now(name, data);
-    }
-    create(name, data) {
-        return this.pulse.create(name, data);
-    }
-    getProviders() {
-        return this.injector.getProviders(PROVIDER_TYPE_PULSE);
-    }
-    addPulseDefinitionsForProvider(provider) {
-        const store = provider.store.get("pulse", {});
-        if (!store.define) {
-            return;
-        }
-        Object.entries(store.define).forEach(([propertyKey, { name, ...options }]) => {
-            const instance = this.injector.get(provider.token);
-            const jobProcessor = instance[propertyKey].bind(instance);
-            const jobName = this.getNameForJob(propertyKey, store.namespace, name);
-            this.define(jobName, jobProcessor, options);
-        });
-    }
-    async scheduleJobsForProvider(provider) {
-        const store = provider.store.get("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);
-    }
-    getNameForJob(propertyKey, namespace, customName) {
-        const name = customName || propertyKey;
-        return namespace ? `${namespace}.${name}` : name;
-    }
-};
-__decorate([
-    Inject(),
-    __metadata("design:type", Logger)
-], PulseModule.prototype, "logger", void 0);
-__decorate([
-    Inject(),
-    __metadata("design:type", InjectorService)
-], PulseModule.prototype, "injector", void 0);
-__decorate([
-    Inject(),
-    __metadata("design:type", PulseService)
-], PulseModule.prototype, "pulse", void 0);
-__decorate([
-    Constant("pulse.enabled", false),
-    __metadata("design:type", Boolean)
-], PulseModule.prototype, "enabled", void 0);
-__decorate([
-    Constant("pulse.drainJobsBeforeClose", false),
-    __metadata("design:type", Boolean)
-], PulseModule.prototype, "drainJobsBeforeClose", void 0);
-__decorate([
-    Constant("pulse.disableJobProcessing", false),
-    __metadata("design:type", Boolean)
-], PulseModule.prototype, "disableJobProcessing", void 0);
-PulseModule = __decorate([
-    Module()
-], PulseModule);
-export { PulseModule };

package/lib/esm/services/PulseFactory.js

@@ -1,12 +0,0 @@
-import { Pulse } 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;
-registerProvider({
-    token: Pulse,
-    deps: [Configuration],
-    useFactory(settings) {
-        const opts = settings.get("pulse", { enabled: false });
-        return opts.enabled ? new Pulse(opts) : {};
-    }
-});

package/lib/types/PulseModule.d.ts

@@ -1,24 +0,0 @@
-import { DefineOptions, Job, JobAttributesData, Processor } from "@pulsecron/pulse";
-import { InjectorService, OnDestroy, Provider } from "@tsed/di";
-import { Logger } from "@tsed/logger";
-import { AfterListen } from "@tsed/platform-http";
-import { PulseService } from "./services/PulseFactory.js";
-export declare class PulseModule implements OnDestroy, AfterListen {
-    protected logger: Logger;
-    protected injector: InjectorService;
-    protected pulse: PulseService;
-    private enabled;
-    private drainJobsBeforeClose;
-    private disableJobProcessing;
-    $afterListen(): Promise<any>;
-    $onDestroy(): Promise<any>;
-    define<T extends JobAttributesData>(name: string, processor: Processor<T>, options?: DefineOptions): void;
-    every(interval: string, name: string, data?: any, options?: any): Promise<Job<JobAttributesData> | Job<JobAttributesData>[]>;
-    schedule(when: Date | string, name: string, data?: any): Promise<Job<{}>[]> | Promise<Job<any>>;
-    now(name: string, data?: any): Promise<Job<JobAttributesData>>;
-    create(name: string, data?: any): Job<any>;
-    protected getProviders(): Provider<any>[];
-    protected addPulseDefinitionsForProvider(provider: Provider): void;
-    protected scheduleJobsForProvider(provider: Provider<any>): Promise<void>;
-    protected getNameForJob(propertyKey: string, namespace?: string, customName?: string): string;
-}

package/lib/types/services/PulseFactory.d.ts

@@ -1,3 +0,0 @@
-import { Pulse } from "@pulsecron/pulse";
-export declare const PulseService: typeof Pulse;
-export type PulseService = Pulse;