@cosmicdrift/kumiko-bundled-features 0.383.0 → 0.384.0

package/dist/jobs/handlers/consumer.write.d.ts

@@ -0,0 +1,37 @@
+import * as z from "zod";
+export declare const consumerRestartWrite: import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<string, z.ZodObject<{
+    name: z.ZodString;
+    instanceId: z.ZodString;
+}, z.core.$strip>, {
+    name: string;
+    instanceId: string;
+    status: string;
+    skippedEventId: string | null;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;
+export declare const consumerSkipWrite: import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<string, z.ZodObject<{
+    name: z.ZodString;
+    instanceId: z.ZodString;
+}, z.core.$strip>, {
+    name: string;
+    instanceId: string;
+    status: string;
+    skippedEventId: string | null;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;
+export declare const consumerDisableWrite: import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<string, z.ZodObject<{
+    name: z.ZodString;
+    instanceId: z.ZodString;
+}, z.core.$strip>, {
+    name: string;
+    instanceId: string;
+    status: string;
+    skippedEventId: string | null;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;
+export declare const consumerEnableWrite: import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<string, z.ZodObject<{
+    name: z.ZodString;
+    instanceId: z.ZodString;
+}, z.core.$strip>, {
+    name: string;
+    instanceId: string;
+    status: string;
+    skippedEventId: string | null;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;

package/dist/jobs/handlers/consumer.write.js

@@ -0,0 +1,59 @@
+import { defineWriteHandler } from "@cosmicdrift/kumiko-framework/engine";
+import { InternalError, UnprocessableError, writeFailure, } from "@cosmicdrift/kumiko-framework/errors";
+import { ConsumerStatuses, ConsumerTransitionError, disableConsumer, enableConsumer, restartConsumer, skipPoisonEvent, } from "@cosmicdrift/kumiko-framework/pipeline";
+import * as z from "zod";
+import { JobErrors } from "../web/constants.js";
+const consumerTargetSchema = z.object({ name: z.string().min(1), instanceId: z.string().min(1) });
+const CONSUMER_STATE_REASON = "event consumer state is global dispatcher state, not tenant data";
+function rejected(code, i18nKey) {
+    return writeFailure(new UnprocessableError(code, { i18nKey }));
+}
+function defineConsumerWrite(name, description, transition) {
+    return defineWriteHandler({
+        name,
+        description,
+        schema: consumerTargetSchema,
+        access: { roles: ["SystemAdmin"] },
+        // Operator recovery for people only; skip drops an event for good.
+        agent: { expose: false },
+        handler: async (event, ctx) => {
+            if (!ctx.systemDb) {
+                throw new InternalError({
+                    message: `jobs:write:${name} requires ctx.systemDb (feature must declare r.systemScope())`,
+                });
+            }
+            const db = ctx.systemDb.unsafeRaw(CONSUMER_STATE_REASON);
+            try {
+                const next = await transition(db, event.payload.name, event.payload.instanceId);
+                if (next.skippedEventId === null) {
+                    return rejected(JobErrors.consumerNothingToSkip, "jobs.errors.consumerNothingToSkip");
+                }
+                return {
+                    isSuccess: true,
+                    data: {
+                        name: next.name,
+                        instanceId: next.instanceId,
+                        status: next.status,
+                        skippedEventId: next.skippedEventId?.toString() ?? null,
+                    },
+                };
+            }
+            catch (e) {
+                if (e instanceof ConsumerTransitionError) {
+                    return e.rejection === "unknown-consumer"
+                        ? rejected(JobErrors.consumerUnknown, "jobs.errors.consumerUnknown")
+                        : rejected(JobErrors.consumerWrongStatus, "jobs.errors.consumerWrongStatus");
+                }
+                ctx.log?.error(`jobs:write:${name} failed: ${e instanceof Error ? e.message : String(e)}`, {
+                    consumer: event.payload.name,
+                    instanceId: event.payload.instanceId,
+                });
+                return rejected(JobErrors.consumerTransitionFailed, "jobs.errors.consumerTransitionFailed");
+            }
+        },
+    });
+}
+export const consumerRestartWrite = defineConsumerWrite("consumer-restart", "Sets a dead event consumer back to idle so it retries the event that stopped it; use it after a transient failure is fixed.", restartConsumer);
+export const consumerSkipWrite = defineConsumerWrite("consumer-skip", "Moves a stuck event consumer past the event that keeps failing; that event is never delivered to this consumer, so use it only for events that can never succeed.", (db, consumerName, instanceId) => skipPoisonEvent(db, consumerName, instanceId, { requireStatus: ConsumerStatuses.dead }));
+export const consumerDisableWrite = defineConsumerWrite("consumer-disable", "Pauses an event consumer; the dispatcher skips it until it is enabled again.", disableConsumer);
+export const consumerEnableWrite = defineConsumerWrite("consumer-enable", "Resumes a paused event consumer from where it stopped.", enableConsumer);

package/dist/jobs/handlers/consumers.query.d.ts

@@ -0,0 +1,52 @@
+import * as z from "zod";
+export declare function consumerRowId(name: string, instanceId: string): string;
+export declare function splitConsumerRowId(id: string): {
+    name: string;
+    instanceId: string;
+} | null;
+export declare const consumersQuery: import("@cosmicdrift/kumiko-types/define-handler").QueryHandlerDefinition<"consumers", z.ZodObject<{
+    filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        field: z.ZodLiteral<"status">;
+        op: z.ZodLiteral<"in">;
+        value: z.ZodArray<z.ZodEnum<{
+            dead: "dead";
+            disabled: "disabled";
+            idle: "idle";
+            "never-run": "never-run";
+            processing: "processing";
+        }>>;
+    }, z.core.$strict>>>;
+    sort: z.ZodOptional<z.ZodEnum<{
+        attempts: "attempts";
+        lag: "lag";
+        name: "name";
+        status: "status";
+    }>>;
+    sortDirection: z.ZodOptional<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+}, z.core.$strip>, {
+    rows: {
+        id: string;
+        name: string;
+        instanceId: string;
+        status: string;
+        lag: number;
+        attempts: number;
+        lastError: string | null;
+    }[];
+    nextCursor: null;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;
+export declare const consumerDetailQuery: import("@cosmicdrift/kumiko-types/define-handler").QueryHandlerDefinition<"consumer-details", z.ZodObject<{
+    consumerId: z.ZodString;
+}, z.core.$strip>, {
+    id: string;
+    name: string;
+    instanceId: string;
+    status: string;
+    lag: number;
+    attempts: number;
+    lastError: string | null;
+    updatedAt: string | null;
+} | null, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;

package/dist/jobs/handlers/consumers.query.js

@@ -0,0 +1,114 @@
+import { defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
+import { InternalError } from "@cosmicdrift/kumiko-framework/errors";
+import { getAllConsumerProgress, getConsumerState, SEARCH_CONSUMER_NAME, SSE_BROADCAST_CONSUMER_NAME, } from "@cosmicdrift/kumiko-framework/pipeline";
+import * as z from "zod";
+import { CONSUMER_ID_SEPARATOR, CONSUMER_STATUSES, isConsumerStatus, } from "../web/constants.js";
+const LAST_ERROR_PREVIEW_LENGTH = 90;
+// Dead consumers are what support looks for, so they lead the default order.
+const STATUS_RANK = {
+    dead: 0,
+    disabled: 1,
+    processing: 2,
+    "never-run": 3,
+    idle: 4,
+};
+export function consumerRowId(name, instanceId) {
+    return `${name}${CONSUMER_ID_SEPARATOR}${instanceId}`;
+}
+export function splitConsumerRowId(id) {
+    const at = id.lastIndexOf(CONSUMER_ID_SEPARATOR);
+    if (at <= 0)
+        return null;
+    return { name: id.slice(0, at), instanceId: id.slice(at + 1) };
+}
+function registeredConsumerNames(registry) {
+    return [
+        SSE_BROADCAST_CONSUMER_NAME,
+        SEARCH_CONSUMER_NAME,
+        ...registry.getAllMultiStreamProjections().keys(),
+    ];
+}
+function previewOf(error) {
+    if (error === null || error.length <= LAST_ERROR_PREVIEW_LENGTH)
+        return error;
+    return `${error.slice(0, LAST_ERROR_PREVIEW_LENGTH).trimEnd()}…`;
+}
+function toRow(c) {
+    return {
+        id: consumerRowId(c.name, c.instanceId),
+        name: c.name,
+        instanceId: c.instanceId,
+        status: c.status,
+        lag: Number(c.lag),
+        attempts: c.attempts,
+        lastError: previewOf(c.lastError),
+    };
+}
+const statusFilterSchema = z.strictObject({
+    field: z.literal("status"),
+    op: z.literal("in"),
+    value: z.array(z.enum(CONSUMER_STATUSES)),
+});
+export const consumersQuery = defineQueryHandler({
+    name: "consumers",
+    description: "Lists every event consumer (projections, search indexer, SSE broadcaster) with status, lag behind the event store and last error, dead consumers first; use it to find a stuck consumer.",
+    schema: z.object({
+        filters: z.array(statusFilterSchema).max(1).optional(),
+        sort: z.enum(["name", "status", "lag", "attempts"]).optional(),
+        sortDirection: z.enum(["asc", "desc"]).optional(),
+    }),
+    access: { roles: ["SystemAdmin"] },
+    handler: async (query, ctx) => {
+        if (!ctx.systemDb) {
+            throw new InternalError({
+                message: "jobs:query:consumers requires ctx.systemDb (feature must declare r.systemScope())",
+            });
+        }
+        const db = ctx.systemDb.unsafeRaw("event consumer state is global dispatcher state, not tenant data");
+        const progress = await getAllConsumerProgress(db, registeredConsumerNames(ctx.registry));
+        const statuses = query.payload.filters?.[0]?.value;
+        const visible = statuses
+            ? progress.filter((c) => statuses.some((s) => s === c.status))
+            : progress;
+        const direction = query.payload.sortDirection === "desc" ? -1 : 1;
+        const sort = query.payload.sort;
+        const compare = (a, b) => {
+            if (sort === "name")
+                return a.name.localeCompare(b.name) * direction;
+            if (sort === "lag")
+                return Number(a.lag - b.lag) * direction;
+            if (sort === "attempts")
+                return (a.attempts - b.attempts) * direction;
+            const rank = (c) => isConsumerStatus(c.status) ? STATUS_RANK[c.status] : 5;
+            return (rank(a) - rank(b)) * direction || a.name.localeCompare(b.name);
+        };
+        return { rows: [...visible].sort(compare).map(toRow), nextCursor: null };
+    },
+});
+export const consumerDetailQuery = defineQueryHandler({
+    name: "consumer-details",
+    description: "Returns one event consumer with its status, lag, attempts, the full last error and the time of its last state change; use it to decide between restart, skip and pause.",
+    schema: z.object({ consumerId: z.string().min(1) }),
+    access: { roles: ["SystemAdmin"] },
+    handler: async (query, ctx) => {
+        if (!ctx.systemDb) {
+            throw new InternalError({
+                message: "jobs:query:consumer-details requires ctx.systemDb (feature must declare r.systemScope())",
+            });
+        }
+        const target = splitConsumerRowId(query.payload.consumerId);
+        if (!target)
+            return null;
+        const db = ctx.systemDb.unsafeRaw("event consumer state is global dispatcher state, not tenant data");
+        const all = await getAllConsumerProgress(db, registeredConsumerNames(ctx.registry));
+        const progress = all.find((c) => c.name === target.name && c.instanceId === target.instanceId);
+        if (!progress)
+            return null;
+        const state = await getConsumerState(db, target.name, target.instanceId);
+        return {
+            ...toRow(progress),
+            lastError: progress.lastError,
+            updatedAt: state ? state.updatedAt.toString() : null,
+        };
+    },
+});

package/dist/jobs/job-run-table.d.ts

@@ -2,119 +2,19 @@ import { type EntityTableMeta, type WritableTable } from "@cosmicdrift/kumiko-fr
 export type JobRunStatus = "queued" | "running" | "completed" | "failed";
 export type JobLogLevel = "info" | "warn" | "error";
 export declare const jobRunEntity: import("@cosmicdrift/kumiko-types/fields").EntityDefinition<{
-    readonly jobName: {
-        readonly type: "text";
-        readonly description?: string;
-        readonly maxLength?: number;
-        readonly minLength?: number;
-        readonly autoComplete?: string;
-        readonly required?: boolean;
-        readonly searchable?: boolean;
-        readonly sortable?: boolean;
-        readonly filterable?: boolean;
-        readonly encrypted?: boolean;
-        readonly sensitive?: boolean;
-        readonly writeOnly?: boolean;
-        readonly readAsInstruction?: boolean;
-        readonly format?: "email" | "url" | "phone" | "password" | "month" | "iban";
-        readonly default?: string;
-        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
-        readonly multiline?: boolean | {
-            readonly rows?: number;
-        };
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    readonly jobName: import("@cosmicdrift/kumiko-types/fields").EntityTextFieldDef & {
         required: true;
     };
-    readonly bullJobId: {
-        readonly type: "text";
-        readonly description?: string;
-        readonly maxLength?: number;
-        readonly minLength?: number;
-        readonly autoComplete?: string;
-        readonly required?: boolean;
-        readonly searchable?: boolean;
-        readonly sortable?: boolean;
-        readonly filterable?: boolean;
-        readonly encrypted?: boolean;
-        readonly sensitive?: boolean;
-        readonly writeOnly?: boolean;
-        readonly readAsInstruction?: boolean;
-        readonly format?: "email" | "url" | "phone" | "password" | "month" | "iban";
-        readonly default?: string;
-        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
-        readonly multiline?: boolean | {
-            readonly rows?: number;
-        };
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    readonly bullJobId: import("@cosmicdrift/kumiko-types/fields").EntityTextFieldDef & {
         required: true;
     };
-    readonly status: {
-        readonly type: "text";
-        readonly description?: string;
-        readonly maxLength?: number;
-        readonly minLength?: number;
-        readonly autoComplete?: string;
-        readonly required?: boolean;
-        readonly searchable?: boolean;
-        readonly sortable?: boolean;
-        readonly filterable?: boolean;
-        readonly encrypted?: boolean;
-        readonly sensitive?: boolean;
-        readonly writeOnly?: boolean;
-        readonly readAsInstruction?: boolean;
-        readonly format?: "email" | "url" | "phone" | "password" | "month" | "iban";
-        readonly default?: string;
-        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
-        readonly multiline?: boolean | {
-            readonly rows?: number;
-        };
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    readonly status: import("@cosmicdrift/kumiko-types/fields").EntityTextFieldDef & {
         required: true;
     };
-    readonly payload: {
-        readonly type: "text";
-        readonly description?: string;
-        readonly maxLength?: number;
-        readonly minLength?: number;
-        readonly autoComplete?: string;
-        readonly required?: boolean;
-        readonly searchable?: boolean;
-        readonly sortable?: boolean;
-        readonly filterable?: boolean;
-        readonly encrypted?: boolean;
-        readonly sensitive?: boolean;
-        readonly writeOnly?: boolean;
-        readonly readAsInstruction?: boolean;
-        readonly format?: "email" | "url" | "phone" | "password" | "month" | "iban";
-        readonly default?: string;
-        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
-        readonly multiline?: boolean | {
-            readonly rows?: number;
-        };
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    readonly payload: import("@cosmicdrift/kumiko-types/fields").EntityTextFieldDef & {
         required: false;
     };
-    readonly error: {
-        readonly type: "text";
-        readonly description?: string;
-        readonly maxLength?: number;
-        readonly minLength?: number;
-        readonly autoComplete?: string;
-        readonly required?: boolean;
-        readonly searchable?: boolean;
-        readonly sortable?: boolean;
-        readonly filterable?: boolean;
-        readonly encrypted?: boolean;
-        readonly sensitive?: boolean;
-        readonly writeOnly?: boolean;
-        readonly readAsInstruction?: boolean;
-        readonly format?: "email" | "url" | "phone" | "password" | "month" | "iban";
-        readonly default?: string;
-        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
-        readonly multiline?: boolean | {
-            readonly rows?: number;
-        };
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    readonly error: import("@cosmicdrift/kumiko-types/fields").EntityTextFieldDef & {
         required: false;
     };
     readonly attempt: {
@@ -185,27 +85,7 @@ export declare const jobRunEntity: import("@cosmicdrift/kumiko-types/fields").En
     } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
         required: false;
     };
-    readonly triggeredById: {
-        readonly type: "text";
-        readonly description?: string;
-        readonly maxLength?: number;
-        readonly minLength?: number;
-        readonly autoComplete?: string;
-        readonly required?: boolean;
-        readonly searchable?: boolean;
-        readonly sortable?: boolean;
-        readonly filterable?: boolean;
-        readonly encrypted?: boolean;
-        readonly sensitive?: boolean;
-        readonly writeOnly?: boolean;
-        readonly readAsInstruction?: boolean;
-        readonly format?: "email" | "url" | "phone" | "password" | "month" | "iban";
-        readonly default?: string;
-        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
-        readonly multiline?: boolean | {
-            readonly rows?: number;
-        };
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    readonly triggeredById: import("@cosmicdrift/kumiko-types/fields").EntityTextFieldDef & {
         required: false;
     };
 }, "tenant">;

package/dist/jobs/screens.d.ts

@@ -0,0 +1,6 @@
+import { type ActionFormScreenDefinition, type ProjectionDetailScreenDefinition, type ProjectionListScreenDefinition } from "@cosmicdrift/kumiko-framework/engine";
+export declare const jobRunsScreen: ProjectionListScreenDefinition;
+export declare const jobTriggerScreen: ActionFormScreenDefinition;
+export declare const jobRunDetailScreen: ProjectionDetailScreenDefinition;
+export declare const eventConsumersScreen: ProjectionListScreenDefinition;
+export declare const eventConsumerDetailScreen: ProjectionDetailScreenDefinition;

package/dist/jobs/screens.js

@@ -0,0 +1,241 @@
+import { i18nKey, } from "@cosmicdrift/kumiko-framework/engine";
+import { CONSUMER_INSTANCE_OPTION_KEY_PREFIX, CONSUMER_STATUS_OPTION_KEY_PREFIX, CONSUMER_STATUSES, EVENT_CONSUMER_DETAIL_SCREEN_ID, EVENT_CONSUMERS_SCREEN_ID, JOB_RUN_DETAIL_SCREEN_ID, JOB_RUNS_SCREEN_ID, JobHandlers, JobQueries, } from "./web/constants.js";
+const systemAdminAccess = { roles: ["SystemAdmin"] };
+export const jobRunsScreen = {
+    id: JOB_RUNS_SCREEN_ID,
+    type: "projectionList",
+    query: JobQueries.list,
+    columns: [
+        { field: "jobName", label: i18nKey("jobs.runs.col.job") },
+        { field: "status", label: i18nKey("jobs.runs.col.status") },
+        {
+            field: "startedAt",
+            label: i18nKey("jobs.runs.col.started"),
+            renderer: { format: "timestamp" },
+        },
+        { field: "duration", label: i18nKey("jobs.runs.col.duration") },
+    ],
+    defaultSort: { field: "startedAt", dir: "desc" },
+    facets: [
+        {
+            field: "status",
+            type: "select",
+            label: i18nKey("jobs.runs.filter.status"),
+            options: [
+                { value: "queued", label: i18nKey("jobs.runs.filter.queued") },
+                { value: "running", label: i18nKey("jobs.runs.filter.running") },
+                { value: "completed", label: i18nKey("jobs.runs.filter.completed") },
+                { value: "failed", label: i18nKey("jobs.runs.filter.failed") },
+            ],
+        },
+    ],
+    rowActions: [
+        {
+            kind: "navigate",
+            id: "open",
+            label: i18nKey("jobs.runs.open"),
+            screen: JOB_RUN_DETAIL_SCREEN_ID,
+            entityId: "id",
+            rowClick: true,
+        },
+    ],
+    toolbarActions: [
+        {
+            kind: "drawer",
+            id: "trigger",
+            label: i18nKey("jobs.trigger.title"),
+            screen: "job-trigger",
+            style: "primary",
+        },
+    ],
+    pagination: "infinite",
+    access: systemAdminAccess,
+};
+export const jobTriggerScreen = {
+    id: "job-trigger",
+    type: "actionForm",
+    handler: JobHandlers.trigger,
+    fields: {
+        jobName: { type: "text", required: true },
+        payload: { type: "longText", multiline: true, default: "{}" },
+    },
+    layout: { sections: [{ fields: ["jobName", "payload"] }] },
+    submitLabel: i18nKey("jobs.trigger.submit"),
+    access: systemAdminAccess,
+    description: "jobs.screen.job-trigger.subtitle",
+};
+export const jobRunDetailScreen = {
+    id: JOB_RUN_DETAIL_SCREEN_ID,
+    type: "projectionDetail",
+    query: JobQueries.details,
+    idParam: "runId",
+    fieldLabels: {
+        jobName: i18nKey("jobs.detail.field.job"),
+        status: i18nKey("jobs.detail.field.status"),
+        id: i18nKey("jobs.detail.field.id"),
+        startedAt: i18nKey("jobs.detail.field.started"),
+        finishedAt: i18nKey("jobs.detail.field.finished"),
+        duration: i18nKey("jobs.detail.field.duration"),
+        error: i18nKey("jobs.detail.field.error"),
+        logs: i18nKey("jobs.detail.logs"),
+    },
+    layout: {
+        sections: [
+            {
+                fields: [
+                    "jobName",
+                    "status",
+                    "id",
+                    { field: "startedAt", renderer: { format: "timestamp" } },
+                    { field: "finishedAt", renderer: { format: "timestamp" } },
+                    "duration",
+                    "error",
+                ],
+            },
+            // No section `title` here (fw#2312 label-dedup fix): the section
+            // holds exactly one field, so a title would repeat the field's own
+            // label (rendered by RenderField as the Field's heading) verbatim.
+            {
+                fields: [{ field: "logs", renderer: { format: "json" } }],
+            },
+        ],
+    },
+    actions: [
+        {
+            kind: "writeHandler",
+            id: "retry",
+            label: i18nKey("jobs.detail.retry"),
+            handler: JobHandlers.retry,
+            payload: { map: { runId: "id" } },
+            visible: { field: "status", eq: "failed" },
+            style: "primary",
+        },
+    ],
+    description: "jobs.screen.job-run-detail.subtitle",
+    listScreenId: JOB_RUNS_SCREEN_ID,
+    access: systemAdminAccess,
+};
+export const eventConsumersScreen = {
+    id: EVENT_CONSUMERS_SCREEN_ID,
+    type: "projectionList",
+    query: JobQueries.consumers,
+    columns: [
+        { field: "name", label: i18nKey("jobs.consumers.col.name") },
+        {
+            field: "status",
+            label: i18nKey("jobs.consumers.col.status"),
+            renderer: { format: "enumOption", keyPrefix: CONSUMER_STATUS_OPTION_KEY_PREFIX },
+        },
+        { field: "lag", label: i18nKey("jobs.consumers.col.lag"), hideOnNarrow: true },
+        { field: "attempts", label: i18nKey("jobs.consumers.col.attempts"), hideOnNarrow: true },
+        { field: "lastError", label: i18nKey("jobs.consumers.col.lastError") },
+    ],
+    defaultSort: { field: "status", dir: "asc" },
+    facets: [
+        {
+            field: "status",
+            type: "select",
+            label: i18nKey("jobs.consumers.col.status"),
+            options: CONSUMER_STATUSES.map((status) => ({
+                value: status,
+                label: i18nKey(`${CONSUMER_STATUS_OPTION_KEY_PREFIX}${status}`),
+            })),
+        },
+    ],
+    rowActions: [
+        {
+            kind: "navigate",
+            id: "open",
+            label: i18nKey("jobs.runs.open"),
+            screen: EVENT_CONSUMER_DETAIL_SCREEN_ID,
+            entityId: "id",
+            rowClick: true,
+        },
+    ],
+    pagination: "infinite",
+    access: systemAdminAccess,
+    description: "jobs.screen.event-consumers.subtitle",
+};
+export const eventConsumerDetailScreen = {
+    id: EVENT_CONSUMER_DETAIL_SCREEN_ID,
+    type: "projectionDetail",
+    query: JobQueries.consumerDetails,
+    idParam: "consumerId",
+    fieldLabels: {
+        name: i18nKey("jobs.consumers.col.name"),
+        instanceId: i18nKey("jobs.consumers.field.instanceId"),
+        status: i18nKey("jobs.consumers.col.status"),
+        lag: i18nKey("jobs.consumers.col.lag"),
+        attempts: i18nKey("jobs.consumers.col.attempts"),
+        lastError: i18nKey("jobs.consumers.col.lastError"),
+        updatedAt: i18nKey("jobs.consumers.field.updatedAt"),
+    },
+    layout: {
+        sections: [
+            {
+                fields: [
+                    "name",
+                    {
+                        field: "instanceId",
+                        renderer: { format: "enumOption", keyPrefix: CONSUMER_INSTANCE_OPTION_KEY_PREFIX },
+                    },
+                    {
+                        field: "status",
+                        renderer: { format: "enumOption", keyPrefix: CONSUMER_STATUS_OPTION_KEY_PREFIX },
+                    },
+                    "lag",
+                    "attempts",
+                    { field: "updatedAt", renderer: { format: "timestamp" } },
+                ],
+            },
+            { fields: ["lastError"] },
+        ],
+    },
+    actions: [
+        {
+            kind: "writeHandler",
+            id: "restart",
+            icon: "refresh",
+            label: i18nKey("jobs.consumers.restart"),
+            handler: JobHandlers.consumerRestart,
+            payload: { map: { name: "name", instanceId: "instanceId" } },
+            visible: { field: "status", eq: "dead" },
+            style: "primary",
+        },
+        {
+            kind: "writeHandler",
+            id: "skip",
+            icon: "arrow-right",
+            label: i18nKey("jobs.consumers.skip"),
+            handler: JobHandlers.consumerSkip,
+            payload: { map: { name: "name", instanceId: "instanceId" } },
+            visible: { field: "status", eq: "dead" },
+            confirm: i18nKey("jobs.consumers.skip.confirm"),
+            style: "danger",
+        },
+        {
+            kind: "writeHandler",
+            id: "disable",
+            icon: "x",
+            label: i18nKey("jobs.consumers.disable"),
+            handler: JobHandlers.consumerDisable,
+            payload: { map: { name: "name", instanceId: "instanceId" } },
+            visible: { field: "status", ne: "disabled" },
+            style: "secondary",
+        },
+        {
+            kind: "writeHandler",
+            id: "enable",
+            icon: "check",
+            label: i18nKey("jobs.consumers.enable"),
+            handler: JobHandlers.consumerEnable,
+            payload: { map: { name: "name", instanceId: "instanceId" } },
+            visible: { field: "status", eq: "disabled" },
+            style: "primary",
+        },
+    ],
+    primaryAction: "restart",
+    description: "jobs.screen.event-consumer-detail.subtitle",
+    listScreenId: EVENT_CONSUMERS_SCREEN_ID,
+    access: systemAdminAccess,
+};