@wavezync/nestjs-pgboss 5.1.0 → 6.0.0

package/test/pgboss.module.spec.ts

@@ -0,0 +1,123 @@
+jest.mock("pg-boss", () => {
+  return {
+    PgBoss: jest.fn().mockImplementation(() => ({
+      on: jest.fn(),
+      start: jest.fn(),
+      stop: jest.fn(),
+    })),
+  };
+});
+
+import { PgBossModule } from "../lib/pgboss.module";
+import { HandlerScannerService } from "../lib/handler-scanner.service";
+import { PgBossService } from "../lib/pgboss.service";
+import { PGBOSS_OPTIONS, PGBOSS_TOKEN } from "../lib/utils/consts";
+import { MetadataScanner } from "@nestjs/core";
+
+describe("PgBossModule", () => {
+  let mockBoss: any;
+  let mockHandlerScanner: jest.Mocked<
+    Pick<HandlerScannerService, "scanAndRegisterHandlers">
+  >;
+  let module: PgBossModule;
+
+  beforeEach(() => {
+    mockBoss = {
+      on: jest.fn(),
+      stop: jest.fn().mockResolvedValue(undefined),
+    };
+    mockHandlerScanner = {
+      scanAndRegisterHandlers: jest.fn().mockResolvedValue(undefined),
+    };
+    module = new PgBossModule(mockBoss, mockHandlerScanner as any);
+  });
+
+  it("should register error event listener on boss in constructor", () => {
+    expect(mockBoss.on).toHaveBeenCalledWith("error", expect.any(Function));
+  });
+
+  describe("onApplicationBootstrap", () => {
+    it("should call scanAndRegisterHandlers", async () => {
+      await module.onApplicationBootstrap();
+      expect(mockHandlerScanner.scanAndRegisterHandlers).toHaveBeenCalled();
+    });
+  });
+
+  describe("onModuleDestroy", () => {
+    it("should call boss.stop()", async () => {
+      await module.onModuleDestroy();
+      expect(mockBoss.stop).toHaveBeenCalled();
+    });
+
+    it("should catch and log errors from boss.stop()", async () => {
+      mockBoss.stop.mockRejectedValue(new Error("stop failed"));
+      // Should not throw
+      await expect(module.onModuleDestroy()).resolves.not.toThrow();
+    });
+  });
+
+  describe("forRootAsync", () => {
+    it("should return correct module structure with useFactory", () => {
+      const factory = jest.fn();
+      const result = PgBossModule.forRootAsync({
+        useFactory: factory,
+        inject: ["CONFIG"],
+      });
+
+      expect(result.module).toBe(PgBossModule);
+      expect(result.exports).toContain(PgBossService);
+      expect(result.exports).toContain(PGBOSS_TOKEN);
+
+      const providerTokens = (result.providers as any[]).map(
+        (p: any) => p.provide || p,
+      );
+      expect(providerTokens).toContain(PGBOSS_OPTIONS);
+      expect(providerTokens).toContain(PGBOSS_TOKEN);
+      expect(providerTokens).toContain(PgBossService);
+      expect(providerTokens).toContain(HandlerScannerService);
+      expect(providerTokens).toContain(MetadataScanner);
+    });
+
+    it("should return correct module structure with useClass", () => {
+      class TestOptionsFactory {
+        createPgBossOptions() {
+          return { connectionString: "postgres://localhost/test" };
+        }
+      }
+
+      const result = PgBossModule.forRootAsync({
+        useClass: TestOptionsFactory,
+      });
+
+      expect(result.module).toBe(PgBossModule);
+      expect(result.exports).toContain(PgBossService);
+      expect(result.exports).toContain(PGBOSS_TOKEN);
+
+      const providerTokens = (result.providers as any[]).map(
+        (p: any) => p.provide || p,
+      );
+      expect(providerTokens).toContain(PGBOSS_OPTIONS);
+      expect(providerTokens).toContain(PGBOSS_TOKEN);
+      // useClass also adds the class itself as a provider
+      expect(providerTokens).toContain(TestOptionsFactory);
+    });
+
+    it("should pass imports through", () => {
+      const fakeModule = { module: class FakeModule {} } as any;
+      const result = PgBossModule.forRootAsync({
+        imports: [fakeModule],
+        useFactory: jest.fn(),
+      });
+
+      expect(result.imports).toContain(fakeModule);
+    });
+
+    it("should default imports to empty array", () => {
+      const result = PgBossModule.forRootAsync({
+        useFactory: jest.fn(),
+      });
+
+      expect(result.imports).toEqual([]);
+    });
+  });
+});

package/test/pgboss.service.spec.ts

@@ -19,10 +19,10 @@ jest.mock("pg-boss", () => {
 
 describe("PgBossService", () => {
   let service: PgBossService;
-  let mockPgBoss: any;
+  let mockPgBoss: jest.Mocked<PgBoss>;
 
   beforeEach(async () => {
-    mockPgBoss = new PgBoss("connectionString");
+    mockPgBoss = new PgBoss("connectionString") as jest.Mocked<PgBoss>;
     mockPgBoss.createQueue.mockResolvedValue(undefined);
     mockPgBoss.send.mockResolvedValue("job-id");
     mockPgBoss.schedule.mockResolvedValue(undefined);
@@ -49,6 +49,7 @@ describe("PgBossService", () => {
 
       await service.registerJob("test-job", handler, options);
 
+      // eslint-disable-next-line @typescript-eslint/unbound-method
       expect(mockPgBoss.work).toHaveBeenCalledWith(
         "test-job",
         { includeMetadata: true },
@@ -63,8 +64,64 @@ describe("PgBossService", () => {
 
       await service.scheduleJob("test-job", data, {});
 
+      // eslint-disable-next-line @typescript-eslint/unbound-method
       expect(mockPgBoss.send).toHaveBeenCalledWith("test-job", data, {});
     });
+
+    it("should call createQueue before send", async () => {
+      const callOrder: string[] = [];
+      mockPgBoss.createQueue.mockImplementation(() => {
+        callOrder.push("createQueue");
+        return Promise.resolve();
+      });
+      mockPgBoss.send.mockImplementation(() => {
+        callOrder.push("send");
+        return Promise.resolve("job-id");
+      });
+
+      await service.scheduleJob("test-job", {});
+
+      expect(callOrder).toEqual(["createQueue", "send"]);
+    });
+  });
+
+  describe("scheduleCronJob", () => {
+    it("should call createQueue then schedule with correct params", async () => {
+      await service.scheduleCronJob(
+        "cron-job",
+        "0 * * * *",
+        { key: "val" },
+        { tz: "UTC" },
+      );
+
+      // eslint-disable-next-line @typescript-eslint/unbound-method
+      expect(mockPgBoss.createQueue).toHaveBeenCalledWith("cron-job");
+      // eslint-disable-next-line @typescript-eslint/unbound-method
+      expect(mockPgBoss.schedule).toHaveBeenCalledWith(
+        "cron-job",
+        "0 * * * *",
+        { key: "val" },
+        { tz: "UTC" },
+      );
+    });
+
+    it("should use {} defaults when data/options are omitted", async () => {
+      await service.scheduleCronJob("cron-job", "0 * * * *");
+
+      // eslint-disable-next-line @typescript-eslint/unbound-method
+      expect(mockPgBoss.schedule).toHaveBeenCalledWith(
+        "cron-job",
+        "0 * * * *",
+        {},
+        {},
+      );
+    });
+  });
+
+  describe("boss getter", () => {
+    it("should return the PgBoss instance", () => {
+      expect(service.boss).toBe(mockPgBoss);
+    });
   });
 
   describe("registerCronJob", () => {
@@ -82,12 +139,14 @@ describe("PgBossService", () => {
         options,
       );
 
+      // eslint-disable-next-line @typescript-eslint/unbound-method
       expect(mockPgBoss.schedule).toHaveBeenCalledWith(
         "test-cron-job",
         cron,
         data,
         { tz: "UTC" },
       );
+      // eslint-disable-next-line @typescript-eslint/unbound-method
       expect(mockPgBoss.work).toHaveBeenCalledWith(
         "test-cron-job",
         { includeMetadata: true, tz: "UTC" },

package/.eslintrc.js

@@ -1,33 +0,0 @@
-/** @type {import('eslint').ESLint.ConfigData} */
-module.exports = {
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    project: 'tsconfig.json',
-    sourceType: 'module',
-  },
-  plugins: ['@typescript-eslint/eslint-plugin'],
-  extends: [
-    'plugin:@typescript-eslint/recommended',
-    'plugin:prettier/recommended',
-  ],
-  root: true,
-  env: {
-    node: true,
-    jest: true,
-  },
-  ignorePatterns: ['.eslintrc.js', 'tools/**'],
-  rules: {
-    '@typescript-eslint/interface-name-prefix': 'off',
-    '@typescript-eslint/explicit-function-return-type': 'off',
-    '@typescript-eslint/explicit-module-boundary-types': 'off',
-    '@typescript-eslint/no-explicit-any': 'off',
-    "@typescript-eslint/no-unused-vars": [
-      "error",
-      {
-        "args": "all",
-        "argsIgnorePattern": "^_",
-        "varsIgnorePattern": "^_",
-      }
-    ],
-  },
-};