duron 0.1.1 → 0.2.1

package/dist/adapters/postgres/postgres.js

@@ -1,32 +1,16 @@
 import { join } from 'node:path';
-import { and, asc, between, desc, eq, gt, gte, ilike, inArray, isNull, ne, or, sql } from 'drizzle-orm';
 import { drizzle } from 'drizzle-orm/postgres-js';
 import { migrate } from 'drizzle-orm/postgres-js/migrator';
-import { JOB_STATUS_ACTIVE, JOB_STATUS_CANCELLED, JOB_STATUS_COMPLETED, JOB_STATUS_CREATED, JOB_STATUS_FAILED, STEP_STATUS_ACTIVE, STEP_STATUS_CANCELLED, STEP_STATUS_COMPLETED, STEP_STATUS_FAILED, } from '../../constants.js';
-import { Adapter, } from '../adapter.js';
-import createSchema from './schema.js';
+import { PostgresBaseAdapter } from './base.js';
 const noop = () => {
 };
-export class PostgresAdapter extends Adapter {
-    options;
-    db;
-    tables;
-    constructor(options) {
-        super();
-        this.options = {
-            connection: options.connection,
-            schema: options.schema ?? 'duron',
-            migrateOnStart: options.migrateOnStart ?? true,
-        };
-        this.tables = createSchema(this.options.schema);
-        this._initDb();
-    }
+export class PostgresAdapter extends PostgresBaseAdapter {
     _initDb() {
-        const postgresConnection = typeof this.options.connection === 'string'
+        const postgresConnection = typeof this.connection === 'string'
             ? {
-                url: this.options.connection,
+                url: this.connection,
             }
-            : this.options.connection;
+            : this.connection;
         this.db = drizzle({
             connection: {
                 ...postgresConnection,
@@ -39,828 +23,31 @@ export class PostgresAdapter extends Adapter {
         });
     }
     async _start() {
-        if (this.options.migrateOnStart) {
+        if (this.migrateOnStart) {
             await migrate(this.db, {
                 migrationsFolder: join(import.meta.dirname, '..', '..', '..', 'migrations', 'postgres'),
                 migrationsTable: 'migrations',
                 migrationsSchema: 'duron',
             });
         }
-        await this._listen(`ping-${this.id}`, async (payload) => {
-            const fromOwnerId = JSON.parse(payload).fromOwnerId;
-            await this._notify(`pong-${fromOwnerId}`, { toOwnerId: this.id });
-        });
-        await this._listen(`job-status-changed`, (payload) => {
-            if (this.listenerCount('job-status-changed') > 0) {
-                const { jobId, status, ownerId } = JSON.parse(payload);
-                this.emit('job-status-changed', { jobId, status, ownerId });
-            }
-        });
-        await this._listen(`job-available`, (payload) => {
-            if (this.listenerCount('job-available') > 0) {
-                const { jobId } = JSON.parse(payload);
-                this.emit('job-available', { jobId });
-            }
-        });
+        await super._start();
     }
     async _stop() {
         await this.db.$client.end({
             timeout: 5_000,
         });
     }
-    async _createJob({ queue, groupKey, input, timeoutMs, checksum, concurrencyLimit }) {
-        const [result] = await this.db
-            .insert(this.tables.jobsTable)
-            .values({
-            action_name: queue,
-            group_key: groupKey,
-            checksum,
-            input,
-            status: JOB_STATUS_CREATED,
-            timeout_ms: timeoutMs,
-            concurrency_limit: concurrencyLimit,
-        })
-            .returning({ id: this.tables.jobsTable.id });
-        if (!result) {
-            return null;
-        }
-        return result.id;
-    }
-    async _completeJob({ jobId, output }) {
-        const result = await this.db
-            .update(this.tables.jobsTable)
-            .set({
-            status: JOB_STATUS_COMPLETED,
-            output,
-            finished_at: sql `now()`,
-        })
-            .where(and(eq(this.tables.jobsTable.id, jobId), eq(this.tables.jobsTable.status, JOB_STATUS_ACTIVE), eq(this.tables.jobsTable.owner_id, this.id), gt(this.tables.jobsTable.expires_at, sql `now()`)))
-            .returning({ id: this.tables.jobsTable.id });
-        return result.length > 0;
-    }
-    async _failJob({ jobId, error }) {
-        const result = await this.db
-            .update(this.tables.jobsTable)
-            .set({
-            status: JOB_STATUS_FAILED,
-            error,
-            finished_at: sql `now()`,
-        })
-            .where(and(eq(this.tables.jobsTable.id, jobId), eq(this.tables.jobsTable.status, JOB_STATUS_ACTIVE), eq(this.tables.jobsTable.owner_id, this.id)))
-            .returning({ id: this.tables.jobsTable.id });
-        return result.length > 0;
-    }
-    async _cancelJob({ jobId }) {
-        const result = await this.db
-            .update(this.tables.jobsTable)
-            .set({
-            status: JOB_STATUS_CANCELLED,
-            finished_at: sql `now()`,
-        })
-            .where(and(eq(this.tables.jobsTable.id, jobId), or(eq(this.tables.jobsTable.status, JOB_STATUS_ACTIVE), eq(this.tables.jobsTable.status, JOB_STATUS_CREATED))))
-            .returning({ id: this.tables.jobsTable.id });
-        return result.length > 0;
-    }
-    async _retryJob({ jobId }) {
-        const result = this._map(await this.db.execute(sql `
-      WITH locked_source AS (
-        -- Lock the source job row to prevent concurrent retries
-        SELECT
-          j.action_name,
-          j.group_key,
-          j.checksum,
-          j.input,
-          j.timeout_ms,
-          j.created_at,
-          j.concurrency_limit
-        FROM ${this.tables.jobsTable} j
-        WHERE j.id = ${jobId}
-          AND j.status IN (${JOB_STATUS_COMPLETED}, ${JOB_STATUS_CANCELLED}, ${JOB_STATUS_FAILED})
-        FOR UPDATE OF j SKIP LOCKED
-      ),
-      existing_retry AS (
-        -- Check if a retry already exists (a newer job with same checksum, group_key, and input)
-        SELECT j.id
-        FROM ${this.tables.jobsTable} j
-        INNER JOIN locked_source ls
-          ON j.action_name = ls.action_name
-          AND j.group_key = ls.group_key
-          AND j.checksum = ls.checksum
-          AND j.input = ls.input
-          AND j.created_at > ls.created_at
-        WHERE j.status IN (${JOB_STATUS_CREATED}, ${JOB_STATUS_ACTIVE})
-        LIMIT 1
-      ),
-      inserted_retry AS (
-        -- Insert the retry only if no existing retry was found
-        -- Get concurrency_limit from the latest job at insertion time to avoid stale values
-        INSERT INTO ${this.tables.jobsTable} (
-          action_name,
-          group_key,
-          checksum,
-          input,
-          status,
-          timeout_ms,
-          concurrency_limit
-        )
-        SELECT
-          ls.action_name,
-          ls.group_key,
-          ls.checksum,
-          ls.input,
-          ${JOB_STATUS_CREATED},
-          ls.timeout_ms,
-          COALESCE(
-            (
-              SELECT j.concurrency_limit
-              FROM ${this.tables.jobsTable} j
-              WHERE j.action_name = ls.action_name
-                AND j.group_key = ls.group_key
-                AND (j.expires_at IS NULL OR j.expires_at > now())
-              ORDER BY j.created_at DESC, j.id DESC
-              LIMIT 1
-            ),
-            ls.concurrency_limit
-          )
-        FROM locked_source ls
-        WHERE NOT EXISTS (SELECT 1 FROM existing_retry)
-        RETURNING id
-      )
-      -- Return only the newly inserted retry ID (not existing retries)
-      SELECT id FROM inserted_retry
-      LIMIT 1
-    `));
-        if (result.length === 0) {
-            return null;
-        }
-        return result[0].id;
-    }
-    async _deleteJob({ jobId }) {
-        const result = await this.db
-            .delete(this.tables.jobsTable)
-            .where(and(eq(this.tables.jobsTable.id, jobId), ne(this.tables.jobsTable.status, JOB_STATUS_ACTIVE)))
-            .returning({ id: this.tables.jobsTable.id });
-        if (result.length > 0) {
-            await this.db.delete(this.tables.jobStepsTable).where(eq(this.tables.jobStepsTable.job_id, jobId));
-        }
-        return result.length > 0;
-    }
-    async _deleteJobs(options) {
-        const jobsTable = this.tables.jobsTable;
-        const filters = options?.filters ?? {};
-        const where = this._buildJobsWhereClause(filters);
-        const result = await this.db.delete(jobsTable).where(where).returning({ id: jobsTable.id });
-        return result.length;
-    }
-    async _fetch({ batch }) {
-        const result = this._map(await this.db.execute(sql `
-      WITH group_concurrency AS (
-        -- Get the concurrency limit from the latest job for each group
-        SELECT DISTINCT ON (j.group_key, j.action_name)
-          j.group_key as group_key,
-          j.action_name as action_name,
-          j.concurrency_limit as concurrency_limit
-        FROM ${this.tables.jobsTable} j
-        WHERE j.group_key IS NOT NULL
-          AND (j.expires_at IS NULL OR j.expires_at > now())
-        ORDER BY j.group_key, j.action_name, j.created_at DESC, j.id DESC
-      ),
-      eligible_groups AS (
-        -- Find all groups with their active counts that are below their concurrency limit
-        SELECT
-          gc.group_key,
-          gc.action_name,
-          gc.concurrency_limit,
-          COUNT(*) FILTER (WHERE j.status = ${JOB_STATUS_ACTIVE}) as active_count
-        FROM group_concurrency gc
-        LEFT JOIN ${this.tables.jobsTable} j
-          ON j.group_key = gc.group_key
-          AND j.action_name = gc.action_name
-          AND (j.expires_at IS NULL OR j.expires_at > now())
-        GROUP BY gc.group_key, gc.action_name, gc.concurrency_limit
-        HAVING COUNT(*) FILTER (WHERE j.status = ${JOB_STATUS_ACTIVE}) < gc.concurrency_limit
-      ),
-      candidate_jobs AS (
-        -- Lock candidate jobs first (before applying window functions)
-        SELECT
-          j.id,
-          j.action_name,
-          j.group_key as job_group_key,
-          j.created_at
-        FROM ${this.tables.jobsTable} j
-        INNER JOIN eligible_groups eg
-          ON j.group_key = eg.group_key
-          AND j.action_name = eg.action_name
-        WHERE j.status = ${JOB_STATUS_CREATED}
-        FOR UPDATE OF j SKIP LOCKED
-      ),
-      ranked_jobs AS (
-        -- Rank jobs within each group after locking
-        SELECT
-          cj.id,
-          cj.action_name,
-          cj.job_group_key,
-          cj.created_at,
-          ROW_NUMBER() OVER (
-            PARTITION BY cj.job_group_key, cj.action_name
-            ORDER BY cj.created_at ASC, cj.id ASC
-          ) as job_rank
-        FROM candidate_jobs cj
-      ),
-      next_job AS (
-        -- Select only jobs that fit within the concurrency limit per group
-        -- Ordered globally by created_at to respect job creation order
-        SELECT rj.id, rj.action_name, rj.job_group_key
-        FROM ranked_jobs rj
-        INNER JOIN eligible_groups eg
-          ON rj.job_group_key = eg.group_key
-          AND rj.action_name = eg.action_name
-        WHERE rj.job_rank <= (eg.concurrency_limit - eg.active_count)
-        ORDER BY rj.created_at ASC, rj.id ASC
-        LIMIT ${batch}
-      ),
-      verify_concurrency AS (
-        -- Double-check concurrency limit after acquiring lock
-        SELECT
-          nj.id,
-          nj.action_name,
-          nj.job_group_key,
-          eg.concurrency_limit,
-          (SELECT COUNT(*)
-          FROM ${this.tables.jobsTable}
-          WHERE action_name = nj.action_name
-            AND group_key = nj.job_group_key
-            AND status = ${JOB_STATUS_ACTIVE}) as current_active
-        FROM next_job nj
-        INNER JOIN eligible_groups eg
-          ON nj.job_group_key = eg.group_key
-          AND nj.action_name = eg.action_name
-      )
-      UPDATE ${this.tables.jobsTable} j
-      SET status = ${JOB_STATUS_ACTIVE},
-          started_at = now(),
-          expires_at = now() + (timeout_ms || ' milliseconds')::interval,
-          owner_id = ${this.id}
-      FROM verify_concurrency vc
-      WHERE j.id = vc.id
-        AND vc.current_active < vc.concurrency_limit  -- Final concurrency check using job's concurrency limit
-      RETURNING
-        j.id,
-        j.action_name as "actionName",
-        j.group_key as "groupKey",
-        j.input,
-        j.output,
-        j.error,
-        j.status,
-        j.timeout_ms as "timeoutMs",
-        j.expires_at as "expiresAt",
-        j.started_at as "startedAt",
-        j.finished_at as "finishedAt",
-        j.created_at as "createdAt",
-        j.updated_at as "updatedAt",
-        j.concurrency_limit as "concurrencyLimit"
-    `));
-        return result;
-    }
-    async _recoverJobs(options) {
-        const { checksums, multiProcessMode = false, processTimeout = 5_000 } = options;
-        const unresponsiveOwnerIds = [this.id];
-        if (multiProcessMode) {
-            const result = (await this.db
-                .selectDistinct({
-                ownerId: this.tables.jobsTable.owner_id,
-            })
-                .from(this.tables.jobsTable)
-                .where(and(eq(this.tables.jobsTable.status, JOB_STATUS_ACTIVE), ne(this.tables.jobsTable.owner_id, this.id))));
-            if (result.length > 0) {
-                const pongCount = new Set();
-                const { unlisten } = await this._listen(`pong-${this.id}`, (payload) => {
-                    const toOwnerId = JSON.parse(payload).toOwnerId;
-                    pongCount.add(toOwnerId);
-                    if (pongCount.size >= result.length) {
-                        unlisten();
-                    }
-                });
-                await Promise.all(result.map((row) => this._notify(`ping-${row.ownerId}`, { fromOwnerId: this.id })));
-                let waitForSeconds = processTimeout / 1_000;
-                while (pongCount.size < result.length && waitForSeconds > 0) {
-                    await new Promise((resolve) => setTimeout(resolve, 1000).unref?.());
-                    waitForSeconds--;
-                }
-                unresponsiveOwnerIds.push(...result.filter((row) => !pongCount.has(row.ownerId)).map((row) => row.ownerId));
-            }
-        }
-        if (unresponsiveOwnerIds.length > 0) {
-            const result = this._map(await this.db.execute(sql `
-        WITH locked_jobs AS (
-          SELECT j.id
-          FROM ${this.tables.jobsTable} j
-          WHERE j.status = ${JOB_STATUS_ACTIVE}
-            AND j.owner_id IN ${unresponsiveOwnerIds}
-          FOR UPDATE OF j SKIP LOCKED
-        ),
-        updated_jobs AS (
-          UPDATE ${this.tables.jobsTable} j
-          SET status = ${JOB_STATUS_CREATED},
-              started_at = NULL,
-              expires_at = NULL,
-              finished_at = NULL,
-              output = NULL,
-              error = NULL
-          WHERE EXISTS (SELECT 1 FROM locked_jobs lj WHERE lj.id = j.id)
-          RETURNING id, checksum
-        ),
-        deleted_steps AS (
-          DELETE FROM ${this.tables.jobStepsTable} s
-          WHERE EXISTS (
-            SELECT 1 FROM updated_jobs uj
-            WHERE uj.id = s.job_id
-            AND uj.checksum NOT IN ${checksums}
-          )
-        )
-        SELECT id FROM updated_jobs
-      `));
-            return result.length;
-        }
-        return 0;
-    }
-    async _createOrRecoverJobStep({ jobId, name, timeoutMs, retriesLimit, }) {
-        const [result] = this._map(await this.db.execute(sql `
-      WITH job_check AS (
-        SELECT j.id
-        FROM ${this.tables.jobsTable} j
-        WHERE j.id = ${jobId}
-          AND j.status = ${JOB_STATUS_ACTIVE}
-          AND (j.expires_at IS NULL OR j.expires_at > now())
-      ),
-      step_existed AS (
-        SELECT EXISTS(
-          SELECT 1 FROM ${this.tables.jobStepsTable} s
-          WHERE s.job_id = ${jobId} AND s.name = ${name}
-        ) AS existed
-      ),
-      upserted_step AS (
-        INSERT INTO ${this.tables.jobStepsTable} (
-          job_id,
-          name,
-          timeout_ms,
-          retries_limit,
-          status,
-          started_at,
-          expires_at,
-          retries_count,
-          delayed_ms
-        )
-        SELECT
-          ${jobId},
-          ${name},
-          ${timeoutMs},
-          ${retriesLimit},
-          ${STEP_STATUS_ACTIVE},
-          now(),
-          now() + interval '${sql.raw(timeoutMs.toString())} milliseconds',
-          0,
-          NULL
-        WHERE EXISTS (SELECT 1 FROM job_check)
-        ON CONFLICT (job_id, name) DO UPDATE
-        SET
-          timeout_ms = ${timeoutMs},
-          expires_at = now() + interval '${sql.raw(timeoutMs.toString())} milliseconds',
-          retries_count = 0,
-          retries_limit = ${retriesLimit},
-          delayed_ms = NULL,
-          started_at = now(),
-          history_failed_attempts = '{}'::jsonb
-        WHERE ${this.tables.jobStepsTable}.status = ${STEP_STATUS_ACTIVE}
-        RETURNING
-          id,
-          status,
-          retries_limit AS "retriesLimit",
-          retries_count AS "retriesCount",
-          timeout_ms AS "timeoutMs",
-          error,
-          output
-      ),
-      final_upserted AS (
-        SELECT
-          us.*,
-          CASE WHEN se.existed THEN false ELSE true END AS "isNew"
-        FROM upserted_step us
-        CROSS JOIN step_existed se
-      ),
-      existing_step AS (
-        SELECT
-          s.id,
-          s.status,
-          s.retries_limit AS "retriesLimit",
-          s.retries_count AS "retriesCount",
-          s.timeout_ms AS "timeoutMs",
-          s.error,
-          s.output,
-          false AS "isNew"
-        FROM ${this.tables.jobStepsTable} s
-        INNER JOIN job_check jc ON s.job_id = jc.id
-        WHERE s.job_id = ${jobId}
-          AND s.name = ${name}
-          AND NOT EXISTS (SELECT 1 FROM final_upserted)
-      )
-      SELECT * FROM final_upserted
-      UNION ALL
-      SELECT * FROM existing_step
-    `));
-        if (!result) {
-            this.logger?.error({ jobId }, `[PostgresAdapter] Job ${jobId} is not active or has expired`);
-            return null;
-        }
-        return result;
-    }
-    async _completeJobStep({ stepId, output }) {
-        const result = await this.db
-            .update(this.tables.jobStepsTable)
-            .set({
-            status: STEP_STATUS_COMPLETED,
-            output,
-            finished_at: sql `now()`,
-        })
-            .from(this.tables.jobsTable)
-            .where(and(eq(this.tables.jobStepsTable.job_id, this.tables.jobsTable.id), eq(this.tables.jobStepsTable.id, stepId), eq(this.tables.jobStepsTable.status, STEP_STATUS_ACTIVE), eq(this.tables.jobsTable.status, JOB_STATUS_ACTIVE), or(isNull(this.tables.jobsTable.expires_at), gt(this.tables.jobsTable.expires_at, sql `now()`))))
-            .returning({ id: this.tables.jobStepsTable.id });
-        return result.length > 0;
-    }
-    async _failJobStep({ stepId, error }) {
-        const result = await this.db
-            .update(this.tables.jobStepsTable)
-            .set({
-            status: STEP_STATUS_FAILED,
-            error,
-            finished_at: sql `now()`,
-        })
-            .from(this.tables.jobsTable)
-            .where(and(eq(this.tables.jobStepsTable.job_id, this.tables.jobsTable.id), eq(this.tables.jobStepsTable.id, stepId), eq(this.tables.jobStepsTable.status, STEP_STATUS_ACTIVE), eq(this.tables.jobsTable.status, JOB_STATUS_ACTIVE)))
-            .returning({ id: this.tables.jobStepsTable.id });
-        return result.length > 0;
-    }
-    async _delayJobStep({ stepId, delayMs, error }) {
-        const jobStepsTable = this.tables.jobStepsTable;
-        const jobsTable = this.tables.jobsTable;
-        const result = await this.db
-            .update(jobStepsTable)
-            .set({
-            delayed_ms: delayMs,
-            retries_count: sql `${jobStepsTable.retries_count} + 1`,
-            expires_at: sql `now() + (${jobStepsTable.timeout_ms} || ' milliseconds')::interval + (${delayMs} || ' milliseconds')::interval`,
-            history_failed_attempts: sql `COALESCE(${jobStepsTable.history_failed_attempts}, '{}'::jsonb) || jsonb_build_object(
-          extract(epoch from now())::text,
-          jsonb_build_object(
-            'failedAt', now(),
-            'error', ${JSON.stringify(error)}::jsonb,
-            'delayedMs', ${delayMs}::integer
-          )
-        )`,
-        })
-            .from(jobsTable)
-            .where(and(eq(jobStepsTable.job_id, jobsTable.id), eq(jobStepsTable.id, stepId), eq(jobStepsTable.status, STEP_STATUS_ACTIVE), eq(jobsTable.status, JOB_STATUS_ACTIVE)))
-            .returning({ id: jobStepsTable.id });
-        return result.length > 0;
-    }
-    async _cancelJobStep({ stepId }) {
-        const result = await this.db
-            .update(this.tables.jobStepsTable)
-            .set({
-            status: STEP_STATUS_CANCELLED,
-            finished_at: sql `now()`,
-        })
-            .from(this.tables.jobsTable)
-            .where(and(eq(this.tables.jobStepsTable.job_id, this.tables.jobsTable.id), eq(this.tables.jobStepsTable.id, stepId), eq(this.tables.jobStepsTable.status, STEP_STATUS_ACTIVE), or(eq(this.tables.jobsTable.status, JOB_STATUS_ACTIVE), eq(this.tables.jobsTable.status, JOB_STATUS_CANCELLED))))
-            .returning({ id: this.tables.jobStepsTable.id });
-        return result.length > 0;
-    }
-    async _getJobById(jobId) {
-        const [job] = await this.db
-            .select({
-            id: this.tables.jobsTable.id,
-            actionName: this.tables.jobsTable.action_name,
-            groupKey: this.tables.jobsTable.group_key,
-            input: this.tables.jobsTable.input,
-            output: this.tables.jobsTable.output,
-            error: this.tables.jobsTable.error,
-            status: this.tables.jobsTable.status,
-            timeoutMs: this.tables.jobsTable.timeout_ms,
-            expiresAt: this.tables.jobsTable.expires_at,
-            startedAt: this.tables.jobsTable.started_at,
-            finishedAt: this.tables.jobsTable.finished_at,
-            createdAt: this.tables.jobsTable.created_at,
-            updatedAt: this.tables.jobsTable.updated_at,
-            concurrencyLimit: this.tables.jobsTable.concurrency_limit,
-        })
-            .from(this.tables.jobsTable)
-            .where(eq(this.tables.jobsTable.id, jobId))
-            .limit(1);
-        return job ?? null;
-    }
-    async _getJobSteps(options) {
-        const { jobId, page = 1, pageSize = 10, search } = options;
-        const jobStepsTable = this.tables.jobStepsTable;
-        const fuzzySearch = search?.trim();
-        const where = and(eq(jobStepsTable.job_id, jobId), fuzzySearch && fuzzySearch.length > 0
-            ? or(ilike(jobStepsTable.name, `%${fuzzySearch}%`), sql `to_tsvector('english', ${jobStepsTable.output}::text) @@ plainto_tsquery('english', ${fuzzySearch})`)
-            : undefined, options.updatedAfter
-            ? sql `date_trunc('milliseconds', ${jobStepsTable.updated_at}) > ${options.updatedAfter.toISOString()}::timestamptz`
-            : undefined);
-        const total = await this.db.$count(jobStepsTable, where);
-        if (!total) {
-            return {
-                steps: [],
-                total: 0,
-                page,
-                pageSize,
-            };
-        }
-        const steps = await this.db
-            .select({
-            id: jobStepsTable.id,
-            jobId: jobStepsTable.job_id,
-            name: jobStepsTable.name,
-            status: jobStepsTable.status,
-            error: jobStepsTable.error,
-            startedAt: jobStepsTable.started_at,
-            finishedAt: jobStepsTable.finished_at,
-            timeoutMs: jobStepsTable.timeout_ms,
-            expiresAt: jobStepsTable.expires_at,
-            retriesLimit: jobStepsTable.retries_limit,
-            retriesCount: jobStepsTable.retries_count,
-            delayedMs: jobStepsTable.delayed_ms,
-            historyFailedAttempts: jobStepsTable.history_failed_attempts,
-            createdAt: jobStepsTable.created_at,
-            updatedAt: jobStepsTable.updated_at,
-        })
-            .from(jobStepsTable)
-            .where(where)
-            .orderBy(asc(jobStepsTable.created_at))
-            .limit(pageSize)
-            .offset((page - 1) * pageSize);
-        return {
-            steps,
-            total,
-            page,
-            pageSize,
-        };
-    }
-    _buildJobsWhereClause(filters) {
-        if (!filters) {
-            return undefined;
-        }
-        const jobsTable = this.tables.jobsTable;
-        const fuzzySearch = filters.search?.trim();
-        return and(filters.status
-            ? inArray(jobsTable.status, Array.isArray(filters.status) ? filters.status : [filters.status])
-            : undefined, filters.actionName
-            ? inArray(jobsTable.action_name, Array.isArray(filters.actionName) ? filters.actionName : [filters.actionName])
-            : undefined, filters.groupKey && Array.isArray(filters.groupKey)
-            ? sql `j.group_key LIKE ANY(ARRAY[${sql.raw(filters.groupKey.map((key) => `'${key}'`).join(','))}]::text[])`
-            : undefined, filters.groupKey && !Array.isArray(filters.groupKey)
-            ? ilike(jobsTable.group_key, `%${filters.groupKey}%`)
-            : undefined, filters.ownerId
-            ? inArray(jobsTable.owner_id, Array.isArray(filters.ownerId) ? filters.ownerId : [filters.ownerId])
-            : undefined, filters.createdAt && Array.isArray(filters.createdAt)
-            ? between(sql `date_trunc('second', ${jobsTable.created_at})`, filters.createdAt[0].toISOString(), filters.createdAt[1].toISOString())
-            : undefined, filters.createdAt && !Array.isArray(filters.createdAt)
-            ? gte(sql `date_trunc('second', ${jobsTable.created_at})`, filters.createdAt.toISOString())
-            : undefined, filters.startedAt && Array.isArray(filters.startedAt)
-            ? between(sql `date_trunc('second', ${jobsTable.started_at})`, filters.startedAt[0].toISOString(), filters.startedAt[1].toISOString())
-            : undefined, filters.startedAt && !Array.isArray(filters.startedAt)
-            ? gte(sql `date_trunc('second', ${jobsTable.started_at})`, filters.startedAt.toISOString())
-            : undefined, filters.finishedAt && Array.isArray(filters.finishedAt)
-            ? between(sql `date_trunc('second', ${jobsTable.finished_at})`, filters.finishedAt[0].toISOString(), filters.finishedAt[1].toISOString())
-            : undefined, filters.finishedAt && !Array.isArray(filters.finishedAt)
-            ? gte(sql `date_trunc('second', ${jobsTable.finished_at})`, filters.finishedAt.toISOString())
-            : undefined, filters.updatedAfter
-            ? sql `date_trunc('milliseconds', ${jobsTable.updated_at}) > ${filters.updatedAfter.toISOString()}::timestamptz`
-            : undefined, fuzzySearch && fuzzySearch.length > 0
-            ? or(ilike(jobsTable.action_name, `%${fuzzySearch}%`), ilike(jobsTable.group_key, `%${fuzzySearch}%`), ilike(jobsTable.owner_id, `%${fuzzySearch}%`), sql `${jobsTable.id}::text ilike ${`%${fuzzySearch}%`}`, sql `to_tsvector('english', ${jobsTable.input}::text) @@ plainto_tsquery('english', ${fuzzySearch})`, sql `to_tsvector('english', ${jobsTable.output}::text) @@ plainto_tsquery('english', ${fuzzySearch})`)
-            : undefined, ...(filters.inputFilter && Object.keys(filters.inputFilter).length > 0
-            ? this.#buildJsonbWhereConditions(filters.inputFilter, jobsTable.input)
-            : []), ...(filters.outputFilter && Object.keys(filters.outputFilter).length > 0
-            ? this.#buildJsonbWhereConditions(filters.outputFilter, jobsTable.output)
-            : []));
-    }
-    async _getJobs(options) {
-        const jobsTable = this.tables.jobsTable;
-        const page = options?.page ?? 1;
-        const pageSize = options?.pageSize ?? 10;
-        const filters = options?.filters ?? {};
-        const sortInput = options?.sort ?? { field: 'startedAt', order: 'desc' };
-        const sorts = Array.isArray(sortInput) ? sortInput : [sortInput];
-        const where = this._buildJobsWhereClause(filters);
-        const total = await this.db.$count(jobsTable, where);
-        if (!total) {
-            return {
-                jobs: [],
-                total: 0,
-                page,
-                pageSize,
-            };
-        }
-        const sortFieldMap = {
-            createdAt: jobsTable.created_at,
-            startedAt: jobsTable.started_at,
-            finishedAt: jobsTable.finished_at,
-            status: jobsTable.status,
-            actionName: jobsTable.action_name,
-            expiresAt: jobsTable.expires_at,
-        };
-        const jobs = await this.db
-            .select({
-            id: jobsTable.id,
-            actionName: jobsTable.action_name,
-            groupKey: jobsTable.group_key,
-            input: jobsTable.input,
-            output: jobsTable.output,
-            error: jobsTable.error,
-            status: jobsTable.status,
-            timeoutMs: jobsTable.timeout_ms,
-            expiresAt: jobsTable.expires_at,
-            startedAt: jobsTable.started_at,
-            finishedAt: jobsTable.finished_at,
-            createdAt: jobsTable.created_at,
-            updatedAt: jobsTable.updated_at,
-            concurrencyLimit: jobsTable.concurrency_limit,
-        })
-            .from(jobsTable)
-            .where(where)
-            .orderBy(...sorts
-            .filter((sortItem) => sortItem.field in sortFieldMap)
-            .map((sortItem) => {
-            const sortField = sortFieldMap[sortItem.field];
-            if (sortItem.order.toUpperCase() === 'ASC') {
-                return asc(sortField);
-            }
-            else {
-                return desc(sortField);
-            }
-        }))
-            .limit(pageSize)
-            .offset((page - 1) * pageSize);
-        return {
-            jobs,
-            total,
-            page,
-            pageSize,
-        };
-    }
-    async _getJobStepById(stepId) {
-        const [step] = await this.db
-            .select({
-            id: this.tables.jobStepsTable.id,
-            jobId: this.tables.jobStepsTable.job_id,
-            name: this.tables.jobStepsTable.name,
-            output: this.tables.jobStepsTable.output,
-            status: this.tables.jobStepsTable.status,
-            error: this.tables.jobStepsTable.error,
-            startedAt: this.tables.jobStepsTable.started_at,
-            finishedAt: this.tables.jobStepsTable.finished_at,
-            timeoutMs: this.tables.jobStepsTable.timeout_ms,
-            expiresAt: this.tables.jobStepsTable.expires_at,
-            retriesLimit: this.tables.jobStepsTable.retries_limit,
-            retriesCount: this.tables.jobStepsTable.retries_count,
-            delayedMs: this.tables.jobStepsTable.delayed_ms,
-            historyFailedAttempts: this.tables.jobStepsTable.history_failed_attempts,
-            createdAt: this.tables.jobStepsTable.created_at,
-            updatedAt: this.tables.jobStepsTable.updated_at,
-        })
-            .from(this.tables.jobStepsTable)
-            .where(eq(this.tables.jobStepsTable.id, stepId))
-            .limit(1);
-        return step ?? null;
-    }
-    async _getJobStatus(jobId) {
-        const [job] = await this.db
-            .select({
-            status: this.tables.jobsTable.status,
-            updatedAt: this.tables.jobsTable.updated_at,
-        })
-            .from(this.tables.jobsTable)
-            .where(eq(this.tables.jobsTable.id, jobId))
-            .limit(1);
-        return job ?? null;
-    }
-    async _getJobStepStatus(stepId) {
-        const [step] = await this.db
-            .select({
-            status: this.tables.jobStepsTable.status,
-            updatedAt: this.tables.jobStepsTable.updated_at,
-        })
-            .from(this.tables.jobStepsTable)
-            .where(eq(this.tables.jobStepsTable.id, stepId))
-            .limit(1);
-        return step ?? null;
-    }
-    async _getActions() {
-        const actionStats = this.db.$with('action_stats').as(this.db
-            .select({
-            name: this.tables.jobsTable.action_name,
-            last_job_created: sql `MAX(${this.tables.jobsTable.created_at})`.as('last_job_created'),
-            active: sql `COUNT(*) FILTER (WHERE ${this.tables.jobsTable.status} = ${JOB_STATUS_ACTIVE})`.as('active'),
-            completed: sql `COUNT(*) FILTER (WHERE ${this.tables.jobsTable.status} = ${JOB_STATUS_COMPLETED})`.as('completed'),
-            failed: sql `COUNT(*) FILTER (WHERE ${this.tables.jobsTable.status} = ${JOB_STATUS_FAILED})`.as('failed'),
-            cancelled: sql `COUNT(*) FILTER (WHERE ${this.tables.jobsTable.status} = ${JOB_STATUS_CANCELLED})`.as('cancelled'),
-        })
-            .from(this.tables.jobsTable)
-            .groupBy(this.tables.jobsTable.action_name));
-        const actions = await this.db
-            .with(actionStats)
-            .select({
-            name: actionStats.name,
-            lastJobCreated: actionStats.last_job_created,
-            active: sql `${actionStats.active}::int`,
-            completed: sql `${actionStats.completed}::int`,
-            failed: sql `${actionStats.failed}::int`,
-            cancelled: sql `${actionStats.cancelled}::int`,
-        })
-            .from(actionStats)
-            .orderBy(actionStats.name);
-        return {
-            actions: actions.map((action) => ({
-                ...action,
-                lastJobCreated: action.lastJobCreated ?? null,
-            })),
-        };
-    }
-    #buildJsonbWhereConditions(filter, jsonbColumn) {
-        const conditions = [];
-        for (const [key, value] of Object.entries(filter)) {
-            const parts = key.split('.').filter((p) => p.length > 0);
-            if (parts.length === 0) {
-                continue;
-            }
-            let jsonbPath = sql `${jsonbColumn}`;
-            if (parts.length === 1) {
-                jsonbPath = sql `${jsonbPath} ->> ${parts[0]}`;
-            }
-            else {
-                for (let i = 0; i < parts.length - 1; i++) {
-                    const part = parts[i];
-                    if (part) {
-                        jsonbPath = sql `${jsonbPath} -> ${part}`;
-                    }
-                }
-                const lastPart = parts[parts.length - 1];
-                if (lastPart) {
-                    jsonbPath = sql `${jsonbPath} ->> ${lastPart}`;
-                }
-            }
-            if (Array.isArray(value)) {
-                const arrayValueConditions = value.map((arrayValue) => {
-                    const arrayValueStr = String(arrayValue);
-                    let arrayPath = sql `${jsonbColumn}`;
-                    for (let i = 0; i < parts.length - 1; i++) {
-                        const part = parts[i];
-                        if (part) {
-                            arrayPath = sql `${arrayPath} -> ${part}`;
-                        }
-                    }
-                    const lastPart = parts[parts.length - 1];
-                    if (lastPart) {
-                        arrayPath = sql `${arrayPath} -> ${lastPart}`;
-                    }
-                    if (typeof arrayValue === 'string') {
-                        return sql `EXISTS (
-              SELECT 1
-              FROM jsonb_array_elements_text(${arrayPath}) AS elem
-              WHERE LOWER(elem) ILIKE LOWER(${`%${arrayValueStr}%`})
-            )`;
-                    }
-                    else {
-                        return sql `${arrayPath} @> ${sql.raw(JSON.stringify([arrayValue]))}::jsonb`;
-                    }
-                });
-                if (arrayValueConditions.length > 0) {
-                    conditions.push(arrayValueConditions.reduce((acc, condition, idx) => (idx === 0 ? condition : sql `${acc} OR ${condition}`)));
-                }
-            }
-            else if (typeof value === 'string') {
-                conditions.push(sql `COALESCE(${jsonbPath}, '') ILIKE ${`%${value}%`}`);
-            }
-            else {
-                conditions.push(sql `${jsonbPath}::text = ${String(value)}`);
-            }
-        }
-        return conditions;
-    }
     async _notify(event, data) {
         this.logger?.debug({ event, data }, `[PostgresAdapter] Notify ${event}`);
-        await this.db.$client.notify(`${this.options.schema}.${event}`, JSON.stringify(data)).catch((err) => {
+        await this.db.$client.notify(`${this.schema}.${event}`, JSON.stringify(data)).catch((err) => {
             this.logger?.error({ err, data }, `[PostgresAdapter] Failed to notify ${event}`);
         });
     }
     async _listen(event, callback) {
-        return await this.db.$client.listen(`${this.options.schema}.${event}`, (payload) => {
+        return await this.db.$client.listen(`${this.schema}.${event}`, (payload) => {
             callback(payload);
         });
     }
-    _map(result) {
-        return result;
-    }
 }
 export const postgresAdapter = (options) => {
     return new PostgresAdapter(options);