@constructive-io/knative-job-service 0.6.15 → 0.7.0

package/dist/index.js

@@ -1,2 +1,371 @@
 "use strict";
-// noop
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bootJobs = exports.waitForJobsPrereqs = exports.startJobsServices = exports.startKnativeJobsSvcFromEnv = exports.buildKnativeJobsSvcOptionsFromEnv = exports.KnativeJobsSvc = void 0;
+const knative_job_server_1 = __importDefault(require("@constructive-io/knative-job-server"));
+const knative_job_worker_1 = __importDefault(require("@constructive-io/knative-job-worker"));
+const job_scheduler_1 = __importDefault(require("@constructive-io/job-scheduler"));
+const job_pg_1 = __importDefault(require("@constructive-io/job-pg"));
+const job_utils_1 = require("@constructive-io/job-utils");
+const env_1 = require("@pgpmjs/env");
+const logger_1 = require("@pgpmjs/logger");
+const async_retry_1 = __importDefault(require("async-retry"));
+const pg_1 = require("pg");
+const module_1 = require("module");
+const functionRegistry = {
+    'simple-email': {
+        moduleName: '@constructive-io/simple-email-fn',
+        defaultPort: 8081
+    },
+    'send-email-link': {
+        moduleName: '@constructive-io/send-email-link-fn',
+        defaultPort: 8082
+    }
+};
+const log = new logger_1.Logger('knative-job-service');
+const requireFn = (0, module_1.createRequire)(__filename);
+const resolveFunctionEntry = (name) => {
+    const entry = functionRegistry[name];
+    if (!entry) {
+        throw new Error(`Unknown function "${name}".`);
+    }
+    return entry;
+};
+const loadFunctionApp = (moduleName) => {
+    const knativeModuleId = requireFn.resolve('@constructive-io/knative-job-fn');
+    delete requireFn.cache[knativeModuleId];
+    const moduleId = requireFn.resolve(moduleName);
+    delete requireFn.cache[moduleId];
+    const mod = requireFn(moduleName);
+    const app = mod.default ?? mod;
+    if (!app || typeof app.listen !== 'function') {
+        throw new Error(`Function module "${moduleName}" does not export a listenable app.`);
+    }
+    return app;
+};
+const shouldEnableFunctions = (options) => {
+    if (!options)
+        return false;
+    if (typeof options.enabled === 'boolean')
+        return options.enabled;
+    return Boolean(options.services?.length);
+};
+const normalizeFunctionServices = (options) => {
+    if (!shouldEnableFunctions(options))
+        return [];
+    if (!options?.services?.length) {
+        return Object.keys(functionRegistry).map((name) => ({
+            name: name
+        }));
+    }
+    return options.services;
+};
+const resolveFunctionPort = (service) => {
+    const entry = resolveFunctionEntry(service.name);
+    return service.port ?? entry.defaultPort;
+};
+const ensureUniquePorts = (services) => {
+    const usedPorts = new Set();
+    for (const service of services) {
+        const port = resolveFunctionPort(service);
+        if (usedPorts.has(port)) {
+            throw new Error(`Function port ${port} is assigned more than once.`);
+        }
+        usedPorts.add(port);
+    }
+};
+const startFunction = async (service, functionServers) => {
+    const entry = resolveFunctionEntry(service.name);
+    const port = resolveFunctionPort(service);
+    const app = loadFunctionApp(entry.moduleName);
+    await new Promise((resolve, reject) => {
+        const server = app.listen(port, () => {
+            log.info(`function:${service.name} listening on ${port}`);
+            resolve();
+        });
+        if (server?.on) {
+            server.on('error', (err) => {
+                log.error(`function:${service.name} failed to start`, err);
+                reject(err);
+            });
+        }
+        functionServers.set(service.name, server);
+    });
+    return { name: service.name, port };
+};
+const startFunctions = async (options, functionServers) => {
+    const services = normalizeFunctionServices(options);
+    if (!services.length)
+        return [];
+    ensureUniquePorts(services);
+    const started = [];
+    for (const service of services) {
+        started.push(await startFunction(service, functionServers));
+    }
+    return started;
+};
+const listenApp = async (app, port, host) => new Promise((resolveListen, rejectListen) => {
+    const server = host ? app.listen(port, host) : app.listen(port);
+    const cleanup = () => {
+        server.off('listening', handleListen);
+        server.off('error', handleError);
+    };
+    const handleListen = () => {
+        cleanup();
+        resolveListen(server);
+    };
+    const handleError = (err) => {
+        cleanup();
+        rejectListen(err);
+    };
+    server.once('listening', handleListen);
+    server.once('error', handleError);
+});
+const closeServer = async (server) => {
+    if (!server || !server.listening)
+        return;
+    await new Promise((resolveClose, rejectClose) => {
+        server.close((err) => {
+            if (err) {
+                rejectClose(err);
+                return;
+            }
+            resolveClose();
+        });
+    });
+};
+class KnativeJobsSvc {
+    options;
+    started = false;
+    result = {
+        functions: [],
+        jobs: false
+    };
+    functionServers = new Map();
+    jobsHttpServer;
+    worker;
+    scheduler;
+    jobsPoolManager;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async start() {
+        if (this.started)
+            return this.result;
+        this.started = true;
+        this.result = {
+            functions: [],
+            jobs: false
+        };
+        if (shouldEnableFunctions(this.options.functions)) {
+            log.info('starting functions');
+            this.result.functions = await startFunctions(this.options.functions, this.functionServers);
+        }
+        if (this.options.jobs?.enabled) {
+            log.info('starting jobs service');
+            await this.startJobs();
+            this.result.jobs = true;
+        }
+        return this.result;
+    }
+    async stop() {
+        if (!this.started)
+            return;
+        this.started = false;
+        if (this.worker?.stop) {
+            await this.worker.stop();
+        }
+        if (this.scheduler?.stop) {
+            await this.scheduler.stop();
+        }
+        this.worker = undefined;
+        this.scheduler = undefined;
+        await closeServer(this.jobsHttpServer);
+        this.jobsHttpServer = undefined;
+        if (this.jobsPoolManager) {
+            await this.jobsPoolManager.close();
+            this.jobsPoolManager = undefined;
+        }
+        for (const server of this.functionServers.values()) {
+            await closeServer(server);
+        }
+        this.functionServers.clear();
+    }
+    async startJobs() {
+        const pgPool = job_pg_1.default.getPool();
+        const jobsApp = (0, knative_job_server_1.default)(pgPool);
+        const callbackPort = (0, job_utils_1.getJobsCallbackPort)();
+        this.jobsHttpServer = await listenApp(jobsApp, callbackPort);
+        const tasks = (0, job_utils_1.getJobSupported)();
+        this.worker = new knative_job_worker_1.default({
+            pgPool,
+            tasks,
+            workerId: (0, job_utils_1.getWorkerHostname)()
+        });
+        this.scheduler = new job_scheduler_1.default({
+            pgPool,
+            tasks,
+            workerId: (0, job_utils_1.getSchedulerHostname)()
+        });
+        this.jobsPoolManager = job_pg_1.default;
+        this.worker.listen();
+        this.scheduler.listen();
+    }
+}
+exports.KnativeJobsSvc = KnativeJobsSvc;
+const parseList = (value) => {
+    if (!value)
+        return [];
+    return value
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean);
+};
+const parsePortMap = (value) => {
+    if (!value)
+        return {};
+    const trimmed = value.trim();
+    if (!trimmed)
+        return {};
+    if (trimmed.startsWith('{')) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            return Object.entries(parsed).reduce((acc, [key, port]) => {
+                const portNumber = Number(port);
+                if (Number.isFinite(portNumber)) {
+                    acc[key] = portNumber;
+                }
+                return acc;
+            }, {});
+        }
+        catch {
+            return {};
+        }
+    }
+    return trimmed.split(',').reduce((acc, pair) => {
+        const [rawName, rawPort] = pair.split(/[:=]/).map((item) => item.trim());
+        const port = Number(rawPort);
+        if (rawName && Number.isFinite(port)) {
+            acc[rawName] = port;
+        }
+        return acc;
+    }, {});
+};
+const buildFunctionsOptionsFromEnv = () => {
+    const rawFunctions = (process.env.CONSTRUCTIVE_FUNCTIONS || '').trim();
+    if (!rawFunctions)
+        return undefined;
+    const portMap = parsePortMap(process.env.CONSTRUCTIVE_FUNCTION_PORTS);
+    const normalized = rawFunctions.toLowerCase();
+    if (normalized === 'all' || normalized === '*') {
+        return { enabled: true };
+    }
+    const names = parseList(rawFunctions);
+    if (!names.length)
+        return undefined;
+    const services = names.map((name) => ({
+        name,
+        port: portMap[name]
+    }));
+    return {
+        enabled: true,
+        services
+    };
+};
+const buildKnativeJobsSvcOptionsFromEnv = () => ({
+    jobs: {
+        enabled: (0, env_1.parseEnvBoolean)(process.env.CONSTRUCTIVE_JOBS_ENABLED) ?? true
+    },
+    functions: buildFunctionsOptionsFromEnv()
+});
+exports.buildKnativeJobsSvcOptionsFromEnv = buildKnativeJobsSvcOptionsFromEnv;
+const startKnativeJobsSvcFromEnv = async () => {
+    const server = new KnativeJobsSvc((0, exports.buildKnativeJobsSvcOptionsFromEnv)());
+    return server.start();
+};
+exports.startKnativeJobsSvcFromEnv = startKnativeJobsSvcFromEnv;
+const startJobsServices = () => {
+    log.info('starting jobs services...');
+    const pgPool = job_pg_1.default.getPool();
+    const app = (0, knative_job_server_1.default)(pgPool);
+    const callbackPort = (0, job_utils_1.getJobsCallbackPort)();
+    const httpServer = app.listen(callbackPort, () => {
+        log.info(`listening ON ${callbackPort}`);
+        const tasks = (0, job_utils_1.getJobSupported)();
+        const worker = new knative_job_worker_1.default({
+            pgPool,
+            workerId: (0, job_utils_1.getWorkerHostname)(),
+            tasks
+        });
+        const scheduler = new job_scheduler_1.default({
+            pgPool,
+            workerId: (0, job_utils_1.getSchedulerHostname)(),
+            tasks
+        });
+        worker.listen();
+        scheduler.listen();
+    });
+    return { pgPool, httpServer };
+};
+exports.startJobsServices = startJobsServices;
+const waitForJobsPrereqs = async () => {
+    log.info('waiting for jobs prereqs');
+    let client = null;
+    try {
+        const cfg = (0, job_utils_1.getJobPgConfig)();
+        client = new pg_1.Client({
+            host: cfg.host,
+            port: cfg.port,
+            user: cfg.user,
+            password: cfg.password,
+            database: cfg.database
+        });
+        await client.connect();
+        const schema = (0, job_utils_1.getJobSchema)();
+        await client.query(`SELECT * FROM "${schema}".jobs LIMIT 1;`);
+    }
+    catch (error) {
+        log.error(error);
+        throw new Error('jobs server boot failed...');
+    }
+    finally {
+        if (client) {
+            void client.end();
+        }
+    }
+};
+exports.waitForJobsPrereqs = waitForJobsPrereqs;
+const bootJobs = async () => {
+    log.info('attempting to boot jobs');
+    await (0, async_retry_1.default)(async () => {
+        await (0, exports.waitForJobsPrereqs)();
+    }, {
+        retries: 10,
+        factor: 2
+    });
+    const options = (0, exports.buildKnativeJobsSvcOptionsFromEnv)();
+    if (options.jobs?.enabled === false) {
+        log.info('jobs disabled; skipping startup');
+        return;
+    }
+    const server = new KnativeJobsSvc(options);
+    await server.start();
+};
+exports.bootJobs = bootJobs;
+__exportStar(require("./types"), exports);

package/dist/run.d.ts

@@ -1,7 +1,2 @@
 #!/usr/bin/env node
-export declare const startJobsServices: () => {
-    pgPool: import("pg").Pool;
-    httpServer: any;
-};
-export declare const waitForJobsPrereqs: () => Promise<void>;
-export declare const bootJobs: () => Promise<void>;
+export { bootJobs, startJobsServices, waitForJobsPrereqs } from './index';

package/dist/run.js

@@ -1,84 +1,12 @@
 #!/usr/bin/env node
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.bootJobs = exports.waitForJobsPrereqs = exports.startJobsServices = void 0;
-const job_scheduler_1 = __importDefault(require("@constructive-io/job-scheduler"));
-const knative_job_worker_1 = __importDefault(require("@constructive-io/knative-job-worker"));
-const knative_job_server_1 = __importDefault(require("@constructive-io/knative-job-server"));
-const job_pg_1 = __importDefault(require("@constructive-io/job-pg"));
-const pg_1 = require("pg");
-const async_retry_1 = __importDefault(require("async-retry"));
-const job_utils_1 = require("@constructive-io/job-utils");
-const startJobsServices = () => {
-    // eslint-disable-next-line no-console
-    console.log('starting jobs services...');
-    const pgPool = job_pg_1.default.getPool();
-    const app = (0, knative_job_server_1.default)(pgPool);
-    const callbackPort = (0, job_utils_1.getJobsCallbackPort)();
-    const httpServer = app.listen(callbackPort, () => {
-        // eslint-disable-next-line no-console
-        console.log(`[cb] listening ON ${callbackPort}`);
-        const tasks = (0, job_utils_1.getJobSupported)();
-        const worker = new knative_job_worker_1.default({
-            pgPool,
-            workerId: (0, job_utils_1.getWorkerHostname)(),
-            tasks
-        });
-        const scheduler = new job_scheduler_1.default({
-            pgPool,
-            workerId: (0, job_utils_1.getSchedulerHostname)(),
-            tasks
-        });
-        worker.listen();
-        scheduler.listen();
-    });
-    return { pgPool, httpServer };
-};
-exports.startJobsServices = startJobsServices;
-const waitForJobsPrereqs = async () => {
-    // eslint-disable-next-line no-console
-    console.log('waiting for jobs prereqs');
-    let client = null;
-    try {
-        const cfg = (0, job_utils_1.getJobPgConfig)();
-        client = new pg_1.Client({
-            host: cfg.host,
-            port: cfg.port,
-            user: cfg.user,
-            password: cfg.password,
-            database: cfg.database
-        });
-        await client.connect();
-        const schema = (0, job_utils_1.getJobSchema)();
-        await client.query(`SELECT * FROM "${schema}".jobs LIMIT 1;`);
-    }
-    catch (error) {
-        // eslint-disable-next-line no-console
-        console.log(error);
-        throw new Error('jobs server boot failed...');
-    }
-    finally {
-        if (client) {
-            void client.end();
-        }
-    }
-};
-exports.waitForJobsPrereqs = waitForJobsPrereqs;
-const bootJobs = async () => {
-    // eslint-disable-next-line no-console
-    console.log('attempting to boot jobs');
-    await (0, async_retry_1.default)(async () => {
-        await (0, exports.waitForJobsPrereqs)();
-    }, {
-        retries: 10,
-        factor: 2
-    });
-    (0, exports.startJobsServices)();
-};
-exports.bootJobs = bootJobs;
+exports.waitForJobsPrereqs = exports.startJobsServices = exports.bootJobs = void 0;
+var index_1 = require("./index");
+Object.defineProperty(exports, "bootJobs", { enumerable: true, get: function () { return index_1.bootJobs; } });
+Object.defineProperty(exports, "startJobsServices", { enumerable: true, get: function () { return index_1.startJobsServices; } });
+Object.defineProperty(exports, "waitForJobsPrereqs", { enumerable: true, get: function () { return index_1.waitForJobsPrereqs; } });
+const index_2 = require("./index");
 if (require.main === module) {
-    void (0, exports.bootJobs)();
+    void (0, index_2.bootJobs)();
 }

package/dist/types.d.ts

@@ -0,0 +1,24 @@
+export type FunctionName = 'simple-email' | 'send-email-link';
+export type FunctionServiceConfig = {
+    name: FunctionName;
+    port?: number;
+};
+export type FunctionsOptions = {
+    enabled?: boolean;
+    services?: FunctionServiceConfig[];
+};
+export type JobsOptions = {
+    enabled?: boolean;
+};
+export type KnativeJobsSvcOptions = {
+    functions?: FunctionsOptions;
+    jobs?: JobsOptions;
+};
+export type StartedFunction = {
+    name: FunctionName;
+    port: number;
+};
+export type KnativeJobsSvcResult = {
+    functions: StartedFunction[];
+    jobs: boolean;
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constructive-io/knative-job-service",
-  "version": "0.6.15",
+  "version": "0.7.0",
   "description": "knative job service",
   "author": "Constructive <developers@constructive.io>",
   "homepage": "https://github.com/constructive-io/jobs/tree/master/packages/knative-job-service#readme",
@@ -33,16 +33,34 @@
     "url": "https://github.com/constructive-io/jobs/issues"
   },
   "devDependencies": {
+    "@constructive-io/graphql-server": "^2.17.0",
+    "@constructive-io/graphql-types": "^2.12.14",
+    "@pgpm/database-jobs": "^0.16.0",
+    "@pgpm/inflection": "^0.16.0",
+    "@pgpm/metaschema-modules": "^0.16.1",
+    "@pgpm/metaschema-schema": "^0.16.1",
+    "@pgpm/services": "^0.16.1",
+    "@pgpm/types": "^0.16.0",
+    "@pgpm/verify": "^0.16.0",
+    "@pgpmjs/core": "^4.15.2",
+    "@types/supertest": "^6.0.3",
+    "pgsql-test": "^2.24.16",
+    "supertest": "^7.2.2",
     "ts-node": "^10.9.2"
   },
   "dependencies": {
-    "@constructive-io/job-pg": "^0.3.20",
-    "@constructive-io/job-scheduler": "^0.3.22",
-    "@constructive-io/job-utils": "^0.5.15",
-    "@constructive-io/knative-job-server": "^0.3.24",
-    "@constructive-io/knative-job-worker": "^0.7.15",
+    "@constructive-io/job-pg": "^0.3.21",
+    "@constructive-io/job-scheduler": "^0.3.23",
+    "@constructive-io/job-utils": "^0.5.16",
+    "@constructive-io/knative-job-fn": "^0.2.8",
+    "@constructive-io/knative-job-server": "^0.3.25",
+    "@constructive-io/knative-job-worker": "^0.7.16",
+    "@constructive-io/send-email-link-fn": "^0.2.21",
+    "@constructive-io/simple-email-fn": "^0.2.22",
+    "@pgpmjs/env": "^2.9.5",
+    "@pgpmjs/logger": "^1.3.8",
     "async-retry": "1.3.1",
     "pg": "8.16.3"
   },
-  "gitHead": "b9719cd48487af70e6e065510197c9d2d6b331b6"
+  "gitHead": "b7abf2fdaf0a827d79a80c9c0a29e5c960f227df"
 }