@lucidcms/core/dist/libs/repositories/queue-jobs.d.mts

The core of the Lucid CMS. It's responsible for spinning up the API and serving the CMS.

import { QueryParams } from "../../types/query-params.mjs";
import DatabaseAdapter from "../db/adapter-base.mjs";
import { QueueJobStatus } from "../queue/types.mjs";
import { KyselyDB, LucidQueueJobs, Select } from "../db/types.mjs";
import { QueryProps, QueryResult } from "./types.mjs";
import StaticRepository from "./parents/static-repository.mjs";
import z from "zod";

//#region src/libs/repositories/queue-jobs.d.ts
declare class QueueJobsRepository extends StaticRepository<"lucid_queue_jobs"> {
  constructor(db: KyselyDB, dbAdapter: DatabaseAdapter);
  tableSchema: z.ZodObject<{
    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
    job_id: z.ZodString;
    event_type: z.ZodString;
    event_data: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    status: z.ZodEnum<{
      pending: "pending";
      cancelled: "cancelled";
      failed: "failed";
      processing: "processing";
      completed: "completed";
    }>;
    queue_adapter_key: z.ZodString;
    priority: z.ZodNullable<z.ZodNumber>;
    attempts: z.ZodNumber;
    max_attempts: z.ZodNumber;
    error_message: z.ZodNullable<z.ZodString>;
    created_at: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>>;
    scheduled_for: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>>;
    started_at: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>>;
    completed_at: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>>;
    failed_at: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>>;
    next_retry_at: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>>;
    created_by_user_id: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
    updated_at: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>>;
  }, z.z.core.$strip>;
  columnFormats: {
    id: import("kysely").ColumnDataType;
    job_id: import("kysely").ColumnDataType;
    event_type: import("kysely").ColumnDataType;
    event_data: import("kysely").ColumnDataType;
    status: import("kysely").ColumnDataType;
    queue_adapter_key: import("kysely").ColumnDataType;
    priority: import("kysely").ColumnDataType;
    attempts: import("kysely").ColumnDataType;
    max_attempts: import("kysely").ColumnDataType;
    error_message: import("kysely").ColumnDataType;
    created_at: import("kysely").ColumnDataType;
    scheduled_for: import("kysely").ColumnDataType;
    started_at: import("kysely").ColumnDataType;
    completed_at: import("kysely").ColumnDataType;
    failed_at: import("kysely").ColumnDataType;
    next_retry_at: import("kysely").ColumnDataType;
    created_by_user_id: import("kysely").ColumnDataType;
    updated_at: import("kysely").ColumnDataType;
  };
  queryConfig: {
    readonly tableKeys: {
      readonly filters: {
        readonly jobId: "job_id";
        readonly eventType: "event_type";
        readonly status: "status";
        readonly queueAdapterKey: "queue_adapter_key";
        readonly priority: "priority";
        readonly attempts: "attempts";
        readonly maxAttempts: "max_attempts";
        readonly errorMessage: "error_message";
        readonly createdByUserId: "created_by_user_id";
        readonly createdAt: "created_at";
        readonly scheduledFor: "scheduled_for";
        readonly startedAt: "started_at";
        readonly completedAt: "completed_at";
        readonly failedAt: "failed_at";
        readonly nextRetryAt: "next_retry_at";
      };
      readonly sorts: {
        readonly jobId: "job_id";
        readonly eventType: "event_type";
        readonly status: "status";
        readonly queueAdapterKey: "queue_adapter_key";
        readonly priority: "priority";
        readonly attempts: "attempts";
        readonly maxAttempts: "max_attempts";
        readonly createdAt: "created_at";
        readonly scheduledFor: "scheduled_for";
        readonly startedAt: "started_at";
        readonly completedAt: "completed_at";
        readonly failedAt: "failed_at";
        readonly nextRetryAt: "next_retry_at";
        readonly updatedAt: "updated_at";
      };
    };
    readonly operators: {
      readonly eventType: "contains";
      readonly queueAdapterKey: "contains";
      readonly errorMessage: "contains";
    };
  };
  selectSingleById<K extends keyof Select<LucidQueueJobs>, V extends boolean = false>(props: QueryProps<V, {
    id: number;
    select: K[];
    tenantKey?: string | null;
  }>): Promise<QueryResult<Pick<Select<LucidQueueJobs>, K>, V>>;
  selectMultipleFilteredFixed<K extends keyof Select<LucidQueueJobs>, V extends boolean = false>(props: QueryProps<V, {
    select: K[];
    queryParams: Partial<QueryParams>;
    tenantKey?: string | null;
  }>): Promise<QueryResult<readonly [Pick<Select<LucidQueueJobs>, K>[], {
    count: string;
  } | undefined], V>>;
  selectJobsForProcessing<V extends boolean = false>(props: QueryProps<V, {
    data: {
      limit: number;
      currentTime: Date;
    };
  }>): Promise<QueryResult<{
    status: QueueJobStatus;
    id: number;
    priority: number | null;
    job_id: string;
    event_type: string;
    event_data: Record<string, unknown>;
    queue_adapter_key: string;
    attempts: number;
    max_attempts: number;
    error_message: string | null;
    created_at: string | Date;
    scheduled_for: string | Date | null;
    started_at: string | Date | null;
    completed_at: string | Date | null;
    failed_at: string | Date | null;
    next_retry_at: string | Date | null;
    created_by_user_id: number | null;
    updated_at: string | Date | null;
  }[], V>>;
  private applyTenantScope;
}
//#endregion
export { QueueJobsRepository as default };
//# sourceMappingURL=queue-jobs.d.mts.map