pg-boss 12.4.0 → 12.5.0

package/dist/manager.js

@@ -0,0 +1,547 @@
+import assert, { notStrictEqual } from 'node:assert';
+import { randomUUID } from 'node:crypto';
+import EventEmitter from 'node:events';
+import { serializeError as stringify } from 'serialize-error';
+import * as Attorney from "./attorney.js";
+import * as plans from "./plans.js";
+import * as timekeeper from "./timekeeper.js";
+import { resolveWithinSeconds } from "./tools.js";
+import * as types from "./types.js";
+import Worker from "./worker.js";
+import { JobSpy } from "./spy.js";
+const INTERNAL_QUEUES = Object.values(timekeeper.QUEUES).reduce((acc, i) => ({ ...acc, [i]: i }), {});
+const events = {
+    error: 'error',
+    wip: 'wip'
+};
+class Manager extends EventEmitter {
+    events = events;
+    db;
+    config;
+    wipTs;
+    workers;
+    stopped;
+    queueCacheInterval;
+    timekeeper;
+    queues;
+    pendingOffWorkCleanups;
+    #spies;
+    constructor(db, config) {
+        super();
+        this.config = config;
+        this.db = db;
+        this.wipTs = Date.now();
+        this.workers = new Map();
+        this.queues = null;
+        this.pendingOffWorkCleanups = new Set();
+        this.#spies = new Map();
+    }
+    getSpy(name) {
+        if (!this.config.__test__enableSpies) {
+            throw new Error('Spy is not enabled. Set __test__enableSpies: true in constructor options to use spies.');
+        }
+        let spy = this.#spies.get(name);
+        if (!spy) {
+            spy = new JobSpy();
+            this.#spies.set(name, spy);
+        }
+        return spy;
+    }
+    clearSpies() {
+        for (const spy of this.#spies.values()) {
+            spy.clear();
+        }
+        this.#spies.clear();
+    }
+    async start() {
+        this.stopped = false;
+        this.queueCacheInterval = setInterval(() => this.onCacheQueues({ emit: true }), this.config.queueCacheIntervalSeconds * 1000);
+        await this.onCacheQueues();
+    }
+    async onCacheQueues({ emit = false } = {}) {
+        try {
+            assert(!this.config.__test__throw_queueCache, 'test error');
+            const queues = await this.getQueues();
+            this.queues = queues.reduce((acc, i) => { acc[i.name] = i; return acc; }, {});
+        }
+        catch (error) {
+            emit && this.emit(events.error, { ...error, message: error.message, stack: error.stack });
+        }
+    }
+    async getQueueCache(name) {
+        assert(this.queues, 'Queue cache is not initialized');
+        let queue = this.queues[name];
+        if (queue) {
+            return queue;
+        }
+        queue = await this.getQueue(name);
+        if (!queue) {
+            throw new Error(`Queue ${name} does not exist`);
+        }
+        this.queues[name] = queue;
+        return queue;
+    }
+    async stop() {
+        this.stopped = true;
+        clearInterval(this.queueCacheInterval);
+        await Promise.allSettled([...this.workers.values()]
+            .filter(worker => !INTERNAL_QUEUES[worker.name])
+            .map(async (worker) => await this.offWork(worker.name, { wait: false })));
+    }
+    async failWip() {
+        for (const worker of this.workers.values()) {
+            const jobIds = worker.jobs.map(j => j.id);
+            if (jobIds.length) {
+                await this.fail(worker.name, jobIds, 'pg-boss shut down while active');
+            }
+        }
+    }
+    async work(name, ...args) {
+        const { options, callback } = Attorney.checkWorkArgs(name, args);
+        if (this.stopped) {
+            throw new Error('Workers are disabled. pg-boss is stopped');
+        }
+        const { pollingInterval: interval, batchSize = 1, includeMetadata = false, priority = true } = options;
+        const id = randomUUID({ disableEntropyCache: true });
+        const fetch = () => this.fetch(name, { batchSize, includeMetadata, priority });
+        const onFetch = async (jobs) => {
+            if (!jobs.length) {
+                return;
+            }
+            if (this.config.__test__throw_worker) {
+                throw new Error('__test__throw_worker');
+            }
+            this.emitWip(name);
+            const spy = this.config.__test__enableSpies ? this.#spies.get(name) : undefined;
+            if (spy) {
+                for (const job of jobs) {
+                    spy.addJob(job.id, name, job.data, 'active');
+                }
+            }
+            const maxExpiration = jobs.reduce((acc, i) => Math.max(acc, i.expireInSeconds), 0);
+            const jobIds = jobs.map(job => job.id);
+            const ac = new AbortController();
+            jobs.forEach(job => { job.signal = ac.signal; });
+            try {
+                const result = await resolveWithinSeconds(callback(jobs), maxExpiration, `handler execution exceeded ${maxExpiration}s`, ac);
+                await this.complete(name, jobIds, jobIds.length === 1 ? result : undefined);
+                if (spy) {
+                    for (const job of jobs) {
+                        spy.addJob(job.id, name, job.data, 'completed', jobIds.length === 1 ? result : undefined);
+                    }
+                }
+            }
+            catch (err) {
+                await this.fail(name, jobIds, err);
+                if (spy) {
+                    for (const job of jobs) {
+                        spy.addJob(job.id, name, job.data, 'failed', { message: err?.message, stack: err?.stack });
+                    }
+                }
+            }
+            this.emitWip(name);
+        };
+        const onError = (error) => {
+            this.emit(events.error, { ...error, message: error.message, stack: error.stack, queue: name, worker: id });
+        };
+        const worker = new Worker({ id, name, options, interval, fetch, onFetch, onError });
+        this.addWorker(worker);
+        worker.start();
+        return id;
+    }
+    addWorker(worker) {
+        this.workers.set(worker.id, worker);
+    }
+    removeWorker(worker) {
+        this.workers.delete(worker.id);
+    }
+    getWorkers() {
+        return Array.from(this.workers.values());
+    }
+    emitWip(name) {
+        if (!INTERNAL_QUEUES[name]) {
+            const now = Date.now();
+            if (now - this.wipTs > 2000) {
+                this.emit(events.wip, this.getWipData());
+                this.wipTs = now;
+            }
+        }
+    }
+    getWipData(options = {}) {
+        const { includeInternal = false } = options;
+        const data = this.getWorkers()
+            .map(i => i.toWipData())
+            .filter(i => i.state !== 'stopped' && (!INTERNAL_QUEUES[i.name] || includeInternal));
+        return data;
+    }
+    hasPendingCleanups() {
+        return this.pendingOffWorkCleanups.size > 0;
+    }
+    async offWork(name, options = { wait: true }) {
+        assert(name, 'queue name is required');
+        assert(typeof name === 'string', 'queue name must be a string');
+        const query = (i) => options?.id ? i.id === options.id : i.name === name;
+        const workers = this.getWorkers().filter(i => query(i) && !i.stopping && !i.stopped);
+        if (workers.length === 0) {
+            return;
+        }
+        const cleanupPromise = Promise.allSettled(workers.map(async (worker) => {
+            await worker.stop();
+            this.removeWorker(worker);
+        }));
+        if (options.wait) {
+            await cleanupPromise;
+        }
+        else {
+            this.pendingOffWorkCleanups.add(cleanupPromise);
+            cleanupPromise.finally(() => this.pendingOffWorkCleanups.delete(cleanupPromise));
+        }
+    }
+    notifyWorker(workerId) {
+        this.workers.get(workerId)?.notify();
+    }
+    async subscribe(event, name) {
+        assert(event, 'Missing required argument');
+        assert(name, 'Missing required argument');
+        const sql = plans.subscribe(this.config.schema);
+        await this.db.executeSql(sql, [event, name]);
+    }
+    async unsubscribe(event, name) {
+        assert(event, 'Missing required argument');
+        assert(name, 'Missing required argument');
+        const sql = plans.unsubscribe(this.config.schema);
+        await this.db.executeSql(sql, [event, name]);
+    }
+    async publish(event, data, options) {
+        assert(event, 'Missing required argument');
+        const sql = plans.getQueuesForEvent(this.config.schema);
+        const { rows } = await this.db.executeSql(sql, [event]);
+        await Promise.allSettled(rows.map(({ name }) => this.send(name, data, options)));
+    }
+    async send(...args) {
+        const result = Attorney.checkSendArgs(args);
+        return await this.createJob(result);
+    }
+    async sendAfter(name, data, options, after) {
+        options = options ? { ...options } : {};
+        options.startAfter = after;
+        const result = Attorney.checkSendArgs([name, data, options]);
+        return await this.createJob(result);
+    }
+    async sendThrottled(name, data, options, seconds, key) {
+        options = options ? { ...options } : {};
+        options.singletonSeconds = seconds;
+        options.singletonNextSlot = false;
+        options.singletonKey = key;
+        const result = Attorney.checkSendArgs([name, data, options]);
+        return await this.createJob(result);
+    }
+    async sendDebounced(name, data, options, seconds, key) {
+        options = options ? { ...options } : {};
+        options.singletonSeconds = seconds;
+        options.singletonNextSlot = true;
+        options.singletonKey = key;
+        const result = Attorney.checkSendArgs([name, data, options]);
+        return await this.createJob(result);
+    }
+    async createJob(request) {
+        const { name, data = null, options = {} } = request;
+        const { id = null, db: wrapper, priority, startAfter, singletonKey = null, singletonSeconds, singletonNextSlot, expireInSeconds, deleteAfterSeconds, retentionSeconds, keepUntil, retryLimit, retryDelay, retryBackoff, retryDelayMax } = options;
+        const job = {
+            id,
+            name,
+            data,
+            priority,
+            startAfter,
+            singletonKey,
+            singletonSeconds,
+            singletonOffset: 0,
+            expireInSeconds,
+            deleteAfterSeconds,
+            retentionSeconds,
+            keepUntil,
+            retryLimit,
+            retryDelay,
+            retryBackoff,
+            retryDelayMax
+        };
+        const db = wrapper || this.db;
+        const { table } = await this.getQueueCache(name);
+        const sql = plans.insertJobs(this.config.schema, { table, name, returnId: true });
+        const { rows: try1 } = await db.executeSql(sql, [JSON.stringify([job])]);
+        if (try1.length === 1) {
+            const jobId = try1[0].id;
+            if (this.config.__test__enableSpies) {
+                const spy = this.#spies.get(name);
+                if (spy) {
+                    spy.addJob(jobId, name, data || {}, 'created');
+                }
+            }
+            return jobId;
+        }
+        if (singletonNextSlot) {
+            // delay starting by the offset to honor throttling config
+            job.startAfter = this.getDebounceStartAfter(singletonSeconds, this.timekeeper.clockSkew);
+            job.singletonOffset = singletonSeconds;
+            const { rows: try2 } = await db.executeSql(sql, [JSON.stringify([job])]);
+            if (try2.length === 1) {
+                const jobId = try2[0].id;
+                if (this.config.__test__enableSpies) {
+                    const spy = this.#spies.get(name);
+                    if (spy) {
+                        spy.addJob(jobId, name, data || {}, 'created');
+                    }
+                }
+                return jobId;
+            }
+        }
+        return null;
+    }
+    async insert(name, jobs, options = {}) {
+        assert(Array.isArray(jobs), 'jobs argument should be an array');
+        const { table } = await this.getQueueCache(name);
+        const db = this.assertDb(options);
+        const spy = this.config.__test__enableSpies ? this.#spies.get(name) : undefined;
+        // Return IDs if spy is active for this queue (needed for job tracking)
+        const returnId = !!spy;
+        const sql = plans.insertJobs(this.config.schema, { table, name, returnId });
+        const { rows } = await db.executeSql(sql, [JSON.stringify(jobs)]);
+        if (rows.length) {
+            if (spy) {
+                for (let i = 0; i < rows.length; i++) {
+                    spy.addJob(rows[i].id, name, jobs[i].data || {}, 'created');
+                }
+            }
+            return rows.map((i) => i.id);
+        }
+        return null;
+    }
+    getDebounceStartAfter(singletonSeconds, clockOffset) {
+        const debounceInterval = singletonSeconds * 1000;
+        const now = Date.now() + clockOffset;
+        const slot = Math.floor(now / debounceInterval) * debounceInterval;
+        // prevent startAfter=0 during debouncing
+        let startAfter = (singletonSeconds - Math.floor((now - slot) / 1000)) || 1;
+        if (singletonSeconds > 1) {
+            startAfter++;
+        }
+        return startAfter;
+    }
+    async fetch(name, options = {}) {
+        Attorney.checkFetchArgs(name, options);
+        const db = this.assertDb(options);
+        const { table, policy, singletonsActive } = await this.getQueueCache(name);
+        const fetchOptions = {
+            ...options,
+            schema: this.config.schema,
+            table,
+            name,
+            policy,
+            limit: options.batchSize || 1,
+            ignoreSingletons: singletonsActive
+        };
+        const sql = plans.fetchNextJob(fetchOptions);
+        let result;
+        try {
+            result = await db.executeSql(sql);
+        }
+        catch (err) {
+            // errors from fetchquery should only be unique constraint violations
+        }
+        return result?.rows || [];
+    }
+    mapCompletionIdArg(id, funcName) {
+        const errorMessage = `${funcName}() requires an id`;
+        assert(id, errorMessage);
+        const ids = Array.isArray(id) ? id : [id];
+        assert(ids.length, errorMessage);
+        return ids;
+    }
+    mapCompletionDataArg(data) {
+        if (data === null || typeof data === 'undefined' || typeof data === 'function') {
+            return null;
+        }
+        const result = (typeof data === 'object' && !Array.isArray(data))
+            ? data
+            : { value: data };
+        return stringify(result);
+    }
+    mapCommandResponse(ids, result) {
+        return {
+            jobs: ids,
+            requested: ids.length,
+            affected: result && result.rows ? parseInt(result.rows[0].count) : 0
+        };
+    }
+    async complete(name, id, data, options = {}) {
+        Attorney.assertQueueName(name);
+        const db = this.assertDb(options);
+        const ids = this.mapCompletionIdArg(id, 'complete');
+        const { table } = await this.getQueueCache(name);
+        const sql = plans.completeJobs(this.config.schema, table);
+        const result = await db.executeSql(sql, [name, ids, this.mapCompletionDataArg(data)]);
+        return this.mapCommandResponse(ids, result);
+    }
+    async fail(name, id, data, options = {}) {
+        Attorney.assertQueueName(name);
+        const db = this.assertDb(options);
+        const ids = this.mapCompletionIdArg(id, 'fail');
+        const { table } = await this.getQueueCache(name);
+        const sql = plans.failJobsById(this.config.schema, table);
+        const result = await db.executeSql(sql, [name, ids, this.mapCompletionDataArg(data)]);
+        return this.mapCommandResponse(ids, result);
+    }
+    async cancel(name, id, options = {}) {
+        Attorney.assertQueueName(name);
+        const db = this.assertDb(options);
+        const ids = this.mapCompletionIdArg(id, 'cancel');
+        const { table } = await this.getQueueCache(name);
+        const sql = plans.cancelJobs(this.config.schema, table);
+        const result = await db.executeSql(sql, [name, ids]);
+        return this.mapCommandResponse(ids, result);
+    }
+    async deleteJob(name, id, options = {}) {
+        Attorney.assertQueueName(name);
+        const db = this.assertDb(options);
+        const ids = this.mapCompletionIdArg(id, 'deleteJob');
+        const { table } = await this.getQueueCache(name);
+        const sql = plans.deleteJobsById(this.config.schema, table);
+        const result = await db.executeSql(sql, [name, ids]);
+        return this.mapCommandResponse(ids, result);
+    }
+    async resume(name, id, options = {}) {
+        Attorney.assertQueueName(name);
+        const db = this.assertDb(options);
+        const ids = this.mapCompletionIdArg(id, 'resume');
+        const { table } = await this.getQueueCache(name);
+        const sql = plans.resumeJobs(this.config.schema, table);
+        const result = await db.executeSql(sql, [name, ids]);
+        return this.mapCommandResponse(ids, result);
+    }
+    async retry(name, id, options = {}) {
+        Attorney.assertQueueName(name);
+        const db = options.db || this.db;
+        const ids = this.mapCompletionIdArg(id, 'retry');
+        const { table } = await this.getQueueCache(name);
+        const sql = plans.retryJobs(this.config.schema, table);
+        const result = await db.executeSql(sql, [name, ids]);
+        return this.mapCommandResponse(ids, result);
+    }
+    async createQueue(name, options = {}) {
+        name = name || options.name;
+        Attorney.assertQueueName(name);
+        const policy = options.policy || plans.QUEUE_POLICIES.standard;
+        assert(policy in plans.QUEUE_POLICIES, `${policy} is not a valid queue policy`);
+        Attorney.validateQueueArgs(options);
+        if (options.deadLetter) {
+            Attorney.assertQueueName(options.deadLetter);
+            notStrictEqual(name, options.deadLetter, 'deadLetter cannot be itself');
+            await this.getQueueCache(options.deadLetter);
+        }
+        const sql = plans.createQueue(this.config.schema, name, { ...options, policy });
+        await this.db.executeSql(sql);
+    }
+    async getQueues(names) {
+        names = Array.isArray(names) ? names : typeof names === 'string' ? [names] : undefined;
+        if (names) {
+            for (const name of names) {
+                Attorney.assertQueueName(name);
+            }
+        }
+        const sql = plans.getQueues(this.config.schema, names);
+        const { rows } = await this.db.executeSql(sql);
+        return rows;
+    }
+    async updateQueue(name, options = {}) {
+        Attorney.assertQueueName(name);
+        assert(Object.keys(options).length > 0, 'no properties found to update');
+        if ('policy' in options) {
+            throw new Error('queue policy cannot be changed after creation');
+        }
+        if ('partition' in options) {
+            throw new Error('queue partitioning cannot be changed after creation');
+        }
+        Attorney.validateQueueArgs(options);
+        const { deadLetter } = options;
+        if (deadLetter) {
+            Attorney.assertQueueName(deadLetter);
+            notStrictEqual(name, deadLetter, 'deadLetter cannot be itself');
+        }
+        const sql = plans.updateQueue(this.config.schema, { deadLetter });
+        await this.db.executeSql(sql, [name, options]);
+    }
+    async getQueue(name) {
+        Attorney.assertQueueName(name);
+        const sql = plans.getQueues(this.config.schema, [name]);
+        const { rows } = await this.db.executeSql(sql);
+        return rows[0] || null;
+    }
+    async deleteQueue(name) {
+        Attorney.assertQueueName(name);
+        try {
+            await this.getQueueCache(name);
+            const sql = plans.deleteQueue(this.config.schema, name);
+            await this.db.executeSql(sql);
+        }
+        catch { }
+    }
+    async deleteQueuedJobs(name) {
+        Attorney.assertQueueName(name);
+        const { table } = await this.getQueueCache(name);
+        const sql = plans.deleteQueuedJobs(this.config.schema, table);
+        await this.db.executeSql(sql, [name]);
+    }
+    async deleteStoredJobs(name) {
+        Attorney.assertQueueName(name);
+        const { table } = await this.getQueueCache(name);
+        const sql = plans.deleteStoredJobs(this.config.schema, table);
+        await this.db.executeSql(sql, [name]);
+    }
+    async deleteAllJobs(name) {
+        if (!name) {
+            const sql = plans.truncateTable(this.config.schema, 'job');
+            await this.db.executeSql(sql);
+            return;
+        }
+        Attorney.assertQueueName(name);
+        const { table, partition } = await this.getQueueCache(name);
+        if (partition) {
+            const sql = plans.truncateTable(this.config.schema, table);
+            await this.db.executeSql(sql);
+        }
+        else {
+            const sql = plans.deleteAllJobs(this.config.schema, table);
+            await this.db.executeSql(sql, [name]);
+        }
+    }
+    async getQueueStats(name) {
+        Attorney.assertQueueName(name);
+        const queue = await this.getQueueCache(name);
+        const sql = plans.getQueueStats(this.config.schema, queue.table, [name]);
+        const { rows } = await this.db.executeSql(sql);
+        return Object.assign(queue, rows.at(0) || {});
+    }
+    async getJobById(name, id, options = {}) {
+        Attorney.assertQueueName(name);
+        const db = this.assertDb(options);
+        const { table } = await this.getQueueCache(name);
+        const sql = plans.getJobById(this.config.schema, table);
+        const result1 = await db.executeSql(sql, [name, id]);
+        if (result1?.rows?.length === 1) {
+            return result1.rows[0];
+        }
+        else {
+            return null;
+        }
+    }
+    assertDb(options) {
+        if (options.db) {
+            return options.db;
+        }
+        if (this.db._pgbdb) {
+            assert(this.db.opened, 'Database connection is not opened');
+        }
+        return this.db;
+    }
+}
+export default Manager;

package/dist/migrationStore.d.ts

@@ -0,0 +1,7 @@
+import * as types from './types.ts';
+declare function rollback(schema: string, version: number, migrations?: types.Migration[]): string;
+declare function next(schema: string, version: number, migrations: types.Migration[] | undefined): string;
+declare function migrate(schema: string, version: number, migrations?: types.Migration[]): string;
+declare function getAll(schema: string): types.Migration[];
+export { rollback, next, migrate, getAll, };
+//# sourceMappingURL=migrationStore.d.ts.map

package/dist/migrationStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrationStore.d.ts","sourceRoot":"","sources":["../src/migrationStore.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AASnC,iBAAS,QAAQ,CAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,KAAK,CAAC,SAAS,EAAE,UAQjF;AAED,iBAAS,IAAI,CAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,CAAC,SAAS,EAAE,GAAG,SAAS,UAQxF;AAED,iBAAS,OAAO,CAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,KAAK,CAAC,SAAS,EAAE,UAehF;AAED,iBAAS,MAAM,CAAE,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC,SAAS,EAAE,CA0FlD;AAED,OAAO,EACL,QAAQ,EACR,IAAI,EACJ,OAAO,EACP,MAAM,GACP,CAAA"}

package/dist/migrationStore.js

@@ -0,0 +1,126 @@
+import assert from 'node:assert';
+import * as plans from "./plans.js";
+import * as types from "./types.js";
+function flatten(schema, commands, version) {
+    commands.unshift(plans.assertMigration(schema, version));
+    commands.push(plans.setVersion(schema, version));
+    return plans.locked(schema, commands);
+}
+function rollback(schema, version, migrations) {
+    migrations = migrations || getAll(schema);
+    const result = migrations.find(i => i.version === version);
+    assert(result, `Version ${version} not found.`);
+    return flatten(schema, result.uninstall || [], result.previous);
+}
+function next(schema, version, migrations) {
+    migrations = migrations || getAll(schema);
+    const result = migrations.find(i => i.previous === version);
+    assert(result, `Version ${version} not found.`);
+    return flatten(schema, result.install, result.version);
+}
+function migrate(schema, version, migrations) {
+    migrations = migrations || getAll(schema);
+    const result = migrations
+        .filter(i => i.previous >= version)
+        .sort((a, b) => a.version - b.version)
+        .reduce((acc, i) => {
+        acc.install = acc.install.concat(i.install);
+        acc.version = i.version;
+        return acc;
+    }, { install: [], version });
+    assert(result.install.length > 0, `Version ${version} not found.`);
+    return flatten(schema, result.install, result.version);
+}
+function getAll(schema) {
+    return [
+        {
+            release: '11.1.0',
+            version: 26,
+            previous: 25,
+            install: [
+                `
+        CREATE OR REPLACE FUNCTION ${schema}.create_queue(queue_name text, options jsonb)
+        RETURNS VOID AS
+        $$
+        DECLARE
+          tablename varchar := CASE WHEN options->>'partition' = 'true'
+                                THEN 'j' || encode(sha224(queue_name::bytea), 'hex')
+                                ELSE 'job_common'
+                                END;
+          queue_created_on timestamptz;
+        BEGIN
+
+          WITH q as (
+            INSERT INTO ${schema}.queue (
+              name,
+              policy,
+              retry_limit,
+              retry_delay,
+              retry_backoff,
+              retry_delay_max,
+              expire_seconds,
+              retention_seconds,
+              deletion_seconds,
+              warning_queued,
+              dead_letter,
+              partition,
+              table_name
+            )
+            VALUES (
+              queue_name,
+              options->>'policy',
+              COALESCE((options->>'retryLimit')::int, 2),
+              COALESCE((options->>'retryDelay')::int, 0),
+              COALESCE((options->>'retryBackoff')::bool, false),
+              (options->>'retryDelayMax')::int,
+              COALESCE((options->>'expireInSeconds')::int, 900),
+              COALESCE((options->>'retentionSeconds')::int, 1209600),
+              COALESCE((options->>'deleteAfterSeconds')::int, 604800),
+              COALESCE((options->>'warningQueueSize')::int, 0),
+              options->>'deadLetter',
+              COALESCE((options->>'partition')::bool, false),
+              tablename
+            )
+            ON CONFLICT DO NOTHING
+            RETURNING created_on
+          )
+          SELECT created_on into queue_created_on from q;
+
+          IF queue_created_on IS NULL OR options->>'partition' IS DISTINCT FROM 'true' THEN
+            RETURN;
+          END IF;
+
+          EXECUTE format('CREATE TABLE ${schema}.%I (LIKE ${schema}.job INCLUDING DEFAULTS)', tablename);
+
+          EXECUTE format('ALTER TABLE ${schema}.%1$I ADD PRIMARY KEY (name, id)', tablename);
+          EXECUTE format('ALTER TABLE ${schema}.%1$I ADD CONSTRAINT q_fkey FOREIGN KEY (name) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED', tablename);
+          EXECUTE format('ALTER TABLE ${schema}.%1$I ADD CONSTRAINT dlq_fkey FOREIGN KEY (dead_letter) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED', tablename);
+
+          EXECUTE format('CREATE INDEX %1$s_i5 ON ${schema}.%1$I (name, start_after) INCLUDE (priority, created_on, id) WHERE state < ''active''', tablename);
+          EXECUTE format('CREATE UNIQUE INDEX %1$s_i4 ON ${schema}.%1$I (name, singleton_on, COALESCE(singleton_key, '''')) WHERE state <> ''cancelled'' AND singleton_on IS NOT NULL', tablename);
+
+          IF options->>'policy' = 'short' THEN
+            EXECUTE format('CREATE UNIQUE INDEX %1$s_i1 ON ${schema}.%1$I (name, COALESCE(singleton_key, '''')) WHERE state = ''created'' AND policy = ''short''', tablename);
+          ELSIF options->>'policy' = 'singleton' THEN
+            EXECUTE format('CREATE UNIQUE INDEX %1$s_i2 ON ${schema}.%1$I (name, COALESCE(singleton_key, '''')) WHERE state = ''active'' AND policy = ''singleton''', tablename);
+          ELSIF options->>'policy' = 'stately' THEN
+            EXECUTE format('CREATE UNIQUE INDEX %1$s_i3 ON ${schema}.%1$I (name, state, COALESCE(singleton_key, '''')) WHERE state <= ''active'' AND policy = ''stately''', tablename);
+          ELSIF options->>'policy' = 'exclusive' THEN
+            EXECUTE format('CREATE UNIQUE INDEX %1$s_i6 ON ${schema}.%1$I (name, COALESCE(singleton_key, '''')) WHERE state <= ''active'' AND policy = ''exclusive''', tablename);
+          END IF;
+
+          EXECUTE format('ALTER TABLE ${schema}.%I ADD CONSTRAINT cjc CHECK (name=%L)', tablename, queue_name);
+          EXECUTE format('ALTER TABLE ${schema}.job ATTACH PARTITION ${schema}.%I FOR VALUES IN (%L)', tablename, queue_name);
+        END;
+        $$
+        LANGUAGE plpgsql;
+        `,
+                `CREATE UNIQUE INDEX job_i6 ON ${schema}.job_common (name, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'exclusive'`
+            ],
+            uninstall: [
+                `DROP INDEX ${schema}.job_i6`
+            ]
+        },
+    ];
+}
+export { rollback, next, migrate, getAll, };