bunqueue 2.8.60 → 2.9.2

package/dist/infrastructure/persistence/postgres/schemaInitialization.js

@@ -0,0 +1,226 @@
+import { postgresAdvisoryLockName } from './advisoryLocks';
+import { databaseNow } from './context';
+import { POSTGRES_ASSIGN_EVENT_COMMIT_BODY, POSTGRES_REGISTER_EVENT_ROWS_BODY, POSTGRES_REGISTER_WATERMARK_ROWS_BODY, } from './eventJournalSchema';
+import { POSTGRES_SCHEMA, POSTGRES_SCHEMA_VERSION } from './schema';
+import { hasCurrentPostgresGroupSchema } from './groupSchemaFingerprint';
+const EXPECTED_FUNCTION_BODIES = new Map([
+    ['bunqueue_register_event_rows', POSTGRES_REGISTER_EVENT_ROWS_BODY],
+    ['bunqueue_register_watermark_rows', POSTGRES_REGISTER_WATERMARK_ROWS_BODY],
+    ['bunqueue_assign_event_commit', POSTGRES_ASSIGN_EVENT_COMMIT_BODY],
+]);
+function normalizeFunctionBody(value) {
+    return value.replaceAll(/\s+/g, ' ').trim();
+}
+async function hasCurrentSchema(tx) {
+    const [table] = await tx `
+    SELECT to_regclass('bunqueue_schema_migrations') IS NOT NULL AS exists
+  `;
+    if (!table.exists)
+        return false;
+    const [migration] = await tx `
+    SELECT
+      EXISTS (
+        SELECT 1 FROM bunqueue_schema_migrations
+        WHERE version = ${POSTGRES_SCHEMA_VERSION}
+      ) AS current,
+      MAX(version) AS latest
+    FROM bunqueue_schema_migrations
+  `;
+    const latest = Number(migration.latest ?? 0);
+    if (latest > POSTGRES_SCHEMA_VERSION) {
+        throw new Error(`PostgreSQL schema version ${latest} is newer than supported version ${POSTGRES_SCHEMA_VERSION}`);
+    }
+    if (!migration.current)
+        return false;
+    const [objects] = await tx `
+    WITH expected_columns(table_name, column_name, type_name, not_null, default_kind) AS (
+      VALUES
+        ('bunqueue_events', 'transaction_id', 'bigint', TRUE, 'transaction'),
+        ('bunqueue_event_commits', 'namespace', 'text', TRUE, 'none'),
+        ('bunqueue_event_commits', 'transaction_id', 'bigint', TRUE, 'none'),
+        ('bunqueue_event_commits', 'commit_seq', 'bigint', FALSE, 'none'),
+        ('bunqueue_event_prune_watermarks', 'transaction_id', 'bigint', TRUE, 'transaction'),
+        ('bunqueue_event_prune_watermarks', 'commit_seq', 'bigint', FALSE, 'none'),
+        ('bunqueue_event_prune_watermarks', 'pruned_commit_seq', 'bigint', TRUE, 'zero'),
+        ('bunqueue_event_prune_watermarks', 'self_pruned_commit_seq', 'bigint', TRUE, 'zero'),
+        ('bunqueue_event_prune_watermarks', 'prunes_current_transaction', 'boolean', TRUE, 'false'),
+        ('bunqueue_brokers', 'session_id', 'text', FALSE, 'none'),
+        ('bunqueue_jobs', 'lease_broker_session_id', 'text', FALSE, 'none'),
+        ('bunqueue_workers', 'broker_session_id', 'text', FALSE, 'none'),
+        ('bunqueue_queue_state', 'group_sequence', 'bigint', TRUE, 'zero')
+    ), expected_indexes(
+      index_name, table_name, columns, descending, predicate, is_unique
+    ) AS (
+      VALUES
+        ('bunqueue_events_transaction_idx', 'bunqueue_events',
+         ARRAY['namespace', 'transaction_id', 'id'], ARRAY[FALSE, FALSE, FALSE], '', FALSE),
+        ('bunqueue_event_commits_replay_idx', 'bunqueue_event_commits',
+         ARRAY['namespace', 'commit_seq', 'transaction_id'], ARRAY[FALSE, FALSE, FALSE],
+         'commit_seqisnotnull', FALSE),
+        ('bunqueue_event_prune_watermarks_commit_idx', 'bunqueue_event_prune_watermarks',
+         ARRAY['namespace', 'queue', 'commit_seq'], ARRAY[FALSE, FALSE, TRUE],
+         'commit_seqisnotnull', FALSE),
+        ('bunqueue_event_prune_watermarks_pending_commit_idx',
+         'bunqueue_event_prune_watermarks', ARRAY['namespace', 'transaction_id'],
+         ARRAY[FALSE, FALSE], 'commit_seqisnull', FALSE),
+        ('bunqueue_event_prune_watermarks_transaction_idx',
+         'bunqueue_event_prune_watermarks', ARRAY['namespace', 'transaction_id'],
+         ARRAY[FALSE, FALSE], '', FALSE),
+        ('bunqueue_jobs_broker_session_lease_idx', 'bunqueue_jobs',
+         ARRAY['namespace', 'lease_broker_id', 'lease_broker_session_id', 'id'],
+         ARRAY[FALSE, FALSE, FALSE, FALSE], 'state=''active''::text', FALSE),
+        ('bunqueue_workers_broker_session_idx', 'bunqueue_workers',
+         ARRAY['namespace', 'broker_id', 'broker_session_id', 'client_id'],
+         ARRAY[FALSE, FALSE, FALSE, FALSE], '', FALSE),
+        ('bunqueue_jobs_live_unique_key_idx', 'bunqueue_jobs',
+         ARRAY['namespace', 'queue', 'unique_key'], ARRAY[FALSE, FALSE, FALSE],
+         'unique_keyisnotnullandstate=anyarray[''waiting''::text,''prioritized''::text,' ||
+         '''delayed''::text,''waiting-children''::text,''active''::text]', TRUE)
+    ), expected_triggers(
+      trigger_name, table_name, function_name, trigger_type, new_table,
+      is_constraint, is_deferrable
+    ) AS (
+      VALUES
+        ('bunqueue_events_register_commit', 'bunqueue_events',
+         'bunqueue_register_event_rows', 4, 'new_event_rows', FALSE, FALSE),
+        ('bunqueue_watermarks_insert_register_commit', 'bunqueue_event_prune_watermarks',
+         'bunqueue_register_watermark_rows', 4, 'new_watermark_rows', FALSE, FALSE),
+        ('bunqueue_watermarks_update_register_commit', 'bunqueue_event_prune_watermarks',
+         'bunqueue_register_watermark_rows', 16, 'new_watermark_rows', FALSE, FALSE),
+        ('bunqueue_assign_event_commit', 'bunqueue_event_commits',
+         'bunqueue_assign_event_commit', 5, NULL, TRUE, TRUE)
+    )
+    SELECT
+      EXISTS (
+        SELECT 1 FROM pg_sequence
+        WHERE seqrelid = to_regclass('bunqueue_event_commit_seq')
+          AND seqtypid = to_regtype('bigint')
+          AND seqincrement = 1 AND seqmin = 1
+          AND seqmax = 9223372036854775807
+          AND NOT seqcycle
+          AND seqcache = 1
+      )
+      AND to_regclass('bunqueue_event_commits') IS NOT NULL
+      AND (
+        SELECT COALESCE(bool_and(COALESCE(
+          attribute.atttypid = to_regtype(expected.type_name)
+          AND attribute.attnotnull = expected.not_null
+          AND CASE expected.default_kind
+            WHEN 'transaction' THEN regexp_replace(
+              lower(COALESCE(pg_get_expr(defaults.adbin, defaults.adrelid), '')),
+              '[()[:space:]]', '', 'g'
+            ) = 'pg_current_xact_id::text::bigint'
+            WHEN 'zero' THEN regexp_replace(
+              lower(COALESCE(pg_get_expr(defaults.adbin, defaults.adrelid), '')),
+              '[()[:space:]]', '', 'g'
+            ) IN ('0', '0::bigint')
+            WHEN 'false' THEN regexp_replace(
+              lower(COALESCE(pg_get_expr(defaults.adbin, defaults.adrelid), '')),
+              '[()[:space:]]', '', 'g'
+            ) IN ('false', 'false::boolean')
+            ELSE defaults.oid IS NULL
+          END,
+          FALSE
+        )), FALSE)
+        FROM expected_columns AS expected
+        LEFT JOIN pg_attribute AS attribute
+          ON attribute.attrelid = to_regclass(expected.table_name)
+         AND attribute.attname = expected.column_name AND NOT attribute.attisdropped
+        LEFT JOIN pg_attrdef AS defaults
+          ON defaults.adrelid = attribute.attrelid AND defaults.adnum = attribute.attnum
+      )
+      AND (
+        SELECT COALESCE(bool_and(COALESCE(
+          indexes.indrelid = to_regclass(expected.table_name)
+          AND indexes.indisvalid AND indexes.indisready
+          AND indexes.indisunique = expected.is_unique
+          AND NOT indexes.indisexclusion
+          AND indexes.indnkeyatts = cardinality(expected.columns)
+          AND indexes.indnatts = indexes.indnkeyatts
+          AND indexes.indexprs IS NULL
+          AND access_method.amname = 'btree'
+          AND ARRAY(
+            SELECT attribute.attname::text
+            FROM unnest(indexes.indkey::smallint[]) WITH ORDINALITY AS key(attnum, position)
+            JOIN pg_attribute AS attribute
+              ON attribute.attrelid = indexes.indrelid AND attribute.attnum = key.attnum
+            ORDER BY key.position
+          ) = expected.columns
+          AND ARRAY(
+            SELECT (option & 1) = 1
+            FROM unnest(indexes.indoption::smallint[]) WITH ORDINALITY AS ordering(option, position)
+            ORDER BY ordering.position
+          ) = expected.descending
+          AND regexp_replace(
+            lower(COALESCE(pg_get_expr(indexes.indpred, indexes.indrelid), '')),
+            '[()[:space:]]', '', 'g'
+          ) = expected.predicate,
+          FALSE
+        )), FALSE)
+        FROM expected_indexes AS expected
+        LEFT JOIN pg_class AS index_class ON index_class.oid = to_regclass(expected.index_name)
+        LEFT JOIN pg_index AS indexes ON indexes.indexrelid = index_class.oid
+        LEFT JOIN pg_am AS access_method ON access_method.oid = index_class.relam
+      )
+      AND (
+        SELECT COALESCE(bool_and(EXISTS (
+          SELECT 1 FROM pg_trigger AS trigger
+          WHERE trigger.tgrelid = to_regclass(expected.table_name)
+            AND trigger.tgname = expected.trigger_name
+            AND trigger.tgfoid = to_regprocedure(expected.function_name || '()')
+            AND NOT trigger.tgisinternal AND trigger.tgenabled = 'O'
+            AND trigger.tgtype = expected.trigger_type
+            AND trigger.tgnewtable IS NOT DISTINCT FROM expected.new_table
+            AND trigger.tgoldtable IS NULL
+            AND trigger.tgqual IS NULL AND trigger.tgnargs = 0
+            AND (trigger.tgconstraint <> 0) = expected.is_constraint
+            AND trigger.tgdeferrable = expected.is_deferrable
+            AND trigger.tginitdeferred = expected.is_deferrable
+        )), FALSE)
+        FROM expected_triggers AS expected
+      ) AS valid
+  `;
+    if (!objects.valid)
+        return false;
+    if (!(await hasCurrentPostgresGroupSchema(tx)))
+        return false;
+    const functions = await tx `
+    SELECT expected.name, functions.prosrc AS body,
+           functions.prorettype = to_regtype('trigger')
+             AND language.lanname = 'plpgsql'
+             AND functions.prokind = 'f'
+             AND functions.provolatile = 'v'
+             AND functions.proparallel = 'u'
+             AND NOT functions.prosecdef
+             AND NOT functions.proisstrict
+             AND functions.proconfig IS NULL
+             AND NOT functions.proleakproof AS canonical
+    FROM unnest(${tx.array([...EXPECTED_FUNCTION_BODIES.keys()], 'TEXT')}) AS expected(name)
+    LEFT JOIN pg_proc AS functions
+      ON functions.oid = to_regprocedure(expected.name || '()')
+    LEFT JOIN pg_language AS language ON language.oid = functions.prolang
+  `;
+    return (functions.length === EXPECTED_FUNCTION_BODIES.size &&
+        functions.every(({ name, body, canonical }) => {
+            const expected = EXPECTED_FUNCTION_BODIES.get(name);
+            return canonical && body !== null && expected !== undefined
+                ? normalizeFunctionBody(body) === normalizeFunctionBody(expected)
+                : false;
+        }));
+}
+/** Initialize or migrate the shared schema without locking live tables when current. */
+export async function initializePostgresSchema(ctx) {
+    const lockName = postgresAdvisoryLockName('schema');
+    await ctx.sql.begin(async (tx) => {
+        await tx `SELECT pg_advisory_xact_lock(hashtextextended(${lockName}, 0))`;
+        if (await hasCurrentSchema(tx))
+            return;
+        await tx.unsafe(POSTGRES_SCHEMA).simple();
+        const appliedAt = await databaseNow(tx);
+        await tx `
+      INSERT INTO bunqueue_schema_migrations (version, applied_at)
+      VALUES (${POSTGRES_SCHEMA_VERSION}, ${appliedAt})
+      ON CONFLICT (version) DO NOTHING
+    `;
+    });
+}

package/dist/infrastructure/persistence/postgres/serialAdmission.d.ts

@@ -0,0 +1,6 @@
+import type { TransactionSQL } from 'bun';
+import type { Job } from '../../../domain/types/job';
+import { type PostgresContext } from './context';
+import type { PostgresAdmissionResult } from './admissionResult';
+/** Reconcile same-batch dependency generations without reordering admission events. */
+export declare function reconcilePostgresSerialAdmissions(tx: TransactionSQL, ctx: PostgresContext, admissions: readonly PostgresAdmissionResult[]): Promise<Job[]>;

package/dist/infrastructure/persistence/postgres/serialAdmission.js

@@ -0,0 +1,96 @@
+import { decodePostgresJob, encodePostgresValue, eventPayload, postgresByteaBase64, postgresStateForJob, } from './codec';
+import { databaseNow } from './context';
+function latestInsertions(admissions) {
+    const latest = new Map();
+    for (let index = 0; index < admissions.length; index++) {
+        if (admissions[index].inserted)
+            latest.set(String(admissions[index].job.id), index);
+    }
+    return latest;
+}
+function correctedJob(row, admission, now) {
+    const stored = decodePostgresJob(row);
+    const state = postgresStateForJob(stored.job, row.dependencies_satisfied, now);
+    if (admission.timelineIndex === undefined)
+        return { job: stored.job, state };
+    const timeline = [...stored.job.timeline];
+    const entry = timeline[admission.timelineIndex];
+    if (entry)
+        timeline[admission.timelineIndex] = { ...entry, state };
+    return { job: { ...stored.job, timeline }, state };
+}
+async function loadFinalRows(tx, ctx, ids) {
+    return await tx `
+    SELECT job.*, NOT EXISTS (
+      SELECT 1
+      FROM bunqueue_dependencies AS dependency
+      WHERE dependency.namespace = job.namespace AND dependency.job_id = job.id
+        AND NOT EXISTS (
+          SELECT 1 FROM bunqueue_completions AS completion
+          WHERE completion.namespace = dependency.namespace
+            AND completion.job_id = dependency.dependency_id
+        )
+        AND NOT EXISTS (
+          SELECT 1 FROM bunqueue_jobs AS completed
+          WHERE completed.namespace = dependency.namespace
+            AND completed.id = dependency.dependency_id AND completed.state = 'completed'
+        )
+    ) AS dependencies_satisfied
+    FROM bunqueue_jobs AS job
+    WHERE job.namespace = ${ctx.config.namespace}
+      AND job.id = ANY(${tx.array([...ids], 'TEXT')})
+    ORDER BY job.id
+    FOR UPDATE OF job
+  `;
+}
+async function persistFinalRows(tx, ctx, prepared) {
+    if (prepared.length === 0)
+        return;
+    await tx `
+    UPDATE bunqueue_jobs AS job
+    SET payload = decode(batch.payload_base64, 'base64'), state = batch.state
+    FROM unnest(
+      ${tx.array(prepared.map(({ id }) => id), 'TEXT')},
+      ${tx.array(prepared.map(({ payload }) => payload), 'TEXT')},
+      ${tx.array(prepared.map(({ state }) => state), 'TEXT')}
+    ) AS batch(id, payload_base64, state)
+    WHERE job.namespace = ${ctx.config.namespace} AND job.id = batch.id
+  `;
+    await tx `
+    UPDATE bunqueue_events AS event
+    SET payload = decode(batch.payload_base64, 'base64')
+    FROM unnest(
+      ${tx.array(prepared.map(({ eventId }) => eventId), 'BIGINT')},
+      ${tx.array(prepared.map(({ eventPayload: payload }) => payload), 'TEXT')}
+    ) AS batch(id, payload_base64)
+    WHERE event.namespace = ${ctx.config.namespace} AND event.id = batch.id
+  `;
+}
+/** Reconcile same-batch dependency generations without reordering admission events. */
+export async function reconcilePostgresSerialAdmissions(tx, ctx, admissions) {
+    const latest = latestInsertions(admissions);
+    if (latest.size === 0)
+        return admissions.map(({ job }) => job);
+    const now = await databaseNow(tx);
+    const rows = await loadFinalRows(tx, ctx, [...latest.keys()]);
+    const prepared = rows.map((row) => {
+        const insertionIndex = latest.get(row.id);
+        const admission = admissions[insertionIndex];
+        const { job, state } = correctedJob(row, admission, now);
+        return {
+            id: row.id,
+            job,
+            state,
+            payload: postgresByteaBase64(encodePostgresValue(job)),
+            eventId: admission.pushedEventId,
+            eventPayload: postgresByteaBase64(eventPayload({ job, state })),
+            insertionIndex,
+        };
+    });
+    await persistFinalRows(tx, ctx, prepared);
+    const survivors = new Map(prepared.map((entry) => [entry.id, entry]));
+    return admissions.map((admission, index) => {
+        const survivor = survivors.get(String(admission.job.id));
+        return survivor && index >= survivor.insertionIndex ? survivor.job : admission.job;
+    });
+}

package/dist/infrastructure/persistence/postgres/snapshotBudget.d.ts

@@ -0,0 +1,3 @@
+import type { PostgresContext, PostgresReadSql } from './context';
+/** Reject an unsafe local read model before allocating or decoding its payloads. */
+export declare function assertPostgresSnapshotBudget(ctx: PostgresContext, sql: PostgresReadSql, queue?: string): Promise<void>;

package/dist/infrastructure/persistence/postgres/snapshotBudget.js

@@ -0,0 +1,83 @@
+/** Reject an unsafe local read model before allocating or decoding its payloads. */
+export async function assertPostgresSnapshotBudget(ctx, sql, queue) {
+    const queueFilter = queue ?? null;
+    const [weight] = await sql `
+    WITH retained_jobs AS MATERIALIZED (
+      SELECT payload, result, dlq_entry, dlq_retry_state
+      FROM bunqueue_jobs
+      WHERE namespace = ${ctx.config.namespace}
+        AND (${queueFilter}::text IS NULL OR queue = ${queueFilter})
+        AND (${queueFilter}::text IS NOT NULL OR state <> 'completed')
+      UNION ALL
+      (
+        SELECT payload, result, dlq_entry, dlq_retry_state
+        FROM bunqueue_jobs
+        WHERE namespace = ${ctx.config.namespace}
+          AND ${queueFilter}::text IS NULL
+          AND state = 'completed'
+        ORDER BY completed_at DESC NULLS LAST, id DESC
+        LIMIT ${ctx.config.maxCompletedJobs}
+      )
+    ), pinned AS MATERIALIZED (
+      SELECT DISTINCT dependency.dependency_id AS job_id
+      FROM bunqueue_dependencies AS dependency
+      JOIN bunqueue_jobs AS consumer
+        ON consumer.namespace = dependency.namespace AND consumer.id = dependency.job_id
+      WHERE dependency.namespace = ${ctx.config.namespace}
+        AND consumer.state = ANY(${sql.array(['waiting', 'prioritized', 'delayed', 'waiting-children', 'active'], 'TEXT')})
+    ), recent_completions AS MATERIALIZED (
+      SELECT completion.job_id, completion.result
+      FROM bunqueue_completions AS completion
+      WHERE completion.namespace = ${ctx.config.namespace}
+        AND (${queueFilter}::text IS NULL OR completion.queue = ${queueFilter})
+        AND NOT EXISTS (
+          SELECT 1 FROM pinned WHERE pinned.job_id = completion.job_id
+        )
+      ORDER BY completion.completed_at DESC, completion.job_id DESC
+      LIMIT ${ctx.config.maxJobResults}
+    ), selected_completions AS MATERIALIZED (
+      SELECT completion.job_id, completion.result
+      FROM bunqueue_completions AS completion
+      JOIN pinned ON pinned.job_id = completion.job_id
+      WHERE completion.namespace = ${ctx.config.namespace}
+        AND (${queueFilter}::text IS NULL OR completion.queue = ${queueFilter})
+      UNION ALL
+      SELECT job_id, result FROM recent_completions
+    )
+    SELECT
+      (
+        (SELECT COUNT(*) FROM retained_jobs) +
+        (SELECT COUNT(*) FROM selected_completions)
+      )::bigint AS items,
+      (
+        COALESCE((
+          SELECT SUM(
+            octet_length(payload) + COALESCE(octet_length(result), 0) +
+            COALESCE(octet_length(dlq_entry), 0) +
+            COALESCE(octet_length(dlq_retry_state), 0)
+          ) FROM retained_jobs
+        ), 0) +
+        COALESCE((SELECT SUM(COALESCE(octet_length(result), 0)) FROM selected_completions), 0) +
+        COALESCE((
+          SELECT SUM(octet_length(payload)) FROM bunqueue_crons
+          WHERE namespace = ${ctx.config.namespace} AND ${queueFilter}::text IS NULL
+        ), 0) +
+        COALESCE((
+          SELECT SUM(
+            COALESCE(octet_length(stall_config), 0) +
+            COALESCE(octet_length(dlq_config), 0)
+          ) FROM bunqueue_queue_state
+          WHERE namespace = ${ctx.config.namespace}
+            AND (${queueFilter}::text IS NULL OR queue = ${queueFilter})
+        ), 0)
+      )::bigint AS payload_bytes
+  `;
+    const scope = queue === undefined ? 'manager' : `queue "${queue}"`;
+    if (Number(weight.items) > ctx.config.maxSnapshotJobs) {
+        throw new Error(`PostgreSQL ${scope} snapshot exceeds maxSnapshotJobs=${ctx.config.maxSnapshotJobs}`);
+    }
+    if (Number(weight.payload_bytes) > ctx.config.maxSnapshotPayloadBytes) {
+        throw new Error(`PostgreSQL ${scope} snapshot exceeds ` +
+            `maxSnapshotPayloadBytes=${ctx.config.maxSnapshotPayloadBytes}`);
+    }
+}

package/dist/infrastructure/persistence/postgres/storageHealth.d.ts

@@ -0,0 +1,10 @@
+import type { PostgresStorageHealth, ResolvedPostgresStorageConfig } from './types';
+/** Aggregate independent PostgreSQL subsystem failures without hiding older degradation. */
+export declare class PostgresStorageHealthTracker {
+    private readonly config;
+    private readonly errors;
+    constructor(config: ResolvedPostgresStorageConfig);
+    record(key: string, error: unknown, prefix?: string): void;
+    clear(key: string): void;
+    snapshot(): PostgresStorageHealth;
+}

package/dist/infrastructure/persistence/postgres/storageHealth.js

@@ -0,0 +1,29 @@
+/** Aggregate independent PostgreSQL subsystem failures without hiding older degradation. */
+export class PostgresStorageHealthTracker {
+    config;
+    errors = new Map();
+    constructor(config) {
+        this.config = config;
+    }
+    record(key, error, prefix = '') {
+        const message = error instanceof Error ? error.message : String(error);
+        const since = this.errors.get(key)?.since ?? Date.now();
+        this.errors.set(key, { message: `${prefix}${message}`, since });
+    }
+    clear(key) {
+        this.errors.delete(key);
+    }
+    snapshot() {
+        const errors = [...this.errors.entries()].sort(([left], [right]) => left.localeCompare(right));
+        const messages = errors.map(([, { message }]) => message);
+        const sinceValues = errors.map(([, { since }]) => since);
+        return {
+            ok: messages.length === 0,
+            error: messages.length > 0 ? messages.join('; ') : null,
+            since: sinceValues.length > 0 ? Math.min(...sinceValues) : null,
+            backend: 'postgres',
+            brokerId: this.config.brokerId,
+            namespace: this.config.namespace,
+        };
+    }
+}

package/dist/infrastructure/persistence/postgres/store.d.ts

@@ -0,0 +1,100 @@
+import type { JobId } from '../../../domain/types/job';
+import { setPostgresDlqConfig, setPostgresStallConfig } from './control';
+import { type ListPostgresJobsOptions } from './queries';
+import { PostgresAdmissionStore } from './admissionStore';
+import type { CronJobInput } from '../../../domain/types/cron';
+import { type GroupPullOptions } from '../../../domain/types/group';
+import type { Worker } from '../../../domain/types/worker';
+import type { QueueMetricType } from '../../../domain/types/metrics';
+import type { ClaimedPostgresJob, PostgresCompletionInput, PostgresFailureInput } from './types';
+import { finalizePostgresLifetimeMetrics } from './lifetimeMetricsFinalizer';
+import { loadPostgresJobProjections } from './readModels';
+/** Database-authoritative PostgreSQL queue store safe for concurrent brokers. */
+export declare class PostgresQueueStore extends PostgresAdmissionStore {
+    getGroupJobsCount: (queue: string, groupId?: string) => Promise<number>;
+    getGroupActiveCount: (queue: string, groupId: string) => Promise<number>;
+    setGroupRateLimit: (queue: string, groupId: string, max: number, duration: number) => Promise<void>;
+    getGroupRateLimit: (queue: string, groupId: string) => Promise<import("../../../domain/types/group").GroupRateLimitOverride | null>;
+    removeGroupRateLimit: (queue: string, groupId: string) => Promise<number>;
+    getGroupRateLimitTtl: (queue: string, groupId: string, maxJobs?: number) => Promise<number>;
+    setGroupConcurrency: (queue: string, groupId: string, concurrency: number) => Promise<void>;
+    getGroupConcurrency: (queue: string, groupId: string) => Promise<number | null>;
+    removeGroupConcurrency: (queue: string, groupId: string) => Promise<number>;
+    now(): Promise<number>;
+    claim(queue: string, count: number, owner?: string, leaseDurationMs?: number, groupOptions?: GroupPullOptions): Promise<ClaimedPostgresJob[]>;
+    complete(id: JobId, token: string, result?: unknown, remove?: boolean): Promise<import("./types").PostgresTransitionResult>;
+    completeMany(items: readonly PostgresCompletionInput[]): Promise<import("./types").PostgresBatchCompletionResult[]>;
+    fail(input: PostgresFailureInput): Promise<import("./types").PostgresTransitionResult>;
+    renew(id: JobId, token: string, durationMs: number): Promise<number | null>;
+    recoverExpired(limit?: number): Promise<number>;
+    maintainDlq(limit?: number): Promise<import("./dlqLifecycle").PostgresDlqMaintenanceResult>;
+    addCron: (input: CronJobInput) => Promise<import("../../../domain/types").CronJob>;
+    getCron: (name: string) => Promise<import("../../../domain/types").CronJob | undefined>;
+    listCrons: () => Promise<import("../../../domain/types").CronJob[]>;
+    removeCron: (name: string) => Promise<boolean>;
+    processCrons: (limit?: number) => Promise<number>;
+    saveWorker: (worker: Worker) => Promise<void>;
+    heartbeatWorker: (id: string, stats?: {
+        activeJobs?: number;
+        processed?: number;
+        failed?: number;
+    }, clientId?: string) => Promise<boolean>;
+    removeWorker: (id: string, clientId?: string) => Promise<boolean>;
+    removeClientWorkers: (clientId: string) => Promise<number>;
+    listWorkers: () => Promise<Worker[]>;
+    getQueueMetrics: (queue: string, type: QueueMetricType, start?: number, end?: number) => Promise<import("../../../client").QueueMetrics>;
+    trimQueueEvents: (queue: string, maxLength: number) => Promise<number>;
+    releaseClientLease: (id: JobId, token: string) => Promise<boolean>;
+    getJob: (id: JobId) => Promise<import("./types").PostgresStoredJob | null>;
+    getJobs: (ids: readonly JobId[]) => Promise<import("./types").PostgresStoredJob[]>;
+    findMissingDependencies: (ids: readonly JobId[]) => Promise<JobId[]>;
+    getResult: (id: JobId) => Promise<{
+        found: boolean;
+        result: unknown;
+    }>;
+    getCounts: (queue?: string) => Promise<import("./types").PostgresCounts>;
+    getQueues: () => Promise<string[]>;
+    getDlq: (queue: string, limit?: number) => Promise<import("../../../domain/types/dlq").DlqEntry[]>;
+    getChildrenValues: (id: JobId) => Promise<Record<string, unknown>>;
+    getFailedChildrenValues: (id: JobId) => Promise<Record<string, string>>;
+    getIgnoredChildrenFailures: (id: JobId) => Promise<Record<string, string>>;
+    addLog: (id: JobId, message: string, level: "info" | "warn" | "error") => Promise<boolean>;
+    getLogs: (id: JobId) => Promise<import("../../../domain/types/worker").JobLogEntry[]>;
+    clearLogs: (id: JobId, keepLogs?: number) => Promise<void>;
+    getQueueState: (queue: string) => Promise<import("./types").PostgresQueueState>;
+    list: (queue: string, options?: ListPostgresJobsOptions) => Promise<import("./types").PostgresStoredJob[]>;
+    loadAll: () => Promise<import("./types").PostgresStoredJob[]>;
+    loadResults: (queue?: string) => Promise<import("./types").PostgresCompletionResult[]>;
+    latestEventId: () => Promise<number>;
+    loadLifetimeMetrics: () => Promise<import("./lifetimeMetrics").PostgresLifetimeMetricsSnapshot>;
+    finalizeLifetimeMetrics: (apply: Parameters<typeof finalizePostgresLifetimeMetrics>[1]) => Promise<void>;
+    loadCloudReadModel: () => Promise<import("./cloudReadModel").PostgresCloudReadModel>;
+    loadManagerSnapshot: () => Promise<import("./readModels").PostgresManagerSnapshot>;
+    loadQueueReadModel: (queue: string) => Promise<import("./readModels").PostgresQueueReadModel>;
+    loadJobProjections: (requests: Parameters<typeof loadPostgresJobProjections>[1]) => Promise<ReadonlyMap<JobId, import("./readModels").PostgresJobProjection>>;
+    updateData: (id: JobId, data: unknown) => Promise<boolean>;
+    updateProgress: (id: JobId, value: number, message?: string) => Promise<boolean>;
+    changePriority: (id: JobId, priority: number, lifo?: boolean) => Promise<boolean>;
+    changeDelay: (id: JobId, runAt: number, token?: string) => Promise<boolean>;
+    moveToWaitingChildren: (id: JobId, token?: string) => Promise<boolean>;
+    clearUniqueKey: (id: JobId) => Promise<boolean>;
+    removeDependency: (id: JobId) => Promise<boolean>;
+    removeUnprocessedChildren: (parentId: JobId) => Promise<JobId[]>;
+    updateParent: (childId: JobId, parentId: JobId) => Promise<void>;
+    promote: (id: JobId) => Promise<boolean>;
+    cancel: (id: JobId) => Promise<boolean>;
+    discard: (id: JobId, token?: string) => Promise<boolean>;
+    remove: (id: JobId, token?: string) => Promise<boolean>;
+    removeDlq: (queue: string, id: JobId) => Promise<boolean>;
+    purgeDlq: (queue: string) => Promise<JobId[]>;
+    clean: (queue: string, graceMs: number, state?: string, limit?: number) => Promise<JobId[]>;
+    retry: (id: JobId, timestamp?: number) => Promise<boolean>;
+    pause: (queue: string, paused: boolean) => Promise<void>;
+    setRateLimit: (queue: string, limit: number | null, durationMs: number | null, ttlMs?: number | null) => Promise<void>;
+    setConcurrency: (queue: string, limit: number | null) => Promise<void>;
+    setStallConfig: (queue: string, config: Parameters<typeof setPostgresStallConfig>[2]) => Promise<void>;
+    setDlqConfig: (queue: string, config: Parameters<typeof setPostgresDlqConfig>[2]) => Promise<void>;
+    drain: (queue: string) => Promise<number>;
+    obliterate: (queue: string) => Promise<number>;
+    promoteMany: (queue: string, count?: number) => Promise<JobId[]>;
+}