@constructive-io/knative-job-fn 0.2.4

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.2.4 (2025-12-18)
+
+**Note:** Version bump only for package @constructive-io/knative-job-fn
+
+## [0.2.3](https://github.com/constructive-io/jobs/compare/@launchql/knative-job-fn@0.2.2...@launchql/knative-job-fn@0.2.3) (2025-12-17)
+
+**Note:** Version bump only for package @launchql/knative-job-fn

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 @@
+# knative-job-fn

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    post: (...args: any[]) => any;
+    listen: (port: any, cb?: () => void) => void;
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const body_parser_1 = __importDefault(require("body-parser"));
+const node_http_1 = __importDefault(require("node:http"));
+const node_https_1 = __importDefault(require("node:https"));
+const node_url_1 = require("node:url");
+const app = (0, express_1.default)();
+app.use(body_parser_1.default.json());
+// Echo job headers back on responses for debugging/traceability.
+app.use((req, res, next) => {
+    res.set({
+        'Content-Type': 'application/json',
+        'X-Worker-Id': req.get('X-Worker-Id'),
+        'X-Database-Id': req.get('X-Database-Id'),
+        'X-Job-Id': req.get('X-Job-Id')
+    });
+    next();
+});
+// Normalize callback URL so it always points at the /callback endpoint.
+const normalizeCallbackUrl = (rawUrl) => {
+    try {
+        const url = new node_url_1.URL(rawUrl);
+        if (!url.pathname || url.pathname === '/') {
+            url.pathname = '/callback';
+        }
+        return url.toString();
+    }
+    catch {
+        return rawUrl;
+    }
+};
+const postJson = (urlStr, headers, body) => {
+    return new Promise((resolve, reject) => {
+        let url;
+        try {
+            url = new node_url_1.URL(urlStr);
+        }
+        catch (e) {
+            return reject(e);
+        }
+        const isHttps = url.protocol === 'https:';
+        const client = isHttps ? node_https_1.default : node_http_1.default;
+        const req = client.request({
+            hostname: url.hostname,
+            port: url.port || (isHttps ? 443 : 80),
+            path: url.pathname + url.search,
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...headers
+            }
+        }, (res) => {
+            // Drain response data but ignore contents; callback server
+            // only uses status for debugging.
+            res.on('data', () => { });
+            res.on('end', () => resolve());
+        });
+        req.on('error', (err) => reject(err));
+        req.write(JSON.stringify(body));
+        req.end();
+    });
+};
+const sendJobCallback = async (ctx, status, errorMessage) => {
+    const { callbackUrl, workerId, jobId, databaseId } = ctx;
+    if (!callbackUrl || !workerId || !jobId) {
+        return;
+    }
+    const target = normalizeCallbackUrl(callbackUrl);
+    const headers = {
+        'X-Worker-Id': workerId,
+        'X-Job-Id': jobId
+    };
+    if (databaseId) {
+        headers['X-Database-Id'] = databaseId;
+    }
+    const body = {
+        status
+    };
+    if (status === 'error') {
+        headers['X-Job-Error'] = 'true';
+        body.error = errorMessage || 'ERROR';
+    }
+    try {
+        // eslint-disable-next-line no-console
+        console.log('[knative-job-fn] Sending job callback', {
+            status,
+            target: normalizeCallbackUrl(callbackUrl),
+            workerId,
+            jobId,
+            databaseId
+        });
+        await postJson(target, headers, body);
+    }
+    catch (err) {
+        // eslint-disable-next-line no-console
+        console.error('[knative-job-fn] Failed to POST job callback', {
+            target,
+            status,
+            err
+        });
+    }
+};
+// Attach per-request context and a finish hook to send success callbacks.
+app.use((req, res, next) => {
+    const ctx = {
+        callbackUrl: req.get('X-Callback-Url'),
+        workerId: req.get('X-Worker-Id'),
+        jobId: req.get('X-Job-Id'),
+        databaseId: req.get('X-Database-Id')
+    };
+    // Store on res.locals so the error middleware can also mark callbacks as sent.
+    res.locals = res.locals || {};
+    res.locals.jobContext = ctx;
+    res.locals.jobCallbackSent = false;
+    if (ctx.callbackUrl && ctx.workerId && ctx.jobId) {
+        res.on('finish', () => {
+            // If an error handler already sent a callback, skip.
+            if (res.locals.jobCallbackSent)
+                return;
+            res.locals.jobCallbackSent = true;
+            void sendJobCallback(ctx, 'success');
+        });
+    }
+    next();
+});
+exports.default = {
+    post: function (...args) {
+        return app.post.apply(app, args);
+    },
+    listen: (port, cb = () => { }) => {
+        // NOTE Remember that Express middleware executes in order.
+        // You should define error handlers last, after all other middleware.
+        // Otherwise, your error handler won't get called
+        // eslint-disable-next-line no-unused-vars
+        app.use(async (error, req, res, next) => {
+            res.set({
+                'Content-Type': 'application/json',
+                'X-Job-Error': true
+            });
+            // Mark job as having errored via callback, if available.
+            try {
+                const ctx = res.locals?.jobContext;
+                if (ctx && !res.locals.jobCallbackSent) {
+                    res.locals.jobCallbackSent = true;
+                    await sendJobCallback(ctx, 'error', error?.message);
+                }
+            }
+            catch (err) {
+                // eslint-disable-next-line no-console
+                console.error('[knative-job-fn] Failed to send error callback', err);
+            }
+            res.status(200).json({ message: error.message });
+        });
+        app.listen(port, cb);
+    }
+};

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/knative-job-fn",
+  "version": "0.2.4",
+  "description": "knative job fn",
+  "author": "Constructive <developers@constructive.io>",
+  "homepage": "https://github.com/constructive-io/jobs/tree/master/packages/knative-job-fn#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": {
+    "body-parser": "1.19.0",
+    "express": "4.17.1"
+  },
+  "gitHead": "86d74dc4fce9051df0d2b5bcc163607aba42f009"
+}

package/src/index.ts

@@ -0,0 +1,192 @@
+import express from 'express';
+import bodyParser from 'body-parser';
+import http from 'node:http';
+import https from 'node:https';
+import { URL } from 'node:url';
+
+type JobCallbackStatus = 'success' | 'error';
+
+type JobContext = {
+  callbackUrl: string | undefined;
+  workerId: string | undefined;
+  jobId: string | undefined;
+  databaseId: string | undefined;
+};
+
+const app: any = express();
+
+app.use(bodyParser.json());
+
+// Echo job headers back on responses for debugging/traceability.
+app.use((req: any, res: any, next: any) => {
+  res.set({
+    'Content-Type': 'application/json',
+    'X-Worker-Id': req.get('X-Worker-Id'),
+    'X-Database-Id': req.get('X-Database-Id'),
+    'X-Job-Id': req.get('X-Job-Id')
+  });
+  next();
+});
+
+// Normalize callback URL so it always points at the /callback endpoint.
+const normalizeCallbackUrl = (rawUrl: string): string => {
+  try {
+    const url = new URL(rawUrl);
+    if (!url.pathname || url.pathname === '/') {
+      url.pathname = '/callback';
+    }
+    return url.toString();
+  } catch {
+    return rawUrl;
+  }
+};
+
+const postJson = (
+  urlStr: string,
+  headers: Record<string, string>,
+  body: Record<string, unknown>
+): Promise<void> => {
+  return new Promise((resolve, reject) => {
+    let url: URL;
+    try {
+      url = new URL(urlStr);
+    } catch (e) {
+      return reject(e);
+    }
+
+    const isHttps = url.protocol === 'https:';
+    const client = isHttps ? https : http;
+
+    const req = client.request(
+      {
+        hostname: url.hostname,
+        port: url.port || (isHttps ? 443 : 80),
+        path: url.pathname + url.search,
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          ...headers
+        }
+      },
+      (res) => {
+        // Drain response data but ignore contents; callback server
+        // only uses status for debugging.
+        res.on('data', () => {});
+        res.on('end', () => resolve());
+      }
+    );
+
+    req.on('error', (err) => reject(err));
+    req.write(JSON.stringify(body));
+    req.end();
+  });
+};
+
+const sendJobCallback = async (
+  ctx: JobContext,
+  status: JobCallbackStatus,
+  errorMessage?: string
+) => {
+  const { callbackUrl, workerId, jobId, databaseId } = ctx;
+  if (!callbackUrl || !workerId || !jobId) {
+    return;
+  }
+
+  const target = normalizeCallbackUrl(callbackUrl);
+
+  const headers: Record<string, string> = {
+    'X-Worker-Id': workerId,
+    'X-Job-Id': jobId
+  };
+
+  if (databaseId) {
+    headers['X-Database-Id'] = databaseId;
+  }
+
+  const body: Record<string, unknown> = {
+    status
+  };
+
+  if (status === 'error') {
+    headers['X-Job-Error'] = 'true';
+    body.error = errorMessage || 'ERROR';
+  }
+
+  try {
+    // eslint-disable-next-line no-console
+    console.log('[knative-job-fn] Sending job callback', {
+      status,
+      target: normalizeCallbackUrl(callbackUrl),
+      workerId,
+      jobId,
+      databaseId
+    });
+    await postJson(target, headers, body);
+  } catch (err) {
+    // eslint-disable-next-line no-console
+    console.error('[knative-job-fn] Failed to POST job callback', {
+      target,
+      status,
+      err
+    });
+  }
+};
+
+// Attach per-request context and a finish hook to send success callbacks.
+app.use((req: any, res: any, next: any) => {
+  const ctx: JobContext = {
+    callbackUrl: req.get('X-Callback-Url'),
+    workerId: req.get('X-Worker-Id'),
+    jobId: req.get('X-Job-Id'),
+    databaseId: req.get('X-Database-Id')
+  };
+
+  // Store on res.locals so the error middleware can also mark callbacks as sent.
+  res.locals = res.locals || {};
+  res.locals.jobContext = ctx;
+  res.locals.jobCallbackSent = false;
+
+  if (ctx.callbackUrl && ctx.workerId && ctx.jobId) {
+    res.on('finish', () => {
+      // If an error handler already sent a callback, skip.
+      if (res.locals.jobCallbackSent) return;
+      res.locals.jobCallbackSent = true;
+      void sendJobCallback(ctx, 'success');
+    });
+  }
+
+  next();
+});
+
+export default {
+  post: function (...args: any[]) {
+    return app.post.apply(app, args as any);
+  },
+  listen: (port: any, cb: () => void = () => {}) => {
+    // NOTE Remember that Express middleware executes in order.
+    // You should define error handlers last, after all other middleware.
+    // Otherwise, your error handler won't get called
+    // eslint-disable-next-line no-unused-vars
+    app.use(async (error: any, req: any, res: any, next: any) => {
+      res.set({
+        'Content-Type': 'application/json',
+        'X-Job-Error': true
+      });
+
+      // Mark job as having errored via callback, if available.
+      try {
+        const ctx: JobContext | undefined = res.locals?.jobContext;
+        if (ctx && !res.locals.jobCallbackSent) {
+          res.locals.jobCallbackSent = true;
+          await sendJobCallback(ctx, 'error', error?.message);
+        }
+      } catch (err) {
+        // eslint-disable-next-line no-console
+        console.error('[knative-job-fn] Failed to send error callback', err);
+      }
+
+      res.status(200).json({ message: error.message });
+    });
+    app.listen(port, cb);
+  }
+};

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.*"]
+}