duron 0.1.0

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

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

package/src/adapters/postgres/schema.ts

@@ -0,0 +1,119 @@
+import { sql } from 'drizzle-orm'
+import { check, 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'
+
+export default function createSchema(schemaName: string) {
+  const schema = pgSchema(schemaName)
+
+  const jobsTable = schema.table(
+    'jobs',
+    {
+      id: uuid('id').primaryKey().defaultRandom(),
+      action_name: text('action_name').notNull(),
+      group_key: text('group_key').notNull(),
+      status: text('status').$type<JobStatus>().notNull().default('created'),
+      checksum: text('checksum').notNull(),
+      input: jsonb('input').notNull().default({}),
+      output: jsonb('output'),
+      error: jsonb('error').$type<SerializableError>(),
+      timeout_ms: integer('timeout_ms').notNull(),
+      expires_at: timestamp('expires_at', { withTimezone: true }),
+      started_at: timestamp('started_at', { withTimezone: true }),
+      finished_at: timestamp('finished_at', { withTimezone: true }),
+      owner_id: text('owner_id'),
+      concurrency_limit: integer('concurrency_limit').notNull().default(10),
+      created_at: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+      updated_at: timestamp('updated_at', { withTimezone: true })
+        .notNull()
+        .defaultNow()
+        .$onUpdateFn(
+          () =>
+            ({
+              toISOString: () => sql`now()` as any,
+            }) as any,
+        ),
+    },
+    (table) => [
+      // Single column indexes
+      index('idx_jobs_action_name').on(table.action_name),
+      index('idx_jobs_status').on(table.status),
+      index('idx_jobs_group_key').on(table.group_key),
+      index('idx_jobs_started_at').on(table.started_at),
+      index('idx_jobs_finished_at').on(table.finished_at),
+      index('idx_jobs_expires_at').on(table.expires_at),
+      index('idx_jobs_owner_id').on(table.owner_id),
+      index('idx_jobs_checksum').on(table.checksum),
+      index('idx_jobs_concurrency_limit').on(table.concurrency_limit),
+      // Composite indexes
+      index('idx_jobs_action_status').on(table.action_name, table.status),
+      index('idx_jobs_action_group').on(table.action_name, table.group_key),
+      // GIN indexes for full-text search
+      index('idx_jobs_input_fts').using('gin', sql`to_tsvector('english', ${table.input}::text)`),
+      index('idx_jobs_output_fts').using('gin', sql`to_tsvector('english', ${table.output}::text)`),
+      check(
+        'jobs_status_check',
+        sql`${table.status} IN ${sql.raw(`(${JOB_STATUSES.map((s) => `'${s}'`).join(',')})`)}`,
+      ),
+    ],
+  )
+
+  const jobStepsTable = schema.table(
+    'job_steps',
+    {
+      id: uuid('id').primaryKey().defaultRandom(),
+      job_id: uuid('job_id')
+        .notNull()
+        .references(() => jobsTable.id, { onDelete: 'cascade' }),
+      name: text('name').notNull(),
+      status: text('status').$type<StepStatus>().notNull().default(STEP_STATUS_ACTIVE),
+      output: jsonb('output'),
+      error: jsonb('error').$type<SerializableError>(),
+      started_at: timestamp('started_at', { withTimezone: true }).notNull().defaultNow(),
+      finished_at: timestamp('finished_at', { withTimezone: true }),
+      timeout_ms: integer('timeout_ms').notNull(),
+      expires_at: timestamp('expires_at', { withTimezone: true }),
+      retries_limit: integer('retries_limit').notNull().default(0),
+      retries_count: integer('retries_count').notNull().default(0),
+      delayed_ms: integer('delayed_ms'),
+      history_failed_attempts: jsonb('history_failed_attempts')
+        .$type<Record<string, { failedAt: Date; error: SerializableError; delayedMs: number }>>()
+        .notNull()
+        .default({}),
+      created_at: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+      updated_at: timestamp('updated_at', { withTimezone: true })
+        .notNull()
+        .defaultNow()
+        .$onUpdateFn(
+          () =>
+            ({
+              toISOString: () => sql`now()` as any,
+            }) as any,
+        ),
+    },
+    (table) => [
+      // Single column indexes
+      index('idx_job_steps_job_id').on(table.job_id),
+      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),
+      // 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),
+      index('idx_job_steps_output_fts').using('gin', sql`to_tsvector('english', ${table.output}::text)`),
+      // Unique constraint
+      unique('unique_job_step_name').on(table.job_id, table.name),
+      check(
+        'job_steps_status_check',
+        sql`${table.status} IN ${sql.raw(`(${STEP_STATUSES.map((s) => `'${s}'`).join(',')})`)}`,
+      ),
+    ],
+  )
+
+  return {
+    schema,
+    jobsTable,
+    jobStepsTable,
+  }
+}

package/src/adapters/schemas.ts

@@ -0,0 +1,320 @@
+import { z } from 'zod'
+
+import { JOB_STATUSES, STEP_STATUSES } from '../constants.js'
+
+// ============================================================================
+// Status Enums
+// ============================================================================
+
+export const JobStatusSchema = z.enum(JOB_STATUSES)
+export const StepStatusSchema = z.enum(STEP_STATUSES)
+
+// ============================================================================
+// Date Schema
+// ============================================================================
+
+const DateSchema = z.union([
+  z.date(),
+  z.string().transform((str) => new Date(str)),
+  z.number().transform((num) => new Date(num)),
+])
+
+export const SerializableErrorSchema = z.object({
+  name: z.string(),
+  message: z.string(),
+  cause: z.any().optional(),
+  stack: z.string().optional(),
+})
+
+// ============================================================================
+// Job Schema
+// ============================================================================
+
+export const JobSchema = z.object({
+  id: z.string(),
+  actionName: z.string(),
+  groupKey: z.string(),
+  input: z.any(),
+  output: z.any().nullable(),
+  error: z.any().nullable(),
+  status: JobStatusSchema,
+  timeoutMs: z.coerce.number(),
+  expiresAt: DateSchema.nullable(),
+  startedAt: DateSchema.nullable().default(null),
+  finishedAt: DateSchema.nullable().default(null),
+  createdAt: DateSchema,
+  updatedAt: DateSchema,
+  concurrencyLimit: z.coerce.number(),
+})
+
+// ============================================================================
+// JobStep Schema
+// ============================================================================
+
+export const JobStepSchema = z.object({
+  id: z.string(),
+  jobId: z.string(),
+  name: z.string(),
+  output: z.any().nullable().default(null),
+  status: StepStatusSchema,
+  error: z.any().nullable().default(null),
+  startedAt: DateSchema,
+  finishedAt: DateSchema.nullable().default(null),
+  timeoutMs: z.coerce.number(),
+  expiresAt: DateSchema.nullable().default(null),
+  retriesLimit: z.coerce.number(),
+  retriesCount: z.coerce.number(),
+  delayedMs: z.coerce.number().nullable().default(null),
+  historyFailedAttempts: z.record(
+    z.string(),
+    z.object({ failedAt: DateSchema, error: SerializableErrorSchema, delayedMs: z.coerce.number() }),
+  ),
+  createdAt: DateSchema,
+  updatedAt: DateSchema,
+})
+
+// JobStep without output (for getJobSteps)
+export const JobStepWithoutOutputSchema = JobStepSchema.omit({ output: true })
+
+// ============================================================================
+// Query Option Schemas
+// ============================================================================
+
+export const SortOrderSchema = z.enum(['asc', 'desc'])
+
+export const JobSortFieldSchema = z.enum(['createdAt', 'startedAt', 'finishedAt', 'status', 'actionName', 'expiresAt'])
+
+export const JobSortSchema = z.object({
+  field: JobSortFieldSchema,
+  order: SortOrderSchema,
+})
+
+export const JobFiltersSchema = z.object({
+  status: z.union([JobStatusSchema, z.array(JobStatusSchema)]).optional(),
+  actionName: z.union([z.string(), z.array(z.string())]).optional(),
+  groupKey: z.union([z.string(), z.array(z.string())]).optional(),
+  ownerId: z.union([z.string(), z.array(z.string())]).optional(),
+  createdAt: z.union([DateSchema, z.array(DateSchema).length(2)]).optional(),
+  startedAt: z.union([DateSchema, z.array(DateSchema).length(2)]).optional(),
+  finishedAt: z.union([DateSchema, z.array(DateSchema).length(2)]).optional(),
+  updatedAfter: DateSchema.optional(),
+  inputFilter: z.record(z.string(), z.any()).optional(),
+  outputFilter: z.record(z.string(), z.any()).optional(),
+  search: z.string().optional(),
+})
+
+export const GetJobsOptionsSchema = z.object({
+  page: z.number().int().positive().optional(),
+  pageSize: z.number().int().positive().optional(),
+  filters: JobFiltersSchema.optional(),
+  sort: z.union([JobSortSchema, z.array(JobSortSchema)]).optional(),
+})
+
+export const GetJobStepsOptionsSchema = z.object({
+  jobId: z.string(),
+  page: z.number().int().positive().optional(),
+  pageSize: z.number().int().positive().optional(),
+  search: z.string().optional(),
+  updatedAfter: DateSchema.optional(),
+})
+
+// ============================================================================
+// Job Option Schemas
+// ============================================================================
+
+export const CreateJobOptionsSchema = z.object({
+  /** The queue name (action name) */
+  queue: z.string(),
+  /** The group key for concurrency control */
+  groupKey: z.string(),
+  /** The checksum of the action */
+  checksum: z.string(),
+  /** The job input data */
+  input: z.any(),
+  /** Timeout in milliseconds for the job */
+  timeoutMs: z.number(),
+  /** The concurrency limit for this job's group */
+  concurrencyLimit: z.number(),
+})
+
+export const RecoverJobsOptionsSchema = z.object({
+  /** The action checksums to recover jobs for */
+  checksums: z.array(z.string()),
+  /** Whether to ping other processes before recovering their jobs */
+  multiProcessMode: z.boolean().optional(),
+  /** Timeout in milliseconds to wait for process ping responses */
+  processTimeout: z.number().optional(),
+})
+
+export const FetchOptionsSchema = z.object({
+  /** Maximum number of jobs to fetch in this batch */
+  batch: z.number(),
+})
+
+export const CompleteJobOptionsSchema = z.object({
+  /** The ID of the job to complete */
+  jobId: z.string(),
+  /** The job output data */
+  output: z.any(),
+})
+
+export const FailJobOptionsSchema = z.object({
+  /** The ID of the job to fail */
+  jobId: z.string(),
+  /** The error data */
+  error: z.any(),
+})
+
+export const CancelJobOptionsSchema = z.object({
+  /** The ID of the job to cancel */
+  jobId: z.string(),
+})
+
+export const RetryJobOptionsSchema = z.object({
+  /** The ID of the job to retry */
+  jobId: z.string(),
+})
+
+export const DeleteJobOptionsSchema = z.object({
+  /** The ID of the job to delete */
+  jobId: z.string(),
+})
+
+export const DeleteJobsOptionsSchema = GetJobsOptionsSchema.optional()
+
+// ============================================================================
+// Step Option Schemas
+// ============================================================================
+
+export const CreateOrRecoverJobStepOptionsSchema = z.object({
+  /** The ID of the job this step belongs to */
+  jobId: z.string(),
+  /** The name of the step */
+  name: z.string(),
+  /** Timeout in milliseconds for the step */
+  timeoutMs: z.number(),
+  /** Maximum number of retries for the step */
+  retriesLimit: z.number(),
+})
+
+export const CompleteJobStepOptionsSchema = z.object({
+  /** The ID of the step to complete */
+  stepId: z.string(),
+  /** The step output data */
+  output: z.any(),
+})
+
+export const FailJobStepOptionsSchema = z.object({
+  /** The ID of the step to fail */
+  stepId: z.string(),
+  /** The error data */
+  error: z.any(),
+})
+
+export const DelayJobStepOptionsSchema = z.object({
+  /** The ID of the step to delay */
+  stepId: z.string(),
+  /** The delay in milliseconds */
+  delayMs: z.number(),
+  /** The error data */
+  error: z.any(),
+})
+
+export const CancelJobStepOptionsSchema = z.object({
+  /** The ID of the step to cancel */
+  stepId: z.string(),
+})
+
+export const CreateOrRecoverJobStepResultSchema = z.object({
+  id: z.string(),
+  status: StepStatusSchema,
+  retriesLimit: z.number(),
+  retriesCount: z.number(),
+  timeoutMs: z.number(),
+  error: z.any().nullable(),
+  output: z.any().nullable(),
+  isNew: z.boolean(),
+})
+
+// ============================================================================
+// Response Schemas
+// ============================================================================
+
+// Simple response schemas
+export const JobIdResultSchema = z.union([z.string(), z.null()])
+export const BooleanResultSchema = z.boolean()
+export const NumberResultSchema = z.number()
+export const JobsArrayResultSchema = z.array(JobSchema)
+export const CreateOrRecoverJobStepResultNullableSchema = z.union([CreateOrRecoverJobStepResultSchema, z.null()])
+
+export const GetJobsResultSchema = z.object({
+  jobs: z.array(JobSchema),
+  total: z.number().int().nonnegative(),
+  page: z.number().int().positive(),
+  pageSize: z.number().int().positive(),
+})
+
+export const GetJobStepsResultSchema = z.object({
+  steps: z.array(JobStepWithoutOutputSchema),
+  total: z.number().int().nonnegative(),
+  page: z.number().int().positive(),
+  pageSize: z.number().int().positive(),
+})
+
+export const ActionStatsSchema = z.object({
+  name: z.string(),
+  lastJobCreated: DateSchema.nullable(),
+  active: z.number().int().nonnegative(),
+  completed: z.number().int().nonnegative(),
+  failed: z.number().int().nonnegative(),
+  cancelled: z.number().int().nonnegative(),
+})
+
+export const GetActionsResultSchema = z.object({
+  actions: z.array(ActionStatsSchema),
+})
+
+export const JobStatusResultSchema = z.object({
+  status: JobStatusSchema,
+  updatedAt: DateSchema,
+})
+
+export const JobStepStatusResultSchema = z.object({
+  status: StepStatusSchema,
+  updatedAt: DateSchema,
+})
+
+// ============================================================================
+// Type Exports
+// ============================================================================
+
+export type Job = z.infer<typeof JobSchema>
+export type JobStep = z.infer<typeof JobStepSchema>
+export type JobStepWithoutOutput = z.infer<typeof JobStepWithoutOutputSchema>
+export type SortOrder = z.infer<typeof SortOrderSchema>
+export type JobSortField = z.infer<typeof JobSortFieldSchema>
+export type JobSort = z.infer<typeof JobSortSchema>
+export type JobFilters = z.infer<typeof JobFiltersSchema>
+export type GetJobsOptions = z.infer<typeof GetJobsOptionsSchema>
+export type GetJobStepsOptions = z.infer<typeof GetJobStepsOptionsSchema>
+export type GetJobsResult = z.infer<typeof GetJobsResultSchema>
+export type GetJobStepsResult = z.infer<typeof GetJobStepsResultSchema>
+export type ActionStats = z.infer<typeof ActionStatsSchema>
+export type GetActionsResult = z.infer<typeof GetActionsResultSchema>
+export type JobStatusResult = z.infer<typeof JobStatusResultSchema>
+export type JobStepStatusResult = z.infer<typeof JobStepStatusResultSchema>
+export type CreateJobOptions = z.infer<typeof CreateJobOptionsSchema>
+export type RecoverJobsOptions = z.infer<typeof RecoverJobsOptionsSchema>
+export type FetchOptions = z.infer<typeof FetchOptionsSchema>
+export type CompleteJobOptions = z.infer<typeof CompleteJobOptionsSchema>
+export type FailJobOptions = z.infer<typeof FailJobOptionsSchema>
+export type CancelJobOptions = z.infer<typeof CancelJobOptionsSchema>
+export type RetryJobOptions = z.infer<typeof RetryJobOptionsSchema>
+export type DeleteJobOptions = z.infer<typeof DeleteJobOptionsSchema>
+export type DeleteJobsOptions = z.infer<typeof DeleteJobsOptionsSchema>
+export type CreateOrRecoverJobStepOptions = z.infer<typeof CreateOrRecoverJobStepOptionsSchema>
+export type CompleteJobStepOptions = z.infer<typeof CompleteJobStepOptionsSchema>
+export type FailJobStepOptions = z.infer<typeof FailJobStepOptionsSchema>
+export type DelayJobStepOptions = z.infer<typeof DelayJobStepOptionsSchema>
+export type CancelJobStepOptions = z.infer<typeof CancelJobStepOptionsSchema>
+export type CreateOrRecoverJobStepResult = z.infer<typeof CreateOrRecoverJobStepResultSchema>