duron 0.2.2 → 0.3.0-beta.0

package/src/adapters/postgres/base.ts

@@ -1,5 +1,5 @@
 import { and, asc, between, desc, eq, gt, gte, ilike, inArray, isNull, ne, or, sql } from 'drizzle-orm'
-import type { PgColumn, PgDatabase } from 'drizzle-orm/pg-core'
+import type { PgAsyncDatabase, PgColumn } from 'drizzle-orm/pg-core'
 
 import {
   JOB_STATUS_ACTIVE,
@@ -24,6 +24,7 @@ import {
   type DelayJobStepOptions,
   type DeleteJobOptions,
   type DeleteJobsOptions,
+  type DeleteMetricsOptions,
   type FailJobOptions,
   type FailJobStepOptions,
   type FetchOptions,
@@ -32,13 +33,18 @@ import {
   type GetJobStepsResult,
   type GetJobsOptions,
   type GetJobsResult,
+  type GetMetricsOptions,
+  type GetMetricsResult,
+  type InsertMetricOptions,
   type Job,
   type JobSort,
   type JobStatusResult,
   type JobStep,
   type JobStepStatusResult,
+  type MetricSort,
   type RecoverJobsOptions,
   type RetryJobOptions,
+  type TimeTravelJobOptions,
 } from '../adapter.js'
 import createSchema from './schema.js'
 
@@ -47,7 +53,7 @@ type Schema = ReturnType<typeof createSchema>
 // Re-export types for backward compatibility
 export type { Job, JobStep } from '../adapter.js'
 
-type DrizzleDatabase = PgDatabase<any, Schema>
+type DrizzleDatabase = PgAsyncDatabase<any, Schema>
 
 export interface AdapterOptions<Connection> {
   connection: Connection
@@ -168,6 +174,7 @@ export class PostgresBaseAdapter<Database extends DrizzleDatabase, Connection> e
         status: JOB_STATUS_COMPLETED,
         output,
         finished_at: sql`now()`,
+        updated_at: sql`now()`,
       })
       .where(
         and(
@@ -194,6 +201,7 @@ export class PostgresBaseAdapter<Database extends DrizzleDatabase, Connection> e
         status: JOB_STATUS_FAILED,
         error,
         finished_at: sql`now()`,
+        updated_at: sql`now()`,
       })
       .where(
         and(
@@ -218,6 +226,7 @@ export class PostgresBaseAdapter<Database extends DrizzleDatabase, Connection> e
       .set({
         status: JOB_STATUS_CANCELLED,
         finished_at: sql`now()`,
+        updated_at: sql`now()`,
       })
       .where(
         and(
@@ -316,6 +325,196 @@ export class PostgresBaseAdapter<Database extends DrizzleDatabase, Connection> e
     return result[0]!.id
   }
 
+  /**
+   * Internal method to time travel a job to restart from a specific step.
+   * The job must be in completed, failed, or cancelled status.
+   * Resets the job and ancestor steps to active status, deletes subsequent steps,
+   * and preserves completed parallel siblings.
+   *
+   * Algorithm:
+   * 1. Validate job is in terminal state (completed/failed/cancelled)
+   * 2. Find the target step and all its ancestors (using parent_step_id)
+   * 3. Determine which steps to keep:
+   *    - Steps completed BEFORE the target step (by created_at)
+   *    - Branch siblings that are completed (independent)
+   * 4. Delete steps that should not be kept
+   * 5. Reset ancestor steps to active status (they need to re-run)
+   * 6. Reset the target step to active status
+   * 7. Reset job to created status
+   *
+   * @returns Promise resolving to `true` if time travel succeeded, `false` otherwise
+   */
+  protected async _timeTravelJob({ jobId, stepId }: TimeTravelJobOptions): Promise<boolean> {
+    const result = this._map(
+      await this.db.execute<{ success: boolean }>(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
+  }
+
   /**
    * Internal method to delete a job by its ID.
    * Active jobs cannot be deleted.
@@ -449,7 +648,8 @@ export class PostgresBaseAdapter<Database extends DrizzleDatabase, Connection> e
       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
@@ -534,7 +734,8 @@ export class PostgresBaseAdapter<Database extends DrizzleDatabase, Connection> e
               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
         ),
@@ -570,6 +771,8 @@ export class PostgresBaseAdapter<Database extends DrizzleDatabase, Connection> e
     name,
     timeoutMs,
     retriesLimit,
+    parentStepId,
+    parallel = false,
   }: CreateOrRecoverJobStepOptions): Promise<CreateOrRecoverJobStepResult | null> {
     type StepResult = CreateOrRecoverJobStepResult
 
@@ -591,6 +794,8 @@ export class PostgresBaseAdapter<Database extends DrizzleDatabase, Connection> e
       upserted_step AS (
         INSERT INTO ${this.tables.jobStepsTable} (
           job_id,
+          parent_step_id,
+          branch,
           name,
           timeout_ms,
           retries_limit,
@@ -602,6 +807,8 @@ export class PostgresBaseAdapter<Database extends DrizzleDatabase, Connection> e
         )
         SELECT
           ${jobId},
+          ${parentStepId},
+          ${parallel},
           ${name},
           ${timeoutMs},
           ${retriesLimit},
@@ -679,6 +886,7 @@ export class PostgresBaseAdapter<Database extends DrizzleDatabase, Connection> e
         status: STEP_STATUS_COMPLETED,
         output,
         finished_at: sql`now()`,
+        updated_at: sql`now()`,
       })
       .from(this.tables.jobsTable)
       .where(
@@ -707,6 +915,7 @@ export class PostgresBaseAdapter<Database extends DrizzleDatabase, Connection> e
         status: STEP_STATUS_FAILED,
         error,
         finished_at: sql`now()`,
+        updated_at: sql`now()`,
       })
       .from(this.tables.jobsTable)
       .where(
@@ -745,6 +954,7 @@ export class PostgresBaseAdapter<Database extends DrizzleDatabase, Connection> e
             'delayedMs', ${delayMs}::integer
           )
         )`,
+        updated_at: sql`now()`,
       })
       .from(jobsTable)
       .where(
@@ -771,6 +981,7 @@ export class PostgresBaseAdapter<Database extends DrizzleDatabase, Connection> e
       .set({
         status: STEP_STATUS_CANCELLED,
         finished_at: sql`now()`,
+        updated_at: sql`now()`,
       })
       .from(this.tables.jobsTable)
       .where(
@@ -823,12 +1034,12 @@ export class PostgresBaseAdapter<Database extends DrizzleDatabase, Connection> e
   }
 
   /**
-   * Internal method to get steps for a job with pagination and fuzzy search.
+   * Internal method to get all steps for a job with optional fuzzy search.
    * Steps are always ordered by created_at ASC.
    * Steps do not include output data.
    */
   protected async _getJobSteps(options: GetJobStepsOptions): Promise<GetJobStepsResult> {
-    const { jobId, page = 1, pageSize = 10, search } = options
+    const { jobId, search } = options
 
     const jobStepsTable = this.tables.jobStepsTable
 
@@ -847,22 +1058,12 @@ export class PostgresBaseAdapter<Database extends DrizzleDatabase, Connection> e
         : undefined,
     )
 
-    // Get total count
-    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,
@@ -880,14 +1081,10 @@ export class PostgresBaseAdapter<Database extends DrizzleDatabase, Connection> e
       .from(jobStepsTable)
       .where(where)
       .orderBy(asc(jobStepsTable.created_at))
-      .limit(pageSize)
-      .offset((page - 1) * pageSize)
 
     return {
       steps,
-      total,
-      page,
-      pageSize,
+      total: steps.length,
     }
   }
 
@@ -1054,6 +1251,8 @@ export class PostgresBaseAdapter<Database extends DrizzleDatabase, Connection> e
       .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,
@@ -1155,6 +1354,126 @@ export class PostgresBaseAdapter<Database extends DrizzleDatabase, Connection> e
     }
   }
 
+  // ============================================================================
+  // Metrics Methods
+  // ============================================================================
+
+  /**
+   * Internal method to insert multiple metric records in a single batch.
+   */
+  protected async _insertMetrics(metrics: InsertMetricOptions[]): Promise<number> {
+    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
+  }
+
+  /**
+   * Internal method to get metrics for a job or step.
+   */
+  protected async _getMetrics(options: GetMetricsOptions): Promise<GetMetricsResult> {
+    const metricsTable = this.tables.metricsTable
+    const filters = options.filters ?? {}
+
+    // Build WHERE clause
+    const where = this._buildMetricsWhereClause(options.jobId, options.stepId, filters)
+
+    // Build sort
+    const sortInput = options.sort ?? { field: 'timestamp', order: 'desc' }
+    const sortFieldMap: Record<MetricSort['field'], any> = {
+      name: metricsTable.name,
+      value: metricsTable.value,
+      timestamp: metricsTable.timestamp,
+      createdAt: metricsTable.created_at,
+    }
+
+    // Get total count
+    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,
+    }
+  }
+
+  /**
+   * Internal method to delete all metrics for a job.
+   */
+  protected async _deleteMetrics(options: DeleteMetricsOptions): Promise<number> {
+    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
+  }
+
+  /**
+   * Build WHERE clause for metrics queries.
+   */
+  protected _buildMetricsWhereClause(jobId?: string, stepId?: string, filters?: GetMetricsOptions['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)
+        : []),
+    )
+  }
+
   // ============================================================================
   // Private Methods
   // ============================================================================

package/src/adapters/postgres/schema.default.ts

@@ -1,5 +1,5 @@
 import createSchema from './schema.js'
 
-const { schema, jobsTable, jobStepsTable } = createSchema('duron')
+const { schema, jobsTable, jobStepsTable, metricsTable } = createSchema('duron')
 
-export { schema, jobsTable, jobStepsTable }
+export { schema, jobsTable, jobStepsTable, metricsTable }

package/src/adapters/postgres/schema.ts

@@ -1,5 +1,17 @@
 import { sql } from 'drizzle-orm'
-import { check, index, integer, jsonb, pgSchema, text, timestamp, unique, uuid } from 'drizzle-orm/pg-core'
+import {
+  boolean,
+  check,
+  doublePrecision,
+  index,
+  integer,
+  jsonb,
+  pgSchema,
+  text,
+  timestamp,
+  unique,
+  uuid,
+} from 'drizzle-orm/pg-core'
 
 import { JOB_STATUSES, type JobStatus, STEP_STATUS_ACTIVE, STEP_STATUSES, type StepStatus } from '../../constants.js'
 import type { SerializableError } from '../../errors.js'
@@ -66,6 +78,8 @@ export default function createSchema(schemaName: string) {
       job_id: uuid('job_id')
         .notNull()
         .references(() => jobsTable.id, { onDelete: 'cascade' }),
+      parent_step_id: uuid('parent_step_id'),
+      parallel: boolean('branch').notNull().default(false), // DB column is 'branch', TypeScript uses 'parallel'
       name: text('name').notNull(),
       status: text('status').$type<StepStatus>().notNull().default(STEP_STATUS_ACTIVE),
       output: jsonb('output'),
@@ -98,6 +112,7 @@ export default function createSchema(schemaName: string) {
       index('idx_job_steps_status').on(table.status),
       index('idx_job_steps_name').on(table.name),
       index('idx_job_steps_expires_at').on(table.expires_at),
+      index('idx_job_steps_parent_step_id').on(table.parent_step_id),
       // Composite indexes
       index('idx_job_steps_job_status').on(table.job_id, table.status),
       index('idx_job_steps_job_name').on(table.job_id, table.name),
@@ -111,9 +126,42 @@ export default function createSchema(schemaName: string) {
     ],
   )
 
+  const metricsTable = schema.table(
+    'metrics',
+    {
+      id: uuid('id').primaryKey().defaultRandom(),
+      job_id: uuid('job_id')
+        .notNull()
+        .references(() => jobsTable.id, { onDelete: 'cascade' }),
+      step_id: uuid('step_id').references(() => jobStepsTable.id, { onDelete: 'cascade' }),
+      name: text('name').notNull(),
+      value: doublePrecision('value').notNull(),
+      attributes: jsonb('attributes').$type<Record<string, any>>().notNull().default({}),
+      type: text('type').$type<'metric' | 'span_event' | 'span_attribute'>().notNull(),
+      timestamp: timestamp('timestamp', { withTimezone: true }).notNull().defaultNow(),
+      created_at: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+    },
+    (table) => [
+      // Single column indexes
+      index('idx_metrics_job_id').on(table.job_id),
+      index('idx_metrics_step_id').on(table.step_id),
+      index('idx_metrics_name').on(table.name),
+      index('idx_metrics_type').on(table.type),
+      index('idx_metrics_timestamp').on(table.timestamp),
+      // Composite indexes
+      index('idx_metrics_job_step').on(table.job_id, table.step_id),
+      index('idx_metrics_job_name').on(table.job_id, table.name),
+      index('idx_metrics_job_type').on(table.job_id, table.type),
+      // GIN index for JSONB attributes filtering
+      index('idx_metrics_attributes').using('gin', table.attributes),
+      check('metrics_type_check', sql`${table.type} IN ('metric', 'span_event', 'span_attribute')`),
+    ],
+  )
+
   return {
     schema,
     jobsTable,
     jobStepsTable,
+    metricsTable,
   }
 }