duron 0.2.2 → 0.3.0-beta.1

package/dist/adapters/postgres/base.js

@@ -64,6 +64,7 @@ export class PostgresBaseAdapter extends Adapter {
             status: JOB_STATUS_COMPLETED,
             output,
             finished_at: sql `now()`,
+            updated_at: sql `now()`,
         })
             .where(and(eq(this.tables.jobsTable.id, jobId), eq(this.tables.jobsTable.status, JOB_STATUS_ACTIVE), eq(this.tables.jobsTable.client_id, this.id), gt(this.tables.jobsTable.expires_at, sql `now()`)))
             .returning({ id: this.tables.jobsTable.id });
@@ -76,6 +77,7 @@ export class PostgresBaseAdapter extends Adapter {
             status: JOB_STATUS_FAILED,
             error,
             finished_at: sql `now()`,
+            updated_at: sql `now()`,
         })
             .where(and(eq(this.tables.jobsTable.id, jobId), eq(this.tables.jobsTable.status, JOB_STATUS_ACTIVE), eq(this.tables.jobsTable.client_id, this.id)))
             .returning({ id: this.tables.jobsTable.id });
@@ -87,6 +89,7 @@ export class PostgresBaseAdapter extends Adapter {
             .set({
             status: JOB_STATUS_CANCELLED,
             finished_at: sql `now()`,
+            updated_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 });
@@ -166,6 +169,173 @@ export class PostgresBaseAdapter extends Adapter {
         }
         return result[0].id;
     }
+    async _timeTravelJob({ jobId, stepId }) {
+        const result = this._map(await this.db.execute(sql `
+      WITH RECURSIVE
+      -- Lock and validate the job
+      locked_job AS (
+        SELECT j.id
+        FROM ${this.tables.jobsTable} j
+        WHERE j.id = ${jobId}
+          AND j.status IN (${JOB_STATUS_COMPLETED}, ${JOB_STATUS_FAILED}, ${JOB_STATUS_CANCELLED})
+        FOR UPDATE OF j
+      ),
+      -- Validate target step exists and belongs to job
+      target_step AS (
+        SELECT s.id, s.parent_step_id, s.created_at
+        FROM ${this.tables.jobStepsTable} s
+        WHERE s.id = ${stepId}
+          AND s.job_id = ${jobId}
+          AND EXISTS (SELECT 1 FROM locked_job)
+      ),
+      -- Find all ancestor steps recursively (from target up to root)
+      ancestors AS (
+        SELECT s.id, s.parent_step_id, 0 AS depth
+        FROM ${this.tables.jobStepsTable} s
+        WHERE s.id = (SELECT parent_step_id FROM target_step)
+          AND EXISTS (SELECT 1 FROM target_step)
+        UNION ALL
+        SELECT s.id, s.parent_step_id, a.depth + 1
+        FROM ${this.tables.jobStepsTable} s
+        INNER JOIN ancestors a ON s.id = a.parent_step_id
+      ),
+      -- Steps to keep: completed steps created before target + completed parallel siblings of target and ancestors + their descendants
+      parallel_siblings AS (
+        -- Completed parallel siblings of target step
+        SELECT s.id
+        FROM ${this.tables.jobStepsTable} s
+        CROSS JOIN target_step ts
+        WHERE s.job_id = ${jobId}
+          AND s.id != ts.id
+          AND s.branch = true
+          AND s.status = ${STEP_STATUS_COMPLETED}
+          AND (
+            (s.parent_step_id IS NULL AND ts.parent_step_id IS NULL)
+            OR s.parent_step_id = ts.parent_step_id
+          )
+        UNION
+        -- Completed parallel siblings of each ancestor
+        SELECT s.id
+        FROM ${this.tables.jobStepsTable} s
+        INNER JOIN ancestors a ON (
+          (s.parent_step_id IS NULL AND a.parent_step_id IS NULL)
+          OR s.parent_step_id = a.parent_step_id
+        )
+        WHERE s.job_id = ${jobId}
+          AND s.id NOT IN (SELECT id FROM ancestors)
+          AND s.branch = true
+          AND s.status = ${STEP_STATUS_COMPLETED}
+      ),
+      -- Find all descendants of parallel siblings (to keep their children too)
+      parallel_descendants AS (
+        SELECT s.id
+        FROM ${this.tables.jobStepsTable} s
+        WHERE s.id IN (SELECT id FROM parallel_siblings)
+        UNION ALL
+        SELECT s.id
+        FROM ${this.tables.jobStepsTable} s
+        INNER JOIN parallel_descendants pd ON s.parent_step_id = pd.id
+        WHERE s.job_id = ${jobId}
+      ),
+      steps_to_keep AS (
+        -- Steps created before target that are completed (non-ancestor, non-target)
+        SELECT s.id
+        FROM ${this.tables.jobStepsTable} s
+        CROSS JOIN target_step ts
+        WHERE s.job_id = ${jobId}
+          AND s.created_at < ts.created_at
+          AND s.status = ${STEP_STATUS_COMPLETED}
+          AND s.id NOT IN (SELECT id FROM ancestors)
+          AND s.id != ts.id
+        UNION
+        -- All parallel siblings and their descendants
+        SELECT id FROM parallel_descendants
+      ),
+      -- Calculate time offset: shift preserved steps to start from "now"
+      time_offset AS (
+        SELECT
+          now() - MIN(s.started_at) AS offset_interval
+        FROM ${this.tables.jobStepsTable} s
+        WHERE s.id IN (SELECT id FROM steps_to_keep)
+      ),
+      -- Shift times of preserved steps to align with current time (only started_at/finished_at, NOT created_at to preserve ordering)
+      shift_preserved_times AS (
+        UPDATE ${this.tables.jobStepsTable}
+        SET
+          started_at = started_at + (SELECT offset_interval FROM time_offset),
+          finished_at = CASE
+            WHEN finished_at IS NOT NULL
+            THEN finished_at + (SELECT offset_interval FROM time_offset)
+            ELSE NULL
+          END,
+          updated_at = now()
+        WHERE id IN (SELECT id FROM steps_to_keep)
+          AND (SELECT offset_interval FROM time_offset) IS NOT NULL
+        RETURNING id
+      ),
+      -- Delete steps that are not in the keep list and are not ancestors/target
+      deleted_steps AS (
+        DELETE FROM ${this.tables.jobStepsTable}
+        WHERE job_id = ${jobId}
+          AND id NOT IN (SELECT id FROM steps_to_keep)
+          AND id NOT IN (SELECT id FROM ancestors)
+          AND id != (SELECT id FROM target_step)
+        RETURNING id
+      ),
+      -- Reset ancestor steps to active
+      reset_ancestors AS (
+        UPDATE ${this.tables.jobStepsTable}
+        SET
+          status = ${STEP_STATUS_ACTIVE},
+          output = NULL,
+          error = NULL,
+          finished_at = NULL,
+          started_at = now(),
+          expires_at = now() + (timeout_ms || ' milliseconds')::interval,
+          retries_count = 0,
+          delayed_ms = NULL,
+          history_failed_attempts = '{}'::jsonb,
+          updated_at = now()
+        WHERE id IN (SELECT id FROM ancestors)
+        RETURNING id
+      ),
+      -- Reset target step to active
+      reset_target AS (
+        UPDATE ${this.tables.jobStepsTable}
+        SET
+          status = ${STEP_STATUS_ACTIVE},
+          output = NULL,
+          error = NULL,
+          finished_at = NULL,
+          started_at = now(),
+          expires_at = now() + (timeout_ms || ' milliseconds')::interval,
+          retries_count = 0,
+          delayed_ms = NULL,
+          history_failed_attempts = '{}'::jsonb,
+          updated_at = now()
+        WHERE id = (SELECT id FROM target_step)
+        RETURNING id
+      ),
+      -- Reset job to created status
+      reset_job AS (
+        UPDATE ${this.tables.jobsTable}
+        SET
+          status = ${JOB_STATUS_CREATED},
+          output = NULL,
+          error = NULL,
+          started_at = NULL,
+          finished_at = NULL,
+          client_id = NULL,
+          expires_at = NULL,
+          updated_at = now()
+        WHERE id = ${jobId}
+          AND EXISTS (SELECT 1 FROM target_step)
+        RETURNING id
+      )
+      SELECT EXISTS(SELECT 1 FROM reset_job) AS success
+    `));
+        return result.length > 0 && result[0].success === true;
+    }
     async _deleteJob({ jobId }) {
         const result = await this.db
             .delete(this.tables.jobsTable)
@@ -271,7 +441,8 @@ export class PostgresBaseAdapter extends Adapter {
       SET status = ${JOB_STATUS_ACTIVE},
           started_at = now(),
           expires_at = now() + (timeout_ms || ' milliseconds')::interval,
-          client_id = ${this.id}
+          client_id = ${this.id},
+          updated_at = now()
       FROM verify_concurrency vc
       WHERE j.id = vc.id
         AND vc.current_active < vc.concurrency_limit  -- Final concurrency check using job's concurrency limit
@@ -337,7 +508,8 @@ export class PostgresBaseAdapter extends Adapter {
               expires_at = NULL,
               finished_at = NULL,
               output = NULL,
-              error = NULL
+              error = NULL,
+              updated_at = now()
           WHERE EXISTS (SELECT 1 FROM locked_jobs lj WHERE lj.id = j.id)
           RETURNING id, checksum
         ),
@@ -355,7 +527,7 @@ export class PostgresBaseAdapter extends Adapter {
         }
         return 0;
     }
-    async _createOrRecoverJobStep({ jobId, name, timeoutMs, retriesLimit, }) {
+    async _createOrRecoverJobStep({ jobId, name, timeoutMs, retriesLimit, parentStepId, parallel = false, }) {
         const [result] = this._map(await this.db.execute(sql `
       WITH job_check AS (
         SELECT j.id
@@ -373,6 +545,8 @@ export class PostgresBaseAdapter extends Adapter {
       upserted_step AS (
         INSERT INTO ${this.tables.jobStepsTable} (
           job_id,
+          parent_step_id,
+          branch,
           name,
           timeout_ms,
           retries_limit,
@@ -384,6 +558,8 @@ export class PostgresBaseAdapter extends Adapter {
         )
         SELECT
           ${jobId},
+          ${parentStepId},
+          ${parallel},
           ${name},
           ${timeoutMs},
           ${retriesLimit},
@@ -452,6 +628,7 @@ export class PostgresBaseAdapter extends Adapter {
             status: STEP_STATUS_COMPLETED,
             output,
             finished_at: sql `now()`,
+            updated_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()`))))
@@ -465,6 +642,7 @@ export class PostgresBaseAdapter extends Adapter {
             status: STEP_STATUS_FAILED,
             error,
             finished_at: sql `now()`,
+            updated_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)))
@@ -488,6 +666,7 @@ export class PostgresBaseAdapter extends Adapter {
             'delayedMs', ${delayMs}::integer
           )
         )`,
+            updated_at: sql `now()`,
         })
             .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)))
@@ -500,6 +679,7 @@ export class PostgresBaseAdapter extends Adapter {
             .set({
             status: STEP_STATUS_CANCELLED,
             finished_at: sql `now()`,
+            updated_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))))
@@ -531,7 +711,7 @@ export class PostgresBaseAdapter extends Adapter {
         return job ?? null;
     }
     async _getJobSteps(options) {
-        const { jobId, page = 1, pageSize = 10, search } = options;
+        const { jobId, search } = options;
         const jobStepsTable = this.tables.jobStepsTable;
         const fuzzySearch = search?.trim();
         const where = and(eq(jobStepsTable.job_id, jobId), fuzzySearch && fuzzySearch.length > 0
@@ -539,19 +719,12 @@ export class PostgresBaseAdapter extends Adapter {
             : 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,
+            parentStepId: jobStepsTable.parent_step_id,
+            parallel: jobStepsTable.parallel,
             name: jobStepsTable.name,
             status: jobStepsTable.status,
             error: jobStepsTable.error,
@@ -568,14 +741,10 @@ export class PostgresBaseAdapter extends Adapter {
         })
             .from(jobStepsTable)
             .where(where)
-            .orderBy(asc(jobStepsTable.created_at))
-            .limit(pageSize)
-            .offset((page - 1) * pageSize);
+            .orderBy(asc(jobStepsTable.created_at));
         return {
             steps,
-            total,
-            page,
-            pageSize,
+            total: steps.length,
         };
     }
     _buildJobsWhereClause(filters) {
@@ -686,6 +855,8 @@ export class PostgresBaseAdapter extends Adapter {
             .select({
             id: this.tables.jobStepsTable.id,
             jobId: this.tables.jobStepsTable.job_id,
+            parentStepId: this.tables.jobStepsTable.parent_step_id,
+            parallel: this.tables.jobStepsTable.parallel,
             name: this.tables.jobStepsTable.name,
             output: this.tables.jobStepsTable.output,
             status: this.tables.jobStepsTable.status,
@@ -759,6 +930,85 @@ export class PostgresBaseAdapter extends Adapter {
             })),
         };
     }
+    async _insertMetrics(metrics) {
+        if (metrics.length === 0) {
+            return 0;
+        }
+        const values = metrics.map((m) => ({
+            job_id: m.jobId,
+            step_id: m.stepId ?? null,
+            name: m.name,
+            value: m.value,
+            attributes: m.attributes ?? {},
+            type: m.type,
+        }));
+        const result = await this.db
+            .insert(this.tables.metricsTable)
+            .values(values)
+            .returning({ id: this.tables.metricsTable.id });
+        return result.length;
+    }
+    async _getMetrics(options) {
+        const metricsTable = this.tables.metricsTable;
+        const filters = options.filters ?? {};
+        const where = this._buildMetricsWhereClause(options.jobId, options.stepId, filters);
+        const sortInput = options.sort ?? { field: 'timestamp', order: 'desc' };
+        const sortFieldMap = {
+            name: metricsTable.name,
+            value: metricsTable.value,
+            timestamp: metricsTable.timestamp,
+            createdAt: metricsTable.created_at,
+        };
+        const total = await this.db.$count(metricsTable, where);
+        if (!total) {
+            return {
+                metrics: [],
+                total: 0,
+            };
+        }
+        const sortField = sortFieldMap[sortInput.field];
+        const orderByClause = sortInput.order === 'asc' ? asc(sortField) : desc(sortField);
+        const metrics = await this.db
+            .select({
+            id: metricsTable.id,
+            jobId: metricsTable.job_id,
+            stepId: metricsTable.step_id,
+            name: metricsTable.name,
+            value: metricsTable.value,
+            attributes: metricsTable.attributes,
+            type: metricsTable.type,
+            timestamp: metricsTable.timestamp,
+            createdAt: metricsTable.created_at,
+        })
+            .from(metricsTable)
+            .where(where)
+            .orderBy(orderByClause);
+        return {
+            metrics,
+            total,
+        };
+    }
+    async _deleteMetrics(options) {
+        const result = await this.db
+            .delete(this.tables.metricsTable)
+            .where(eq(this.tables.metricsTable.job_id, options.jobId))
+            .returning({ id: this.tables.metricsTable.id });
+        return result.length;
+    }
+    _buildMetricsWhereClause(jobId, stepId, filters) {
+        const metricsTable = this.tables.metricsTable;
+        return and(jobId ? eq(metricsTable.job_id, jobId) : undefined, stepId ? eq(metricsTable.step_id, stepId) : undefined, filters?.name
+            ? Array.isArray(filters.name)
+                ? or(...filters.name.map((n) => ilike(metricsTable.name, `%${n}%`)))
+                : ilike(metricsTable.name, `%${filters.name}%`)
+            : undefined, filters?.type
+            ? inArray(metricsTable.type, Array.isArray(filters.type) ? filters.type : [filters.type])
+            : undefined, filters?.timestampRange && filters.timestampRange.length === 2
+            ? between(metricsTable.timestamp, filters.timestampRange[0], filters.timestampRange[1])
+            : undefined, ...(filters?.attributesFilter && Object.keys(filters.attributesFilter).length > 0
+            ? this.#buildJsonbWhereConditions(filters.attributesFilter, metricsTable.attributes)
+            : []));
+    }
     #buildJsonbWhereConditions(filter, jsonbColumn) {
         const conditions = [];
         for (const [key, value] of Object.entries(filter)) {