pg-boss 10.4.0 → 10.4.1

package/.claude/settings.local.json

@@ -7,7 +7,17 @@
       "Bash(done)",
       "Bash(find:*)",
       "Bash(npm test:*)",
-      "mcp__ide__getDiagnostics"
+      "mcp__ide__getDiagnostics",
+      "WebFetch(domain:github.com)",
+      "Bash(npm run build:*)",
+      "Bash(npm run tsc:*)",
+      "Bash(cut:*)",
+      "Bash(grep:*)",
+      "WebSearch",
+      "WebFetch(domain:docs.npmjs.com)",
+      "WebFetch(domain:ankushkun.medium.com)",
+      "WebFetch(domain:github.blog)",
+      "Bash(ls:*)"
     ],
     "deny": [],
     "ask": []

package/dist/attorney.d.ts

@@ -0,0 +1,19 @@
+import type * as types from './types.ts';
+declare const POLICY: {
+    MAX_EXPIRATION_HOURS: number;
+    MIN_POLLING_INTERVAL_MS: number;
+    MAX_RETENTION_DAYS: number;
+};
+declare function validateQueueArgs(config?: any): void;
+declare function checkSendArgs(args: any): types.Request;
+declare function checkWorkArgs(name: string, args: any[]): {
+    options: types.ResolvedWorkOptions;
+    callback: types.WorkHandler<any>;
+};
+declare function checkFetchArgs(name: string, options: any): void;
+declare function getConfig(value: string | types.ConstructorOptions): types.ResolvedConstructorOptions;
+declare function assertPostgresObjectName(name: string): void;
+declare function assertQueueName(name: string): void;
+declare function assertKey(key: string): void;
+export { assertKey, assertPostgresObjectName, assertQueueName, checkFetchArgs, checkSendArgs, checkWorkArgs, getConfig, POLICY, validateQueueArgs };
+//# sourceMappingURL=attorney.d.ts.map

package/dist/attorney.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attorney.d.ts","sourceRoot":"","sources":["../src/attorney.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAA;AAExC,QAAA,MAAM,MAAM;;;;CAIX,CAAA;AAMD,iBAAS,iBAAiB,CAAE,MAAM,GAAE,GAAQ,QAW3C;AAED,iBAAS,aAAa,CAAE,IAAI,EAAE,GAAG,GAAG,KAAK,CAAC,OAAO,CA+ChD;AAmED,iBAAS,aAAa,CAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG;IAClD,OAAO,EAAE,KAAK,CAAC,mBAAmB,CAAA;IAClC,QAAQ,EAAE,KAAK,CAAC,WAAW,CAAC,GAAG,CAAC,CAAA;CACjC,CA2BA;AAED,iBAAS,cAAc,CAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,QAOlD;AAED,iBAAS,SAAS,CAAE,KAAK,EAAE,MAAM,GAAG,KAAK,CAAC,kBAAkB,GAAG,KAAK,CAAC,0BAA0B,CAoB9F;AAkBD,iBAAS,wBAAwB,CAAE,IAAI,EAAE,MAAM,QAK9C;AAED,iBAAS,eAAe,CAAE,IAAI,EAAE,MAAM,QAIrC;AAED,iBAAS,SAAS,CAAE,GAAG,EAAE,MAAM,QAI9B;AA+FD,OAAO,EACL,SAAS,EACT,wBAAwB,EACxB,eAAe,EACf,cAAc,EACd,aAAa,EACb,aAAa,EACb,SAAS,EACT,MAAM,EACN,iBAAiB,EAClB,CAAA"}

package/dist/attorney.js

@@ -0,0 +1,227 @@
+import assert from 'node:assert';
+import { DEFAULT_SCHEMA } from "./plans.js";
+const POLICY = {
+    MAX_EXPIRATION_HOURS: 24,
+    MIN_POLLING_INTERVAL_MS: 500,
+    MAX_RETENTION_DAYS: 365
+};
+function assertObjectName(value, name = 'Name') {
+    assert(/^[\w.-]+$/.test(value), `${name} can only contain alphanumeric characters, underscores, hyphens, or periods`);
+}
+function validateQueueArgs(config = {}) {
+    assert(!('deadLetter' in config) || config.deadLetter === null || (typeof config.deadLetter === 'string'), 'deadLetter must be a string');
+    if (config.deadLetter) {
+        assertObjectName(config.deadLetter, 'deadLetter');
+    }
+    validateRetryConfig(config);
+    validateExpirationConfig(config);
+    validateRetentionConfig(config);
+    validateDeletionConfig(config);
+}
+function checkSendArgs(args) {
+    let name, data, options;
+    if (typeof args[0] === 'string') {
+        name = args[0];
+        data = args[1];
+        assert(typeof data !== 'function', 'send() cannot accept a function as the payload.  Did you intend to use work()?');
+        options = args[2];
+    }
+    else if (typeof args[0] === 'object') {
+        assert(args.length === 1, 'send object API only accepts 1 argument');
+        const job = args[0];
+        assert(job, 'boss requires all jobs to have a name');
+        name = job.name;
+        data = job.data;
+        options = job.options;
+    }
+    options = options || {};
+    assert(name, 'boss requires all jobs to have a queue name');
+    assert(typeof options === 'object', 'options should be an object');
+    options = { ...options };
+    assert(!('priority' in options) || (Number.isInteger(options.priority)), 'priority must be an integer');
+    options.priority = options.priority || 0;
+    options.startAfter = (options.startAfter instanceof Date && typeof options.startAfter.toISOString === 'function')
+        ? options.startAfter.toISOString()
+        : (+options.startAfter > 0)
+            ? '' + options.startAfter
+            : (typeof options.startAfter === 'string')
+                ? options.startAfter
+                : undefined;
+    validateRetryConfig(options);
+    validateExpirationConfig(options);
+    validateRetentionConfig(options);
+    validateDeletionConfig(options);
+    validateGroupConfig(options);
+    return { name, data, options };
+}
+function validateGroupConfig(config) {
+    if (!('group' in config) || config.group === undefined || config.group === null) {
+        return;
+    }
+    assert(typeof config.group === 'object', 'group must be an object');
+    assert(typeof config.group.id === 'string' && config.group.id.length > 0, 'group.id must be a non-empty string');
+    assert(!('tier' in config.group) || (typeof config.group.tier === 'string' && config.group.tier.length > 0), 'group.tier must be a non-empty string if provided');
+}
+function validateGroupConcurrencyValue(value, optionName) {
+    if (typeof value === 'number') {
+        assert(Number.isInteger(value) && value >= 1, `${optionName} must be an integer >= 1`);
+        return;
+    }
+    assert(typeof value === 'object', `${optionName} must be a number or an object with { default, tiers? }`);
+    assert(Number.isInteger(value.default) && value.default >= 1, `${optionName}.default must be an integer >= 1`);
+    if ('tiers' in value && value.tiers) {
+        assert(typeof value.tiers === 'object', `${optionName}.tiers must be an object`);
+        for (const [tier, limit] of Object.entries(value.tiers)) {
+            assert(typeof tier === 'string' && tier.length > 0, `${optionName} tier keys must be non-empty strings`);
+            assert(Number.isInteger(limit) && limit >= 1, `${optionName}.tiers["${tier}"] must be an integer >= 1`);
+        }
+    }
+}
+function validateGroupConcurrencyConfig(config) {
+    const hasGlobal = config.groupConcurrency != null;
+    const hasLocal = config.localGroupConcurrency != null;
+    assert(!(hasGlobal && hasLocal), 'cannot specify both groupConcurrency and localGroupConcurrency - choose one');
+    if (hasGlobal)
+        validateGroupConcurrencyValue(config.groupConcurrency, 'groupConcurrency');
+    if (hasLocal) {
+        validateGroupConcurrencyValue(config.localGroupConcurrency, 'localGroupConcurrency');
+        validateLocalGroupConcurrencyLimit(config.localGroupConcurrency, config.localConcurrency);
+    }
+}
+function validateLocalGroupConcurrencyLimit(localGroupConcurrency, localConcurrency) {
+    const effectiveLocalConcurrency = localConcurrency ?? 1;
+    if (typeof localGroupConcurrency === 'number') {
+        assert(localGroupConcurrency <= effectiveLocalConcurrency, `localGroupConcurrency (${localGroupConcurrency}) cannot exceed localConcurrency (${effectiveLocalConcurrency})`);
+    }
+    else if (typeof localGroupConcurrency === 'object') {
+        assert(localGroupConcurrency.default <= effectiveLocalConcurrency, `localGroupConcurrency.default (${localGroupConcurrency.default}) cannot exceed localConcurrency (${effectiveLocalConcurrency})`);
+        if (localGroupConcurrency.tiers) {
+            for (const [tier, limit] of Object.entries(localGroupConcurrency.tiers)) {
+                assert(limit <= effectiveLocalConcurrency, `localGroupConcurrency.tiers["${tier}"] (${limit}) cannot exceed localConcurrency (${effectiveLocalConcurrency})`);
+            }
+        }
+    }
+}
+function checkWorkArgs(name, args) {
+    let options, callback;
+    assert(name, 'queue name is required');
+    if (args.length === 1) {
+        callback = args[0];
+        options = {};
+    }
+    else if (args.length > 1) {
+        options = args[0] || {};
+        callback = args[1];
+    }
+    assert(typeof callback === 'function', 'expected callback to be a function');
+    assert(typeof options === 'object', 'expected config to be an object');
+    options = { ...options };
+    applyPollingInterval(options);
+    assert(!('batchSize' in options) || (Number.isInteger(options.batchSize) && options.batchSize >= 1), 'batchSize must be an integer > 0');
+    assert(!('includeMetadata' in options) || typeof options.includeMetadata === 'boolean', 'includeMetadata must be a boolean');
+    assert(!('priority' in options) || typeof options.priority === 'boolean', 'priority must be a boolean');
+    assert(!('localConcurrency' in options) || (Number.isInteger(options.localConcurrency) && options.localConcurrency >= 1), 'localConcurrency must be an integer >= 1');
+    validateGroupConcurrencyConfig(options);
+    return { options, callback };
+}
+function checkFetchArgs(name, options) {
+    assert(name, 'missing queue name');
+    assert(!('batchSize' in options) || (Number.isInteger(options.batchSize) && options.batchSize >= 1), 'batchSize must be an integer > 0');
+    assert(!('includeMetadata' in options) || typeof options.includeMetadata === 'boolean', 'includeMetadata must be a boolean');
+    assert(!('priority' in options) || typeof options.priority === 'boolean', 'priority must be a boolean');
+    assert(!('ignoreStartAfter' in options) || typeof options.ignoreStartAfter === 'boolean', 'ignoreStartAfter must be a boolean');
+}
+function getConfig(value) {
+    assert(value && (typeof value === 'object' || typeof value === 'string'), 'configuration assert: string or config object is required to connect to postgres');
+    const config = (typeof value === 'string')
+        ? { connectionString: value }
+        : { ...value };
+    config.schedule = ('schedule' in config) ? config.schedule : true;
+    config.supervise = ('supervise' in config) ? config.supervise : true;
+    config.migrate = ('migrate' in config) ? config.migrate : true;
+    config.createSchema = ('createSchema' in config) ? config.createSchema : true;
+    applySchemaConfig(config);
+    applyOpsConfig(config);
+    applyScheduleConfig(config);
+    applyBamConfig(config);
+    validateWarningConfig(config);
+    return config;
+}
+function applySchemaConfig(config) {
+    if (config.schema) {
+        assertPostgresObjectName(config.schema);
+    }
+    config.schema = config.schema || DEFAULT_SCHEMA;
+}
+function validateWarningConfig(config) {
+    assert(!('warningQueueSize' in config) || config.warningQueueSize >= 1, 'configuration assert: warningQueueSize must be at least 1');
+    assert(!('warningSlowQuerySeconds' in config) || config.warningSlowQuerySeconds >= 1, 'configuration assert: warningSlowQuerySeconds must be at least 1');
+}
+function assertPostgresObjectName(name) {
+    assert(typeof name === 'string', 'Name must be a string');
+    assert(name.length <= 50, 'Name cannot exceed 50 characters');
+    assert(!/\W/.test(name), 'Name can only contain alphanumeric characters or underscores');
+    assert(!/^\d/.test(name), 'Name cannot start with a number');
+}
+function assertQueueName(name) {
+    assert(name, 'Name is required');
+    assert(typeof name === 'string', 'Name must be a string');
+    assertObjectName(name);
+}
+function assertKey(key) {
+    if (!key)
+        return;
+    assert(typeof key === 'string', 'Key must be a string');
+    assertObjectName(key, 'Key');
+}
+function validateRetentionConfig(config) {
+    assert(!('retentionSeconds' in config) || config.retentionSeconds >= 1, 'configuration assert: retentionSeconds must be at least every second');
+}
+function validateExpirationConfig(config) {
+    assert(!('expireInSeconds' in config) || config.expireInSeconds >= 1, 'configuration assert: expireInSeconds must be at least every second');
+    assert(!config.expireInSeconds || config.expireInSeconds / 60 / 60 < POLICY.MAX_EXPIRATION_HOURS, `configuration assert: expiration cannot exceed ${POLICY.MAX_EXPIRATION_HOURS} hours`);
+}
+function validateRetryConfig(config) {
+    assert(!('retryDelay' in config) || (Number.isInteger(config.retryDelay) && config.retryDelay >= 0), 'retryDelay must be an integer >= 0');
+    assert(!('retryLimit' in config) || (Number.isInteger(config.retryLimit) && config.retryLimit >= 0), 'retryLimit must be an integer >= 0');
+    assert(!('retryBackoff' in config) || (config.retryBackoff === true || config.retryBackoff === false), 'retryBackoff must be either true or false');
+    assert(!('retryDelayMax' in config) || config.retryDelayMax === null || config.retryBackoff === true, 'retryDelayMax can only be set if retryBackoff is true');
+    assert(!('retryDelayMax' in config) || config.retryDelayMax === null || (Number.isInteger(config.retryDelayMax) && config.retryDelayMax >= 0), 'retryDelayMax must be an integer >= 0');
+}
+function applyPollingInterval(config) {
+    assert(!('pollingIntervalSeconds' in config) || config.pollingIntervalSeconds >= POLICY.MIN_POLLING_INTERVAL_MS / 1000, `configuration assert: pollingIntervalSeconds must be at least every ${POLICY.MIN_POLLING_INTERVAL_MS}ms`);
+    config.pollingInterval = ('pollingIntervalSeconds' in config)
+        ? config.pollingIntervalSeconds * 1000
+        : 2000;
+}
+function applyOpsConfig(config) {
+    assert(!('superviseIntervalSeconds' in config) || config.superviseIntervalSeconds >= 1, 'configuration assert: superviseIntervalSeconds must be at least every second');
+    config.superviseIntervalSeconds = config.superviseIntervalSeconds || 60;
+    assert(config.superviseIntervalSeconds / 60 / 60 <= POLICY.MAX_EXPIRATION_HOURS, `configuration assert: superviseIntervalSeconds cannot exceed ${POLICY.MAX_EXPIRATION_HOURS} hours`);
+    assert(!('maintenanceIntervalSeconds' in config) || config.maintenanceIntervalSeconds >= 1, 'configuration assert: maintenanceIntervalSeconds must be at least every second');
+    config.maintenanceIntervalSeconds = config.maintenanceIntervalSeconds || POLICY.MAX_EXPIRATION_HOURS * 60 * 60;
+    assert(config.maintenanceIntervalSeconds / 60 / 60 <= POLICY.MAX_EXPIRATION_HOURS, `configuration assert: maintenanceIntervalSeconds cannot exceed ${POLICY.MAX_EXPIRATION_HOURS} hours`);
+    assert(!('monitorIntervalSeconds' in config) || config.monitorIntervalSeconds >= 1, 'configuration assert: monitorIntervalSeconds must be at least every second');
+    config.monitorIntervalSeconds = config.monitorIntervalSeconds || 60;
+    assert(config.monitorIntervalSeconds / 60 / 60 <= POLICY.MAX_EXPIRATION_HOURS, `configuration assert: monitorIntervalSeconds cannot exceed ${POLICY.MAX_EXPIRATION_HOURS} hours`);
+    assert(!('queueCacheIntervalSeconds' in config) || config.queueCacheIntervalSeconds >= 1, 'configuration assert: queueCacheIntervalSeconds must be at least every second');
+    config.queueCacheIntervalSeconds = config.queueCacheIntervalSeconds || 60;
+    assert(config.queueCacheIntervalSeconds / 60 / 60 <= POLICY.MAX_EXPIRATION_HOURS, `configuration assert: queueCacheIntervalSeconds cannot exceed ${POLICY.MAX_EXPIRATION_HOURS} hours`);
+}
+function validateDeletionConfig(config) {
+    assert(!('deleteAfterSeconds' in config) || config.deleteAfterSeconds >= 0, 'configuration assert: deleteAfterSeconds must be at least 0 (0 disables deletion)');
+}
+function applyScheduleConfig(config) {
+    assert(!('clockMonitorIntervalSeconds' in config) || (config.clockMonitorIntervalSeconds >= 1 && config.clockMonitorIntervalSeconds <= 600), 'configuration assert: clockMonitorIntervalSeconds must be between 1 second and 10 minutes');
+    config.clockMonitorIntervalSeconds = config.clockMonitorIntervalSeconds || 600;
+    assert(!('cronMonitorIntervalSeconds' in config) || (config.cronMonitorIntervalSeconds >= 1 && config.cronMonitorIntervalSeconds <= 45), 'configuration assert: cronMonitorIntervalSeconds must be between 1 and 45 seconds');
+    config.cronMonitorIntervalSeconds = config.cronMonitorIntervalSeconds || 30;
+    assert(!('cronWorkerIntervalSeconds' in config) || (config.cronWorkerIntervalSeconds >= 1 && config.cronWorkerIntervalSeconds <= 45), 'configuration assert: cronWorkerIntervalSeconds must be between 1 and 45 seconds');
+    config.cronWorkerIntervalSeconds = config.cronWorkerIntervalSeconds || 5;
+}
+function applyBamConfig(config) {
+    const minInterval = config.__test__bypass_bam_interval_check ? 1 : 10;
+    assert(!('bamIntervalSeconds' in config) || config.bamIntervalSeconds >= minInterval, `configuration assert: bamIntervalSeconds must be at least ${minInterval} seconds`);
+    config.bamIntervalSeconds = config.bamIntervalSeconds || 60;
+}
+export { assertKey, assertPostgresObjectName, assertQueueName, checkFetchArgs, checkSendArgs, checkWorkArgs, getConfig, POLICY, validateQueueArgs };

package/dist/bam.d.ts

@@ -0,0 +1,14 @@
+import EventEmitter from 'node:events';
+import * as types from './types.js';
+declare class Bam extends EventEmitter implements types.EventsMixin {
+    #private;
+    events: {
+        error: string;
+        bam: string;
+    };
+    constructor(db: types.IDatabase, config: types.ResolvedConstructorOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+export default Bam;
+//# sourceMappingURL=bam.d.ts.map

package/dist/bam.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bam.d.ts","sourceRoot":"","sources":["../src/bam.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,aAAa,CAAA;AAEtC,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAOnC,cAAM,GAAI,SAAQ,YAAa,YAAW,KAAK,CAAC,WAAW;;IAOzD,MAAM;;;MAAS;gBAGb,EAAE,EAAE,KAAK,CAAC,SAAS,EACnB,MAAM,EAAE,KAAK,CAAC,0BAA0B;IAUpC,KAAK;IAWL,IAAI;CAgGX;AAED,eAAe,GAAG,CAAA"}

package/dist/bam.js

@@ -0,0 +1,114 @@
+import EventEmitter from 'node:events';
+import * as plans from './plans.js';
+import * as types from './types.js';
+const events = {
+    error: 'error',
+    bam: 'bam'
+};
+class Bam extends EventEmitter {
+    #stopped;
+    #working;
+    #pollInterval;
+    #db;
+    #config;
+    events = events;
+    constructor(db, config) {
+        super();
+        this.#db = db;
+        this.#config = config;
+        this.#stopped = true;
+        this.#working = false;
+    }
+    async start() {
+        if (!this.#stopped)
+            return;
+        this.#stopped = false;
+        setImmediate(() => this.#onPoll());
+        this.#pollInterval = setInterval(() => this.#onPoll(), this.#config.bamIntervalSeconds * 1000);
+    }
+    async stop() {
+        if (this.#stopped)
+            return;
+        this.#stopped = true;
+        if (this.#pollInterval) {
+            clearInterval(this.#pollInterval);
+            this.#pollInterval = undefined;
+        }
+    }
+    async #onPoll() {
+        if (this.#stopped || this.#working || !this.#config.migrate)
+            return;
+        this.#working = true;
+        try {
+            if (this.#config.__test__throw_bam) {
+                throw new Error(this.#config.__test__throw_bam);
+            }
+            const sql = plans.trySetBamTime(this.#config.schema, this.#config.bamIntervalSeconds);
+            const { rows } = await this.#db.executeSql(sql);
+            if (rows.length === 1) {
+                await this.#processCommands();
+            }
+        }
+        catch (err) {
+            this.emit(events.error, err);
+        }
+        finally {
+            this.#working = false;
+        }
+    }
+    async #processCommands() {
+        if (this.#stopped)
+            return;
+        const entry = await this.#getNextCommand();
+        if (!entry || this.#stopped)
+            return;
+        this.emit(events.bam, {
+            id: entry.id,
+            name: entry.name,
+            status: 'in_progress',
+            queue: entry.queue,
+            table: entry.table
+        });
+        try {
+            await this.#db.executeSql(entry.command);
+            if (this.#stopped)
+                return;
+            await this.#markCompleted(entry.id);
+            this.emit(events.bam, {
+                id: entry.id,
+                name: entry.name,
+                status: 'completed',
+                queue: entry.queue,
+                table: entry.table
+            });
+        }
+        catch (err) {
+            if (this.#stopped)
+                return;
+            await this.#markFailed(entry.id, err);
+            this.emit(events.error, err);
+            this.emit(events.bam, {
+                id: entry.id,
+                name: entry.name,
+                status: 'failed',
+                queue: entry.queue,
+                table: entry.table,
+                error: String(err)
+            });
+        }
+    }
+    async #getNextCommand() {
+        const sql = plans.getNextBamCommand(this.#config.schema);
+        const { rows } = await this.#db.executeSql(sql);
+        return rows[0] || null;
+    }
+    async #markCompleted(id) {
+        const sql = plans.setBamCompleted(this.#config.schema, id);
+        await this.#db.executeSql(sql);
+    }
+    async #markFailed(id, error) {
+        const sql = plans.setBamFailed(this.#config.schema, id, String(error));
+        await this.#db.executeSql(sql);
+    }
+}
+export default Bam;

package/dist/boss.d.ts

@@ -0,0 +1,16 @@
+import EventEmitter from 'node:events';
+import type Manager from './manager.js';
+import * as types from './types.js';
+declare class Boss extends EventEmitter implements types.EventsMixin {
+    #private;
+    events: {
+        error: string;
+        warning: string;
+    };
+    constructor(db: types.IDatabase, manager: Manager, config: types.ResolvedConstructorOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    supervise(value?: string | types.QueueResult[]): Promise<void>;
+}
+export default Boss;
+//# sourceMappingURL=boss.d.ts.map

package/dist/boss.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boss.d.ts","sourceRoot":"","sources":["../src/boss.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,aAAa,CAAA;AACtC,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAGvC,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAYnC,cAAM,IAAK,SAAQ,YAAa,YAAW,KAAK,CAAC,WAAW;;IAS1D,MAAM;;;MAAS;gBAGb,EAAE,EAAE,KAAK,CAAC,SAAS,EACnB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,KAAK,CAAC,0BAA0B;IAmBpC,KAAK;IAWL,IAAI;IAkEJ,SAAS,CAAE,KAAK,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,WAAW,EAAE;CAuFtD;AAED,eAAe,IAAI,CAAA"}

package/dist/boss.js

@@ -0,0 +1,163 @@
+import EventEmitter from 'node:events';
+import * as plans from './plans.js';
+import { unwrapSQLResult } from './tools.js';
+import * as types from './types.js';
+const events = {
+    error: 'error',
+    warning: 'warning'
+};
+const WARNINGS = {
+    SLOW_QUERY: { seconds: 30, message: 'Warning: slow query. Your queues and/or database server should be reviewed' },
+    LARGE_QUEUE: { size: 10_000, message: 'Warning: large queue backlog. Your queue should be reviewed' }
+};
+class Boss extends EventEmitter {
+    #stopped;
+    #stopping;
+    #maintaining;
+    #superviseInterval;
+    #db;
+    #config;
+    #manager;
+    events = events;
+    constructor(db, manager, config) {
+        super();
+        this.#db = db;
+        this.#config = config;
+        this.#manager = manager;
+        this.#stopped = true;
+        this.#stopping = false;
+        if (config.warningSlowQuerySeconds) {
+            WARNINGS.SLOW_QUERY.seconds = config.warningSlowQuerySeconds;
+        }
+        if (config.warningQueueSize) {
+            WARNINGS.LARGE_QUEUE.size = config.warningQueueSize;
+        }
+    }
+    async start() {
+        if (this.#stopped) {
+            this.#stopping = false;
+            this.#superviseInterval = setInterval(() => this.#onSupervise(), this.#config.superviseIntervalSeconds * 1000);
+            this.#stopped = false;
+        }
+    }
+    async stop() {
+        if (!this.#stopped) {
+            this.#stopping = true;
+            if (this.#superviseInterval)
+                clearInterval(this.#superviseInterval);
+            this.#stopped = true;
+        }
+    }
+    async #executeSql(sql) {
+        const started = Date.now();
+        const result = unwrapSQLResult(await this.#db.executeSql(sql));
+        const elapsed = (Date.now() - started) / 1000;
+        if (elapsed > WARNINGS.SLOW_QUERY.seconds ||
+            this.#config.__test__warn_slow_query) {
+            this.emit(events.warning, {
+                message: WARNINGS.SLOW_QUERY.message,
+                data: { elapsed, sql },
+            });
+        }
+        return result;
+    }
+    async #executeQuery(query) {
+        const started = Date.now();
+        const result = unwrapSQLResult(await this.#db.executeSql(query.text, query.values));
+        const elapsed = (Date.now() - started) / 1000;
+        if (elapsed > WARNINGS.SLOW_QUERY.seconds ||
+            this.#config.__test__warn_slow_query) {
+            this.emit(events.warning, {
+                message: WARNINGS.SLOW_QUERY.message,
+                data: { elapsed, sql: query.text, values: query.values },
+            });
+        }
+        return result;
+    }
+    async #onSupervise() {
+        try {
+            if (this.#stopped)
+                return;
+            if (this.#maintaining)
+                return;
+            if (this.#config.__test__throw_maint) {
+                throw new Error(this.#config.__test__throw_maint);
+            }
+            this.#maintaining = true;
+            const queues = await this.#manager.getQueues();
+            !this.#stopped && (await this.supervise(queues));
+        }
+        catch (err) {
+            this.emit(events.error, err);
+        }
+        finally {
+            this.#maintaining = false;
+        }
+    }
+    async supervise(value) {
+        let queues;
+        if (Array.isArray(value)) {
+            queues = value;
+        }
+        else {
+            queues = await this.#manager.getQueues(value);
+        }
+        const queueGroups = queues.reduce((acc, q) => {
+            const { table } = q;
+            acc[table] = acc[table] || { table, queues: [] };
+            acc[table].queues.push(q);
+            return acc;
+        }, {});
+        for (const queueGroup of Object.values(queueGroups)) {
+            if (this.#stopping)
+                return;
+            const { table, queues } = queueGroup;
+            const names = queues.map((i) => i.name);
+            while (names.length) {
+                if (this.#stopping)
+                    return;
+                const chunk = names.splice(0, 100);
+                await this.#monitor(table, chunk);
+                await this.#maintain(table, chunk);
+            }
+        }
+    }
+    async #monitor(table, names) {
+        if (this.#stopping)
+            return;
+        const command = plans.trySetQueueMonitorTime(this.#config.schema, names, this.#config.monitorIntervalSeconds);
+        const { rows } = await this.#executeQuery(command);
+        if (this.#stopping)
+            return;
+        if (rows.length) {
+            const queues = rows.map((q) => q.name);
+            const cacheStatsSql = plans.cacheQueueStats(this.#config.schema, table, queues);
+            const { rows: rowsCacheStats } = await this.#executeSql(cacheStatsSql);
+            if (this.#stopping)
+                return;
+            const warnings = rowsCacheStats.filter(i => i.queuedCount > (i.warningQueueSize || WARNINGS.LARGE_QUEUE.size));
+            for (const warning of warnings) {
+                this.emit(events.warning, {
+                    message: WARNINGS.LARGE_QUEUE.message,
+                    data: warning,
+                });
+            }
+            const sql = plans.failJobsByTimeout(this.#config.schema, table, queues);
+            await this.#executeSql(sql);
+        }
+    }
+    async #maintain(table, names) {
+        if (this.#stopping)
+            return;
+        const command = plans.trySetQueueDeletionTime(this.#config.schema, names, this.#config.maintenanceIntervalSeconds);
+        const { rows } = await this.#executeQuery(command);
+        if (this.#stopping)
+            return;
+        if (rows.length) {
+            const queues = rows.map((q) => q.name);
+            const sql = plans.deletion(this.#config.schema, table, queues);
+            await this.#executeSql(sql);
+        }
+    }
+}
+export default Boss;

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}