@constructive-io/job-worker 0.3.7

package/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+## 0.3.7 (2025-12-18)
+
+**Note:** Version bump only for package @constructive-io/job-worker
+
+## [0.3.6](https://github.com/constructive-io/jobs/compare/@launchql/job-worker@0.3.5...@launchql/job-worker@0.3.6) (2025-12-17)
+
+**Note:** Version bump only for package @launchql/job-worker

package/LICENSE

@@ -0,0 +1,23 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Dan Lynch <pyramation@gmail.com>
+Copyright (c) 2025 Constructive <developers@constructive.io>
+Copyright (c) 2020-present, Interweb, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# job-worker

package/dist/env.d.ts

@@ -0,0 +1,11 @@
+declare const _default: Readonly<{
+    PGUSER: string;
+    PGHOST: string;
+    PGPASSWORD: string;
+    PGPORT: number;
+    PGDATABASE: string;
+    JOBS_SCHEMA: string;
+}> & import("envalid").CleanEnv & {
+    readonly [varName: string]: string;
+};
+export default _default;

package/dist/env.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const envalid_1 = require("envalid");
+exports.default = (0, envalid_1.cleanEnv)(process.env, {
+    PGUSER: (0, envalid_1.str)({ default: 'postgres' }),
+    PGHOST: (0, envalid_1.str)({ default: 'localhost' }),
+    PGPASSWORD: (0, envalid_1.str)({ default: 'password' }),
+    PGPORT: (0, envalid_1.port)({ default: 5432 }),
+    PGDATABASE: (0, envalid_1.str)({ default: 'jobs' }),
+    JOBS_SCHEMA: (0, envalid_1.str)({ default: 'app_jobs' })
+}, { dotEnvPath: null });

package/dist/index.d.ts

@@ -0,0 +1,46 @@
+import type { Pool } from 'pg';
+import type { PgClientLike } from '@constructive-io/job-utils';
+export interface JobRow {
+    id: number | string;
+    task_identifier: string;
+    payload?: unknown;
+}
+export interface WorkerContext {
+    pgPool: Pool;
+    workerId: string;
+}
+export type TaskHandler = (ctx: WorkerContext, job: JobRow) => Promise<void> | void;
+export default class Worker {
+    tasks: Record<string, TaskHandler>;
+    idleDelay: number;
+    supportedTaskNames: string[];
+    workerId: string;
+    doNextTimer?: NodeJS.Timeout;
+    pgPool: Pool;
+    _ended?: boolean;
+    constructor({ tasks, idleDelay, pgPool, workerId }: {
+        tasks: Record<string, TaskHandler>;
+        idleDelay?: number;
+        pgPool?: Pool;
+        workerId?: string;
+    });
+    close(): void;
+    handleFatalError({ err, fatalError, jobId }: {
+        err?: Error;
+        fatalError: unknown;
+        jobId: JobRow['id'];
+    }): void;
+    handleError(client: PgClientLike, { err, job, duration }: {
+        err: Error;
+        job: JobRow;
+        duration: string;
+    }): Promise<void>;
+    handleSuccess(client: PgClientLike, { job, duration }: {
+        job: JobRow;
+        duration: string;
+    }): Promise<void>;
+    doWork(job: JobRow): Promise<void>;
+    doNext(client: PgClientLike): Promise<void>;
+    listen(): void;
+}
+export { Worker };

package/dist/index.js

@@ -0,0 +1,192 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Worker = void 0;
+const pg_1 = __importDefault(require("pg"));
+const jobs = __importStar(require("@constructive-io/job-utils"));
+const pgPoolConfig = {
+    connectionString: jobs.getJobConnectionString()
+};
+function once(fn, context) {
+    let result;
+    return function (...args) {
+        if (fn) {
+            result = fn.apply((context ?? this), args);
+            fn = null;
+        }
+        return result;
+    };
+}
+/* eslint-disable no-console */
+class Worker {
+    tasks;
+    idleDelay;
+    supportedTaskNames;
+    workerId;
+    doNextTimer;
+    pgPool;
+    _ended;
+    // tasks is required; other options are optional
+    constructor({ tasks, idleDelay = 15000, pgPool = new pg_1.default.Pool(pgPoolConfig), workerId = jobs.getWorkerHostname() }) {
+        this.tasks = tasks;
+        /*
+         * idleDelay: This is how long to wait between polling for jobs.
+         *
+         * Note: this does NOT need to be short, because we use LISTEN/NOTIFY to be
+         * notified when new jobs are added - this is just used in the case where
+         * LISTEN/NOTIFY fails for whatever reason.
+         */
+        this.idleDelay = idleDelay;
+        this.supportedTaskNames = Object.keys(this.tasks);
+        this.workerId = workerId;
+        this.doNextTimer = undefined;
+        this.pgPool = pgPool;
+        const close = () => {
+            console.log('closing connection...');
+            this.close();
+        };
+        process.once('SIGTERM', close);
+        process.once('SIGINT', close);
+    }
+    close() {
+        if (!this._ended) {
+            this.pgPool.end();
+        }
+        this._ended = true;
+    }
+    handleFatalError({ err, fatalError, jobId }) {
+        const when = err ? `after failure '${err.message}'` : 'after success';
+        console.error(`Failed to release job '${jobId}' ${when}; committing seppuku`);
+        console.error(fatalError);
+        process.exit(1);
+    }
+    async handleError(client, { err, job, duration }) {
+        console.error(`Failed task ${job.id} (${job.task_identifier}) with error ${err.message} (${duration}ms)`, { err, stack: err.stack });
+        console.error(err.stack);
+        await jobs.failJob(client, {
+            workerId: this.workerId,
+            jobId: job.id,
+            message: err.message
+        });
+    }
+    async handleSuccess(client, { job, duration }) {
+        console.log(`Completed task ${job.id} (${job.task_identifier}) with success (${duration}ms)`);
+        await jobs.completeJob(client, { workerId: this.workerId, jobId: job.id });
+    }
+    async doWork(job) {
+        const { task_identifier } = job;
+        const worker = this.tasks[task_identifier];
+        if (!worker) {
+            throw new Error('Unsupported task');
+        }
+        await worker({
+            pgPool: this.pgPool,
+            workerId: this.workerId
+        }, job);
+    }
+    async doNext(client) {
+        if (this.doNextTimer) {
+            clearTimeout(this.doNextTimer);
+            this.doNextTimer = undefined;
+        }
+        try {
+            const job = (await jobs.getJob(client, {
+                workerId: this.workerId,
+                supportedTaskNames: this.supportedTaskNames
+            }));
+            if (!job || !job.id) {
+                this.doNextTimer = setTimeout(() => this.doNext(client), this.idleDelay);
+                return;
+            }
+            const start = process.hrtime();
+            let err = null;
+            try {
+                await this.doWork(job);
+            }
+            catch (error) {
+                err = error;
+            }
+            const durationRaw = process.hrtime(start);
+            const duration = ((durationRaw[0] * 1e9 + durationRaw[1]) / 1e6).toFixed(2);
+            const jobId = job.id;
+            try {
+                if (err) {
+                    await this.handleError(client, { err, job, duration });
+                }
+                else {
+                    await this.handleSuccess(client, { job, duration });
+                }
+            }
+            catch (fatalError) {
+                this.handleFatalError({ err, fatalError, jobId });
+            }
+            return this.doNext(client);
+        }
+        catch (err) {
+            this.doNextTimer = setTimeout(() => this.doNext(client), this.idleDelay);
+        }
+    }
+    listen() {
+        const listenForChanges = (err, client, release) => {
+            if (err) {
+                console.error('Error connecting with notify listener', err);
+                // Try again in 5 seconds
+                // should this really be done in the node process?
+                setTimeout(this.listen, 5000);
+                return;
+            }
+            client.on('notification', () => {
+                if (this.doNextTimer) {
+                    // Must be idle, do something!
+                    this.doNext(client);
+                }
+            });
+            client.query('LISTEN "jobs:insert"');
+            client.on('error', (e) => {
+                console.error('Error with database notify listener', e);
+                release();
+                this.listen();
+            });
+            console.log(`${this.workerId} connected and looking for jobs...`);
+            this.doNext(client);
+        };
+        this.pgPool.connect(listenForChanges);
+    }
+}
+exports.default = Worker;
+exports.Worker = Worker;

package/dist/run.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/run.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = __importDefault(require("./index"));
+const worker = new index_1.default({
+    tasks: {
+        hello: async ({ pgPool, workerId }, job) => {
+            console.log('hello');
+            await pgPool.query('select 1');
+            console.log(JSON.stringify(job, null, 2));
+        }
+    }
+});
+worker.listen();

package/jest.config.js

@@ -0,0 +1,18 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.tsx?$': [
+      'ts-jest',
+      {
+        babelConfig: false,
+        tsconfig: 'tsconfig.json',
+      },
+    ],
+  },
+  transformIgnorePatterns: [`/node_modules/*`],
+  testRegex: '(/__tests__/.*|(\\.|/)(test|spec))\\.(jsx?|tsx?)$',
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+  modulePathIgnorePatterns: ['dist/*'],
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@constructive-io/job-worker",
+  "version": "0.3.7",
+  "description": "job worker",
+  "author": "Constructive <developers@constructive.io>",
+  "homepage": "https://github.com/constructive-io/jobs/tree/master/packages/job-worker#readme",
+  "license": "SEE LICENSE IN LICENSE",
+  "main": "dist/index.js",
+  "directories": {
+    "lib": "src",
+    "test": "__tests__"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/constructive-io/jobs"
+  },
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:debug": "node --inspect node_modules/.bin/jest --runInBand",
+    "build": "tsc -p tsconfig.json",
+    "build:watch": "tsc -p tsconfig.json -w"
+  },
+  "bugs": {
+    "url": "https://github.com/constructive-io/jobs/issues"
+  },
+  "dependencies": {
+    "@constructive-io/job-utils": "^0.5.0",
+    "pg": "8.16.3"
+  },
+  "gitHead": "86d74dc4fce9051df0d2b5bcc163607aba42f009"
+}

package/src/index.ts

@@ -0,0 +1,220 @@
+import pg from 'pg';
+import type { Pool, PoolClient } from 'pg';
+import * as jobs from '@constructive-io/job-utils';
+import type { PgClientLike } from '@constructive-io/job-utils';
+
+const pgPoolConfig = {
+  connectionString: jobs.getJobConnectionString()
+};
+
+function once<T extends (...args: unknown[]) => unknown>(
+  fn: T,
+  context?: unknown
+): (...args: Parameters<T>) => ReturnType<T> | undefined {
+  let result: ReturnType<T> | undefined;
+  return function (this: unknown, ...args: Parameters<T>) {
+    if (fn) {
+      result = fn.apply((context ?? this) as never, args) as ReturnType<T>;
+      fn = null as unknown as T;
+    }
+    return result;
+  };
+}
+
+export interface JobRow {
+  id: number | string;
+  task_identifier: string;
+  payload?: unknown;
+}
+
+export interface WorkerContext {
+  pgPool: Pool;
+  workerId: string;
+}
+
+export type TaskHandler = (
+  ctx: WorkerContext,
+  job: JobRow
+) => Promise<void> | void;
+
+/* eslint-disable no-console */
+
+export default class Worker {
+  tasks: Record<string, TaskHandler>;
+  idleDelay: number;
+  supportedTaskNames: string[];
+  workerId: string;
+  doNextTimer?: NodeJS.Timeout;
+  pgPool: Pool;
+  _ended?: boolean;
+
+  // tasks is required; other options are optional
+  constructor({
+    tasks,
+    idleDelay = 15000,
+    pgPool = new (pg as any).Pool(pgPoolConfig),
+    workerId = jobs.getWorkerHostname()
+  }: {
+    tasks: Record<string, TaskHandler>;
+    idleDelay?: number;
+    pgPool?: Pool;
+    workerId?: string;
+  }) {
+    this.tasks = tasks;
+    /*
+     * idleDelay: This is how long to wait between polling for jobs.
+     *
+     * Note: this does NOT need to be short, because we use LISTEN/NOTIFY to be
+     * notified when new jobs are added - this is just used in the case where
+     * LISTEN/NOTIFY fails for whatever reason.
+     */
+    this.idleDelay = idleDelay;
+
+    this.supportedTaskNames = Object.keys(this.tasks);
+    this.workerId = workerId;
+    this.doNextTimer = undefined;
+    this.pgPool = pgPool;
+    const close = () => {
+      console.log('closing connection...');
+      this.close();
+    };
+    process.once('SIGTERM', close);
+    process.once('SIGINT', close);
+  }
+  close() {
+    if (!this._ended) {
+      this.pgPool.end();
+    }
+    this._ended = true;
+  }
+  handleFatalError({
+    err,
+    fatalError,
+    jobId
+  }: {
+    err?: Error;
+    fatalError: unknown;
+    jobId: JobRow['id'];
+  }) {
+    const when = err ? `after failure '${err.message}'` : 'after success';
+    console.error(
+      `Failed to release job '${jobId}' ${when}; committing seppuku`
+    );
+    console.error(fatalError);
+    process.exit(1);
+  }
+  async handleError(
+    client: PgClientLike,
+    { err, job, duration }: { err: Error; job: JobRow; duration: string }
+  ) {
+    console.error(
+      `Failed task ${job.id} (${job.task_identifier}) with error ${err.message} (${duration}ms)`,
+      { err, stack: err.stack }
+    );
+    console.error(err.stack);
+    await jobs.failJob(client, {
+      workerId: this.workerId,
+      jobId: job.id,
+      message: err.message
+    });
+  }
+  async handleSuccess(
+    client: PgClientLike,
+    { job, duration }: { job: JobRow; duration: string }
+  ) {
+    console.log(
+      `Completed task ${job.id} (${job.task_identifier}) with success (${duration}ms)`
+    );
+    await jobs.completeJob(client, { workerId: this.workerId, jobId: job.id });
+  }
+  async doWork(job: JobRow) {
+    const { task_identifier } = job;
+    const worker = this.tasks[task_identifier];
+    if (!worker) {
+      throw new Error('Unsupported task');
+    }
+    await worker(
+      {
+        pgPool: this.pgPool,
+        workerId: this.workerId
+      },
+      job
+    );
+  }
+  async doNext(client: PgClientLike): Promise<void> {
+    if (this.doNextTimer) {
+      clearTimeout(this.doNextTimer);
+      this.doNextTimer = undefined;
+    }
+    try {
+      const job = (await jobs.getJob<JobRow>(client, {
+        workerId: this.workerId,
+        supportedTaskNames: this.supportedTaskNames
+      })) as JobRow | undefined;
+      if (!job || !job.id) {
+        this.doNextTimer = setTimeout(
+          () => this.doNext(client),
+          this.idleDelay
+        );
+        return;
+      }
+      const start = process.hrtime();
+
+      let err: Error | null = null;
+      try {
+        await this.doWork(job);
+      } catch (error) {
+        err = error as Error;
+      }
+      const durationRaw = process.hrtime(start);
+      const duration = ((durationRaw[0] * 1e9 + durationRaw[1]) / 1e6).toFixed(
+        2
+      );
+      const jobId = job.id;
+      try {
+        if (err) {
+          await this.handleError(client, { err, job, duration });
+        } else {
+          await this.handleSuccess(client, { job, duration });
+        }
+      } catch (fatalError: unknown) {
+        this.handleFatalError({ err, fatalError, jobId });
+      }
+      return this.doNext(client);
+    } catch (err: unknown) {
+      this.doNextTimer = setTimeout(() => this.doNext(client), this.idleDelay);
+    }
+  }
+  listen() {
+    const listenForChanges = (
+      err: Error | null,
+      client: PoolClient,
+      release: () => void
+    ) => {
+      if (err) {
+        console.error('Error connecting with notify listener', err);
+        // Try again in 5 seconds
+        // should this really be done in the node process?
+        setTimeout(this.listen, 5000);
+        return;
+      }
+      client.on('notification', () => {
+        if (this.doNextTimer) {
+          // Must be idle, do something!
+          this.doNext(client);
+        }
+      });
+      client.query('LISTEN "jobs:insert"');
+      client.on('error', (e: unknown) => {
+        console.error('Error with database notify listener', e);
+        release();
+        this.listen();
+      });
+      console.log(`${this.workerId} connected and looking for jobs...`);
+      this.doNext(client);
+    };
+    this.pgPool.connect(listenForChanges);
+  }
+}
+
+export { Worker };

package/src/run.ts

@@ -0,0 +1,16 @@
+import Worker, { WorkerContext, JobRow } from './index';
+
+const worker = new Worker({
+  tasks: {
+    hello: async (
+      { pgPool, workerId }: WorkerContext,
+      job: JobRow
+    ) => {
+      console.log('hello');
+      await pgPool.query('select 1');
+      console.log(JSON.stringify(job, null, 2));
+    }
+  }
+});
+
+worker.listen();

package/tsconfig.esm.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist/esm",
+    "module": "es2022",
+    "rootDir": "src/",
+    "declaration": false
+  }
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src/"
+  },
+  "include": ["src/**/*.ts", "../../types/**/*.d.ts"],
+  "exclude": ["dist", "node_modules", "**/*.spec.*", "**/*.test.*"]
+}