@jumoo/processing 17.4.3-prerelease.2 → 17.4.3-prerelease.4

package/dist/api/index.d.ts

@@ -1,3 +1,3 @@
 export { client, type CreateClientConfig } from './client.gen';
 export { type Options, PipelinesService, QueuesService } from './sdk.gen';
-export { type ClearPipelineData, type ClearPipelineError, type ClearPipelineErrors, type ClearPipelineResponses, type ClientOptions, type CreatePipelineData, type CreatePipelineError, type CreatePipelineErrors, type CreatePipelineResponse, type CreatePipelineResponses, type DeleteData, type DeleteError, type DeleteErrors, type DeleteResponses, type GetPipelineData, type GetPipelineError, type GetPipelineErrors, type GetPipelineResponse, type GetPipelineResponses, type GetProcessorsData, type GetProcessorsError, type GetProcessorsErrors, type GetProcessorsResponse, type GetProcessorsResponses, type GetResultsData, type GetResultsError, type GetResultsErrors, type GetResultsResponse, type GetResultsResponses, type ListPipelinesByStrategyData, type ListPipelinesByStrategyError, type ListPipelinesByStrategyErrors, type ListPipelinesByStrategyResponse, type ListPipelinesByStrategyResponses, type ListPipelinesData, type ListPipelinesError, type ListPipelinesErrors, type ListPipelinesResponse, type ListPipelinesResponses, type ListQueueData, type ListQueueError, type ListQueueErrors, type ListQueueResponse, type ListQueueResponses, type PagedModelQueuedItemModel, type PeekItemData, type PeekItemError, type PeekItemErrors, type PeekItemResponse, type PeekItemResponses, type Pipeline, type PipelineBackgroundState, type PipelineCreateRequest, type PipelineState, PipelineStatus, type ProblemDetails, type ProcessData, type ProcessError, type ProcessErrors, type ProcessingChildRequestAction, type ProcessingErrorDetails, type ProcessingOptions, type ProcessingOptionsResults, type ProcessingRequest, type ProcessingRequestAction, type ProcessingResults, type ProcessPipelineData, type ProcessPipelineError, type ProcessPipelineErrors, type ProcessPipelineResponse, type ProcessPipelineResponses, type ProcessResponse, type ProcessResponses, type ProgressInformation, type QueuedItem, type ReattachPipelineData, type ReattachPipelineError, type ReattachPipelineErrors, type ReattachPipelineResponse, type ReattachPipelineResponses, type StepInfo, StepStatus, type UpdatePipelineData, type UpdatePipelineError, type UpdatePipelineErrors, type UpdatePipelineResponse, type UpdatePipelineResponses } from './types.gen';
+export { type CancelPipelineData, type CancelPipelineError, type CancelPipelineErrors, type CancelPipelineResponses, type ClearPipelineData, type ClearPipelineError, type ClearPipelineErrors, type ClearPipelineResponses, type ClientOptions, type CreatePipelineData, type CreatePipelineError, type CreatePipelineErrors, type CreatePipelineResponse, type CreatePipelineResponses, type DeleteData, type DeleteError, type DeleteErrors, type DeleteResponses, type GetPipelineData, type GetPipelineError, type GetPipelineErrors, type GetPipelineResponse, type GetPipelineResponses, type GetProcessorsData, type GetProcessorsError, type GetProcessorsErrors, type GetProcessorsResponse, type GetProcessorsResponses, type GetResultsData, type GetResultsError, type GetResultsErrors, type GetResultsResponse, type GetResultsResponses, type ListPipelinesByStrategyData, type ListPipelinesByStrategyError, type ListPipelinesByStrategyErrors, type ListPipelinesByStrategyResponse, type ListPipelinesByStrategyResponses, type ListPipelinesData, type ListPipelinesError, type ListPipelinesErrors, type ListPipelinesResponse, type ListPipelinesResponses, type ListQueueData, type ListQueueError, type ListQueueErrors, type ListQueueResponse, type ListQueueResponses, type PagedModelQueuedItemModel, type PeekItemData, type PeekItemError, type PeekItemErrors, type PeekItemResponse, type PeekItemResponses, type Pipeline, type PipelineBackgroundState, type PipelineConflictProblemDetails, type PipelineCreateRequest, type PipelineRunError, type PipelineRunProgress, type PipelineRunRejected, PipelineRunRejectedReason, type PipelineRunRequest, type PipelineRunStarted, PipelineRunState, type PipelineRunStatus, type PipelineRunSummary, type PipelineState, PipelineStatus, type PipelineStatusData, type PipelineStatusError, type PipelineStatusErrors, type PipelineStatusResponse, type PipelineStatusResponses, type ProblemDetails, type ProcessData, type ProcessError, type ProcessErrors, type ProcessingChildRequestAction, type ProcessingErrorDetails, type ProcessingOptions, type ProcessingOptionsResults, type ProcessingRequest, type ProcessingRequestAction, type ProcessingResults, type ProcessPipelineData, type ProcessPipelineError, type ProcessPipelineErrors, type ProcessPipelineResponse, type ProcessPipelineResponses, type ProcessResponse, type ProcessResponses, type ProgressInformation, type QueuedItem, type ReattachPipelineData, type ReattachPipelineError, type ReattachPipelineErrors, type ReattachPipelineResponse, type ReattachPipelineResponses, type StartPipelineData, type StartPipelineError, type StartPipelineErrors, type StartPipelineResponse, type StartPipelineResponses, type StepInfo, StepStatus, type UpdatePipelineData, type UpdatePipelineError, type UpdatePipelineErrors, type UpdatePipelineResponse, type UpdatePipelineResponses } from './types.gen';

package/dist/api/index.js

@@ -1,4 +1,4 @@
 // This file is auto-generated by @hey-api/openapi-ts
 export { client } from './client.gen';
 export { PipelinesService, QueuesService } from './sdk.gen';
-export { PipelineStatus, StepStatus } from './types.gen';
+export { PipelineRunRejectedReason, PipelineRunState, PipelineStatus, StepStatus } from './types.gen';

package/dist/api/sdk.gen.d.ts

@@ -1,5 +1,5 @@
 import type { Client, Options as Options2, TDataShape } from './client';
-import type { ClearPipelineData, ClearPipelineErrors, ClearPipelineResponses, CreatePipelineData, CreatePipelineErrors, CreatePipelineResponses, DeleteData, DeleteErrors, DeleteResponses, GetPipelineData, GetPipelineErrors, GetPipelineResponses, GetProcessorsData, GetProcessorsErrors, GetProcessorsResponses, GetResultsData, GetResultsErrors, GetResultsResponses, ListPipelinesByStrategyData, ListPipelinesByStrategyErrors, ListPipelinesByStrategyResponses, ListPipelinesData, ListPipelinesErrors, ListPipelinesResponses, ListQueueData, ListQueueErrors, ListQueueResponses, PeekItemData, PeekItemErrors, PeekItemResponses, ProcessData, ProcessErrors, ProcessPipelineData, ProcessPipelineErrors, ProcessPipelineResponses, ProcessResponses, ReattachPipelineData, ReattachPipelineErrors, ReattachPipelineResponses, UpdatePipelineData, UpdatePipelineErrors, UpdatePipelineResponses } from './types.gen';
+import type { CancelPipelineData, CancelPipelineErrors, CancelPipelineResponses, ClearPipelineData, ClearPipelineErrors, ClearPipelineResponses, CreatePipelineData, CreatePipelineErrors, CreatePipelineResponses, DeleteData, DeleteErrors, DeleteResponses, GetPipelineData, GetPipelineErrors, GetPipelineResponses, GetProcessorsData, GetProcessorsErrors, GetProcessorsResponses, GetResultsData, GetResultsErrors, GetResultsResponses, ListPipelinesByStrategyData, ListPipelinesByStrategyErrors, ListPipelinesByStrategyResponses, ListPipelinesData, ListPipelinesErrors, ListPipelinesResponses, ListQueueData, ListQueueErrors, ListQueueResponses, PeekItemData, PeekItemErrors, PeekItemResponses, PipelineStatusData, PipelineStatusErrors, PipelineStatusResponses, ProcessData, ProcessErrors, ProcessPipelineData, ProcessPipelineErrors, ProcessPipelineResponses, ProcessResponses, ReattachPipelineData, ReattachPipelineErrors, ReattachPipelineResponses, StartPipelineData, StartPipelineErrors, StartPipelineResponses, UpdatePipelineData, UpdatePipelineErrors, UpdatePipelineResponses } from './types.gen';
 export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options2<TData, ThrowOnError, TResponse> & {
     /**
      * You can provide a client instance returned by `createClient()` instead of
@@ -14,6 +14,7 @@ export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends
     meta?: Record<string, unknown>;
 };
 export declare class PipelinesService {
+    static cancelPipeline<ThrowOnError extends boolean = true>(options: Options<CancelPipelineData, ThrowOnError>): import("./client").RequestResult<CancelPipelineResponses, CancelPipelineErrors, ThrowOnError, "fields">;
     static clearPipeline<ThrowOnError extends boolean = true>(options: Options<ClearPipelineData, ThrowOnError>): import("./client").RequestResult<ClearPipelineResponses, ClearPipelineErrors, ThrowOnError, "fields">;
     static createPipeline<ThrowOnError extends boolean = true>(options?: Options<CreatePipelineData, ThrowOnError>): import("./client").RequestResult<CreatePipelineResponses, CreatePipelineErrors, ThrowOnError, "fields">;
     static getPipeline<ThrowOnError extends boolean = true>(options: Options<GetPipelineData, ThrowOnError>): import("./client").RequestResult<GetPipelineResponses, GetPipelineErrors, ThrowOnError, "fields">;
@@ -21,8 +22,10 @@ export declare class PipelinesService {
     static getResults<ThrowOnError extends boolean = true>(options: Options<GetResultsData, ThrowOnError>): import("./client").RequestResult<GetResultsResponses, GetResultsErrors, ThrowOnError, "fields">;
     static listPipelines<ThrowOnError extends boolean = true>(options: Options<ListPipelinesData, ThrowOnError>): import("./client").RequestResult<ListPipelinesResponses, ListPipelinesErrors, ThrowOnError, "fields">;
     static listPipelinesByStrategy<ThrowOnError extends boolean = true>(options: Options<ListPipelinesByStrategyData, ThrowOnError>): import("./client").RequestResult<ListPipelinesByStrategyResponses, ListPipelinesByStrategyErrors, ThrowOnError, "fields">;
+    static pipelineStatus<ThrowOnError extends boolean = true>(options: Options<PipelineStatusData, ThrowOnError>): import("./client").RequestResult<PipelineStatusResponses, PipelineStatusErrors, ThrowOnError, "fields">;
     static processPipeline<ThrowOnError extends boolean = true>(options: Options<ProcessPipelineData, ThrowOnError>): import("./client").RequestResult<ProcessPipelineResponses, ProcessPipelineErrors, ThrowOnError, "fields">;
     static reattachPipeline<ThrowOnError extends boolean = true>(options: Options<ReattachPipelineData, ThrowOnError>): import("./client").RequestResult<ReattachPipelineResponses, ReattachPipelineErrors, ThrowOnError, "fields">;
+    static startPipeline<ThrowOnError extends boolean = true>(options?: Options<StartPipelineData, ThrowOnError>): import("./client").RequestResult<StartPipelineResponses, StartPipelineErrors, ThrowOnError, "fields">;
     static updatePipeline<ThrowOnError extends boolean = true>(options: Options<UpdatePipelineData, ThrowOnError>): import("./client").RequestResult<UpdatePipelineResponses, UpdatePipelineErrors, ThrowOnError, "fields">;
 }
 export declare class QueuesService {

package/dist/api/sdk.gen.js

@@ -1,6 +1,13 @@
 // This file is auto-generated by @hey-api/openapi-ts
 import { client } from './client.gen';
 export class PipelinesService {
+    static cancelPipeline(options) {
+        return (options.client ?? client).post({
+            security: [{ scheme: 'bearer', type: 'http' }],
+            url: '/umbraco/jumoo/api/v1/processing/CancelPipeline/{id}',
+            ...options
+        });
+    }
     static clearPipeline(options) {
         return (options.client ?? client).post({
             security: [{ scheme: 'bearer', type: 'http' }],
@@ -54,6 +61,13 @@ export class PipelinesService {
             ...options
         });
     }
+    static pipelineStatus(options) {
+        return (options.client ?? client).get({
+            security: [{ scheme: 'bearer', type: 'http' }],
+            url: '/umbraco/jumoo/api/v1/processing/PipelineStatus/{id}',
+            ...options
+        });
+    }
     static processPipeline(options) {
         return (options.client ?? client).post({
             security: [{ scheme: 'bearer', type: 'http' }],
@@ -68,6 +82,17 @@ export class PipelinesService {
             ...options
         });
     }
+    static startPipeline(options) {
+        return (options?.client ?? client).post({
+            security: [{ scheme: 'bearer', type: 'http' }],
+            url: '/umbraco/jumoo/api/v1/processing/StartPipeline',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers
+            }
+        });
+    }
     static updatePipeline(options) {
         return (options.client ?? client).post({
             security: [{ scheme: 'bearer', type: 'http' }],

package/dist/api/types.gen.d.ts

@@ -20,12 +20,84 @@ export type PipelineBackgroundState = {
     failedElement?: string | null;
     clientId?: string | null;
 };
+export type PipelineConflictProblemDetails = {
+    type?: string | null;
+    title?: string | null;
+    status?: number | null;
+    detail?: string | null;
+    instance?: string | null;
+    runningPipelineId: string;
+    concurrencyKey: string;
+    [key: string]: unknown;
+};
 export type PipelineCreateRequest = {
     alias: string;
     strategy: string;
     options?: ProcessingOptions | null;
     clientId?: string | null;
 };
+export type PipelineRunError = {
+    message: string;
+    action?: string | null;
+    step?: string | null;
+};
+export type PipelineRunProgress = {
+    percentage: number;
+    action?: string | null;
+    step?: string | null;
+    page: number;
+};
+export type PipelineRunRejected = {
+    reason: PipelineRunRejectedReason;
+    message: string;
+    runningPipelineId?: string | null;
+    concurrencyKey?: string | null;
+};
+export declare enum PipelineRunRejectedReason {
+    NOT_FOUND = "NotFound",
+    ALREADY_RUNNING = "AlreadyRunning",
+    INVALID = "Invalid"
+}
+export type PipelineRunRequest = {
+    processor: string;
+    strategy: string;
+    options?: ProcessingOptions | null;
+    startAtUtc?: string | null;
+    clientId?: string | null;
+};
+export type PipelineRunStarted = {
+    pipelineId: string;
+    status: PipelineRunState;
+    statusUrl: string;
+};
+export declare enum PipelineRunState {
+    QUEUED = "Queued",
+    RUNNING = "Running",
+    SCHEDULED = "Scheduled",
+    WAITING = "Waiting",
+    COMPLETED = "Completed",
+    FAILED = "Failed",
+    CANCELLED = "Cancelled"
+}
+export type PipelineRunStatus = {
+    pipelineId: string;
+    processor: string;
+    strategy: string;
+    status: PipelineRunState;
+    complete: boolean;
+    succeeded: boolean;
+    cancelRequested: boolean;
+    progress: PipelineRunProgress;
+    startedBy?: string | null;
+    created?: string | null;
+    modified?: string | null;
+    scheduledFor?: string | null;
+    error?: PipelineRunError | null;
+    summary?: PipelineRunSummary | null;
+};
+export type PipelineRunSummary = {
+    [key: string]: unknown;
+};
 export type PipelineState = {
     status: PipelineStatus;
     childPipeline?: string | null;
@@ -35,6 +107,11 @@ export type PipelineState = {
     schedule?: string | null;
     backgroundState?: PipelineBackgroundState | null;
     isChildPipeline: boolean;
+    cancelRequested: boolean;
+    concurrencyKey?: string | null;
+    userKey?: string | null;
+    created?: string | null;
+    modified?: string | null;
 };
 export declare enum PipelineStatus {
     NOT_STARTED = "NotStarted",
@@ -43,7 +120,8 @@ export declare enum PipelineStatus {
     WAITING = "Waiting",
     SCHEDULED = "Scheduled",
     COMPLETED = "Completed",
-    FAILED = "Failed"
+    FAILED = "Failed",
+    CANCELLED = "Cancelled"
 }
 export type ProblemDetails = {
     type?: string | null;
@@ -134,6 +212,8 @@ export type QueuedItem = {
     note?: string | null;
     claimedBy?: string | null;
     claimedUntil?: string | null;
+    ownerNode?: string | null;
+    ownerHeartbeat?: string | null;
 };
 export type StepInfo = {
     icon: string;
@@ -146,6 +226,43 @@ export declare enum StepStatus {
     COMPLETE = "Complete",
     ERROR = "Error"
 }
+export type CancelPipelineData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/umbraco/jumoo/api/v1/processing/CancelPipeline/{id}';
+};
+export type CancelPipelineErrors = {
+    /**
+     * Bad Request
+     */
+    400: ProblemDetails;
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+    /**
+     * Forbidden
+     */
+    403: ProblemDetails;
+    /**
+     * Not Found
+     */
+    404: unknown;
+    /**
+     * Conflict
+     */
+    409: ProblemDetails;
+};
+export type CancelPipelineError = CancelPipelineErrors[keyof CancelPipelineErrors];
+export type CancelPipelineResponses = {
+    /**
+     * Accepted
+     */
+    202: unknown;
+};
 export type ClearPipelineData = {
     body?: never;
     path: {
@@ -190,6 +307,10 @@ export type CreatePipelineErrors = {
      * Not Found
      */
     404: unknown;
+    /**
+     * Conflict
+     */
+    409: PipelineConflictProblemDetails;
 };
 export type CreatePipelineError = CreatePipelineErrors[keyof CreatePipelineErrors];
 export type CreatePipelineResponses = {
@@ -340,6 +461,40 @@ export type ListPipelinesByStrategyResponses = {
     200: Array<Pipeline>;
 };
 export type ListPipelinesByStrategyResponse = ListPipelinesByStrategyResponses[keyof ListPipelinesByStrategyResponses];
+export type PipelineStatusData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/umbraco/jumoo/api/v1/processing/PipelineStatus/{id}';
+};
+export type PipelineStatusErrors = {
+    /**
+     * Bad Request
+     */
+    400: ProblemDetails;
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+    /**
+     * Forbidden
+     */
+    403: ProblemDetails;
+    /**
+     * Not Found
+     */
+    404: unknown;
+};
+export type PipelineStatusError = PipelineStatusErrors[keyof PipelineStatusErrors];
+export type PipelineStatusResponses = {
+    /**
+     * OK
+     */
+    200: PipelineRunStatus;
+};
+export type PipelineStatusResponse = PipelineStatusResponses[keyof PipelineStatusResponses];
 export type ProcessPipelineData = {
     body?: never;
     path: {
@@ -359,6 +514,10 @@ export type ProcessPipelineErrors = {
      * The resource is protected and requires an authentication token
      */
     401: unknown;
+    /**
+     * Conflict
+     */
+    409: PipelineConflictProblemDetails;
 };
 export type ProcessPipelineError = ProcessPipelineErrors[keyof ProcessPipelineErrors];
 export type ProcessPipelineResponses = {
@@ -400,6 +559,38 @@ export type ReattachPipelineResponses = {
     200: Pipeline;
 };
 export type ReattachPipelineResponse = ReattachPipelineResponses[keyof ReattachPipelineResponses];
+export type StartPipelineData = {
+    body?: PipelineRunRequest;
+    path?: never;
+    query?: never;
+    url: '/umbraco/jumoo/api/v1/processing/StartPipeline';
+};
+export type StartPipelineErrors = {
+    /**
+     * Bad Request
+     */
+    400: ProblemDetails;
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+    /**
+     * Not Found
+     */
+    404: PipelineRunRejected;
+    /**
+     * Conflict
+     */
+    409: PipelineRunRejected;
+};
+export type StartPipelineError = StartPipelineErrors[keyof StartPipelineErrors];
+export type StartPipelineResponses = {
+    /**
+     * Accepted
+     */
+    202: PipelineRunStarted;
+};
+export type StartPipelineResponse = StartPipelineResponses[keyof StartPipelineResponses];
 export type UpdatePipelineData = {
     body?: ProcessingOptions;
     path: {
@@ -417,6 +608,10 @@ export type UpdatePipelineErrors = {
      * The resource is protected and requires an authentication token
      */
     401: unknown;
+    /**
+     * Conflict
+     */
+    409: PipelineConflictProblemDetails;
 };
 export type UpdatePipelineError = UpdatePipelineErrors[keyof UpdatePipelineErrors];
 export type UpdatePipelineResponses = {

package/dist/api/types.gen.js

@@ -1,4 +1,20 @@
 // This file is auto-generated by @hey-api/openapi-ts
+export var PipelineRunRejectedReason;
+(function (PipelineRunRejectedReason) {
+    PipelineRunRejectedReason["NOT_FOUND"] = "NotFound";
+    PipelineRunRejectedReason["ALREADY_RUNNING"] = "AlreadyRunning";
+    PipelineRunRejectedReason["INVALID"] = "Invalid";
+})(PipelineRunRejectedReason || (PipelineRunRejectedReason = {}));
+export var PipelineRunState;
+(function (PipelineRunState) {
+    PipelineRunState["QUEUED"] = "Queued";
+    PipelineRunState["RUNNING"] = "Running";
+    PipelineRunState["SCHEDULED"] = "Scheduled";
+    PipelineRunState["WAITING"] = "Waiting";
+    PipelineRunState["COMPLETED"] = "Completed";
+    PipelineRunState["FAILED"] = "Failed";
+    PipelineRunState["CANCELLED"] = "Cancelled";
+})(PipelineRunState || (PipelineRunState = {}));
 export var PipelineStatus;
 (function (PipelineStatus) {
     PipelineStatus["NOT_STARTED"] = "NotStarted";
@@ -8,6 +24,7 @@ export var PipelineStatus;
     PipelineStatus["SCHEDULED"] = "Scheduled";
     PipelineStatus["COMPLETED"] = "Completed";
     PipelineStatus["FAILED"] = "Failed";
+    PipelineStatus["CANCELLED"] = "Cancelled";
 })(PipelineStatus || (PipelineStatus = {}));
 export var StepStatus;
 (function (StepStatus) {

package/dist/lang/files/en.d.ts

@@ -13,6 +13,14 @@ declare const _default: {
         method: string;
         stack: string;
     };
+    jumooProcConflict: {
+        headline: string;
+        message: string;
+        status: string;
+        startedBy: string;
+        started: string;
+        progress: string;
+    };
     jumooProcBackground: {
         completed: string;
         error: string;

package/dist/lang/files/en.js

@@ -13,6 +13,14 @@ export default {
         method: 'Method',
         stack: 'Stack',
     },
+    jumooProcConflict: {
+        headline: 'Already running',
+        message: 'Another process is already running for this target. Wait for it to finish, or cancel it, then try again.',
+        status: 'Status',
+        startedBy: 'Started by',
+        started: 'Started',
+        progress: 'Progress',
+    },
     jumooProcBackground: {
         completed: 'This process has completed in the background',
         error: 'This process has errored in the background',

package/dist/pipeline/components/background.element.js

@@ -13,6 +13,7 @@ let JumooPipelineBackgroundElement = class JumooPipelineBackgroundElement extend
             case PipelineStatus.COMPLETED:
                 return this.renderComplete();
             case PipelineStatus.FAILED:
+            case PipelineStatus.CANCELLED:
                 return this.renderError();
             default:
                 return html `${this.renderBackgroundBanner()} ${this.renderProgress()}`;

package/dist/pipeline/components/pipeline-list.element.js

@@ -35,6 +35,7 @@ let JumooProcessingPipelineList = class JumooProcessingPipelineList extends UmbL
             PipelineStatus.RUNNING,
             PipelineStatus.COMPLETED,
             PipelineStatus.FAILED,
+            PipelineStatus.CANCELLED,
         ];
         this._modalPath = '';
         this.status = PipelineStatus.WAITING;

package/dist/pipeline/index.d.ts

@@ -5,4 +5,5 @@ export * from './pipeline.element.js';
 export * from './pipeline.context.js';
 export * from './pipeline.repository.js';
 export * from './pipeline.source.js';
+export * from './pipeline-conflict.js';
 export * from './pipelines.context.js';

package/dist/pipeline/index.js

@@ -5,4 +5,5 @@ export * from './pipeline.element.js';
 export * from './pipeline.context.js';
 export * from './pipeline.repository.js';
 export * from './pipeline.source.js';
+export * from './pipeline-conflict.js';
 export * from './pipelines.context.js';

package/dist/pipeline/pipeline-conflict.d.ts

@@ -0,0 +1,31 @@
+import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+import type { PipelineRunStatus } from '../api';
+/**
+ * @description a pipeline that couldn't be created or resumed because another one holds its
+ * concurrency key (the server's 409 `PipelineConflictProblemDetails`).
+ */
+export interface PipelineConflict {
+    /** the pipeline holding the key */
+    runningPipelineId: string;
+    /** the key that is held */
+    concurrencyKey: string;
+    /** the server's message */
+    detail?: string | null;
+    /** the holder's status, when the current user can see it */
+    holder?: PipelineRunStatus;
+}
+/**
+ * @description reads the 409 "already running" body off an error, whether it is the raw
+ * problem details the generated client throws or the `UmbApiError` tryExecute wraps it in.
+ * @param error the error from a request.
+ * @returns the conflict, or undefined for any other error.
+ */
+export declare function getPipelineConflict(error: unknown): PipelineConflict | undefined;
+/**
+ * @description tryExecute, except a 409 "already running" comes back as the error without a
+ * notification, so the caller can show it inline. Every other error notifies as normal.
+ * @param host the host the request (and any notification) belongs to.
+ * @param promise the request.
+ * @returns the response, as tryExecute returns it.
+ */
+export declare function tryExecuteAllowingConflict<T>(host: UmbControllerHost, promise: Promise<T>): Promise<import("@umbraco-cms/backoffice/resources").UmbApiResponse<T>>;

package/dist/pipeline/pipeline-conflict.js

@@ -0,0 +1,42 @@
+import { tryExecute, UmbApiError } from '@umbraco-cms/backoffice/resources';
+/**
+ * @description reads the 409 "already running" body off an error, whether it is the raw
+ * problem details the generated client throws or the `UmbApiError` tryExecute wraps it in.
+ * @param error the error from a request.
+ * @returns the conflict, or undefined for any other error.
+ */
+export function getPipelineConflict(error) {
+    const body = UmbApiError.isUmbApiError(error) ? error.problemDetails : error;
+    if (!body || typeof body !== 'object')
+        return undefined;
+    const problem = body;
+    if (problem.status !== 409 || typeof problem.runningPipelineId !== 'string')
+        return undefined;
+    return {
+        runningPipelineId: problem.runningPipelineId,
+        concurrencyKey: typeof problem.concurrencyKey === 'string' ? problem.concurrencyKey : '',
+        detail: typeof problem.detail === 'string' ? problem.detail : undefined,
+    };
+}
+/**
+ * @description tryExecute, except a 409 "already running" comes back as the error without a
+ * notification, so the caller can show it inline. Every other error notifies as normal.
+ * @param host the host the request (and any notification) belongs to.
+ * @param promise the request.
+ * @returns the response, as tryExecute returns it.
+ */
+export async function tryExecuteAllowingConflict(host, promise) {
+    let conflict;
+    const response = await tryExecute(host, promise.catch((error) => {
+        if (!getPipelineConflict(error))
+            throw error;
+        conflict = error;
+        return undefined;
+    }));
+    if (!conflict)
+        return response;
+    const problem = conflict;
+    return {
+        error: new UmbApiError(problem.detail ?? problem.title ?? 'Conflict', 409, null, problem),
+    };
+}

package/dist/pipeline/pipeline.context.d.ts

@@ -1,7 +1,7 @@
 import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
 import { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
 import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
-import { PipelineState, ProcessingMessage, ProcessingOptions, ProcessingResults } from '@jumoo/processing';
+import { PipelineState, ProcessingMessage, ProcessingOptions, ProcessingResults, PipelineConflict } from '@jumoo/processing';
 /**
  * @description context for keeping pipeline status and progress as we do things.
  */
@@ -13,6 +13,11 @@ export declare class PipelineContext extends UmbControllerBase {
     readonly results: import("rxjs").Observable<ProcessingResults | undefined>;
     readonly message: import("rxjs").Observable<ProcessingMessage | undefined>;
     readonly backgroundState: import("rxjs").Observable<PipelineState | undefined>;
+    /**
+     * @description set when the pipeline couldn't be created or resumed because another one
+     * holds its concurrency key - "already running".
+     */
+    readonly conflict: import("rxjs").Observable<PipelineConflict | undefined>;
     constructor(host: UmbControllerHost);
     private isMessage;
     private isState;

package/dist/pipeline/pipeline.context.js

@@ -9,11 +9,11 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _PipelineContext_instances, _PipelineContext_repository, _PipelineContext_hubContext, _PipelineContext_pipeline, _PipelineContext_state, _PipelineContext_options, _PipelineContext_results, _PipelineContext_message, _PipelineContext_backgroundState, _PipelineContext_clientId, _PipelineContext_hasConnectedBefore, _PipelineContext_onClientIdChanged, _PipelineContext_isInFlight, _PipelineContext_trigger, _PipelineContext_close, _PipelineContext_finalized, _PipelineContext_valid, _PipelineContext_pending;
+var _PipelineContext_instances, _PipelineContext_repository, _PipelineContext_hubContext, _PipelineContext_pipeline, _PipelineContext_state, _PipelineContext_options, _PipelineContext_results, _PipelineContext_message, _PipelineContext_backgroundState, _PipelineContext_conflict, _PipelineContext_clientId, _PipelineContext_hasConnectedBefore, _PipelineContext_onClientIdChanged, _PipelineContext_isInFlight, _PipelineContext_setConflict, _PipelineContext_trigger, _PipelineContext_close, _PipelineContext_finalized, _PipelineContext_valid, _PipelineContext_pending;
 import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
 import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
 import { UmbBooleanState, UmbObjectState } from '@umbraco-cms/backoffice/observable-api';
-import { PipelineStatus, PipelineRepository, ProcessingSignalRContext, } from '@jumoo/processing';
+import { PipelineStatus, PipelineRepository, ProcessingSignalRContext, getPipelineConflict, } from '@jumoo/processing';
 /**
  * @description context for keeping pipeline status and progress as we do things.
  */
@@ -35,6 +35,12 @@ export class PipelineContext extends UmbControllerBase {
         this.message = __classPrivateFieldGet(this, _PipelineContext_message, "f").asObservable();
         _PipelineContext_backgroundState.set(this, new UmbObjectState(undefined));
         this.backgroundState = __classPrivateFieldGet(this, _PipelineContext_backgroundState, "f").asObservable();
+        _PipelineContext_conflict.set(this, new UmbObjectState(undefined));
+        /**
+         * @description set when the pipeline couldn't be created or resumed because another one
+         * holds its concurrency key - "already running".
+         */
+        this.conflict = __classPrivateFieldGet(this, _PipelineContext_conflict, "f").asObservable();
         // tracks the SignalR connection id ourselves, alongside the hub context's own clientId
         // observable, so #onClientIdChanged can tell "first connect" (nothing to reattach - there's
         // no prior, now-dead connection) apart from "changed after already having one" (a genuine
@@ -86,8 +92,13 @@ export class PipelineContext extends UmbControllerBase {
         return message !== undefined;
     }
     async createPipeline(processor, strategy, options) {
-        const pipeline = await __classPrivateFieldGet(this, _PipelineContext_repository, "f").create(processor, strategy, options);
-        __classPrivateFieldGet(this, _PipelineContext_pipeline, "f").setValue(pipeline);
+        __classPrivateFieldGet(this, _PipelineContext_conflict, "f").setValue(undefined);
+        const { data, error } = await __classPrivateFieldGet(this, _PipelineContext_repository, "f").tryCreate(processor, strategy, options);
+        if (error) {
+            await __classPrivateFieldGet(this, _PipelineContext_instances, "m", _PipelineContext_setConflict).call(this, error);
+            return;
+        }
+        __classPrivateFieldGet(this, _PipelineContext_pipeline, "f").setValue(data);
     }
     async loadPipeline(id) {
         const pipeline = await __classPrivateFieldGet(this, _PipelineContext_repository, "f").Get(id);
@@ -113,7 +124,11 @@ export class PipelineContext extends UmbControllerBase {
         if (!__classPrivateFieldGet(this, _PipelineContext_pipeline, "f").value)
             return;
         const clientId = __classPrivateFieldGet(this, _PipelineContext_hubContext, "f")?.getClientId() ?? null;
-        const response = await __classPrivateFieldGet(this, _PipelineContext_repository, "f").process(__classPrivateFieldGet(this, _PipelineContext_pipeline, "f").value, clientId);
+        const { data: response, error } = await __classPrivateFieldGet(this, _PipelineContext_repository, "f").tryProcess(__classPrivateFieldGet(this, _PipelineContext_pipeline, "f").value, clientId);
+        if (error) {
+            await __classPrivateFieldGet(this, _PipelineContext_instances, "m", _PipelineContext_setConflict).call(this, error);
+            return undefined;
+        }
         if (response?.state) {
             __classPrivateFieldGet(this, _PipelineContext_state, "f").setValue(response.state);
         }
@@ -128,7 +143,9 @@ export class PipelineContext extends UmbControllerBase {
     async updateOptions(options) {
         if (!__classPrivateFieldGet(this, _PipelineContext_pipeline, "f").value)
             return;
-        const response = await __classPrivateFieldGet(this, _PipelineContext_repository, "f").update(__classPrivateFieldGet(this, _PipelineContext_pipeline, "f").value, options);
+        const { data: response, error } = await __classPrivateFieldGet(this, _PipelineContext_repository, "f").tryUpdate(__classPrivateFieldGet(this, _PipelineContext_pipeline, "f").value, options);
+        if (error)
+            await __classPrivateFieldGet(this, _PipelineContext_instances, "m", _PipelineContext_setConflict).call(this, error);
         if (response?.options) {
             console.debug('update: pipeline.options', response);
             __classPrivateFieldGet(this, _PipelineContext_options, "f").setValue(response.options);
@@ -140,7 +157,9 @@ export class PipelineContext extends UmbControllerBase {
     async saveOptions() {
         if (!__classPrivateFieldGet(this, _PipelineContext_pipeline, "f").value)
             return;
-        const response = await __classPrivateFieldGet(this, _PipelineContext_repository, "f").update(__classPrivateFieldGet(this, _PipelineContext_pipeline, "f").value, __classPrivateFieldGet(this, _PipelineContext_options, "f").value);
+        const { data: response, error } = await __classPrivateFieldGet(this, _PipelineContext_repository, "f").tryUpdate(__classPrivateFieldGet(this, _PipelineContext_pipeline, "f").value, __classPrivateFieldGet(this, _PipelineContext_options, "f").value);
+        if (error)
+            await __classPrivateFieldGet(this, _PipelineContext_instances, "m", _PipelineContext_setConflict).call(this, error);
         if (response?.options) {
             console.debug('save:pipeline.options', response);
             __classPrivateFieldGet(this, _PipelineContext_options, "f").setValue(response.options);
@@ -217,7 +236,7 @@ export class PipelineContext extends UmbControllerBase {
         __classPrivateFieldGet(this, _PipelineContext_pending, "f").setValue(__classPrivateFieldGet(this, _PipelineContext_options, "f").value);
     }
 }
-_PipelineContext_repository = new WeakMap(), _PipelineContext_hubContext = new WeakMap(), _PipelineContext_pipeline = new WeakMap(), _PipelineContext_state = new WeakMap(), _PipelineContext_options = new WeakMap(), _PipelineContext_results = new WeakMap(), _PipelineContext_message = new WeakMap(), _PipelineContext_backgroundState = new WeakMap(), _PipelineContext_clientId = new WeakMap(), _PipelineContext_hasConnectedBefore = new WeakMap(), _PipelineContext_trigger = new WeakMap(), _PipelineContext_close = new WeakMap(), _PipelineContext_finalized = new WeakMap(), _PipelineContext_valid = new WeakMap(), _PipelineContext_pending = new WeakMap(), _PipelineContext_instances = new WeakSet(), _PipelineContext_onClientIdChanged = 
+_PipelineContext_repository = new WeakMap(), _PipelineContext_hubContext = new WeakMap(), _PipelineContext_pipeline = new WeakMap(), _PipelineContext_state = new WeakMap(), _PipelineContext_options = new WeakMap(), _PipelineContext_results = new WeakMap(), _PipelineContext_message = new WeakMap(), _PipelineContext_backgroundState = new WeakMap(), _PipelineContext_conflict = new WeakMap(), _PipelineContext_clientId = new WeakMap(), _PipelineContext_hasConnectedBefore = new WeakMap(), _PipelineContext_trigger = new WeakMap(), _PipelineContext_close = new WeakMap(), _PipelineContext_finalized = new WeakMap(), _PipelineContext_valid = new WeakMap(), _PipelineContext_pending = new WeakMap(), _PipelineContext_instances = new WeakSet(), _PipelineContext_onClientIdChanged = 
 /**
  * @description called whenever the SignalR connection id changes - which includes the very
  * first connect, where there's nothing to reattach yet, and a reconnect, where a pipeline
@@ -255,6 +274,22 @@ async function _PipelineContext_onClientIdChanged(clientId) {
         default:
             return false;
     }
+}, _PipelineContext_setConflict = 
+/**
+ * @description records a 409 "already running", with the holder's status when the user can
+ * see it.
+ * @param error the error from a create, process or update.
+ * @returns true when it was a conflict.
+ */
+async function _PipelineContext_setConflict(error) {
+    const conflict = getPipelineConflict(error);
+    if (!conflict)
+        return false;
+    __classPrivateFieldGet(this, _PipelineContext_conflict, "f").setValue(conflict);
+    const holder = await __classPrivateFieldGet(this, _PipelineContext_repository, "f").getRunStatus(conflict.runningPipelineId);
+    if (holder)
+        __classPrivateFieldGet(this, _PipelineContext_conflict, "f").setValue({ ...conflict, holder });
+    return true;
 };
 export default PipelineContext;
 export const JUMOO_PROCESSING_CONTEXT = new UmbContextToken('JumooPipelineContext');

package/dist/pipeline/pipeline.element.d.ts

@@ -9,6 +9,8 @@ import { ProcessingOptions } from '@jumoo/processing';
  * @fires pipeline-waiting - when the pipeline is waiting for user input
  * @fires pipeline-last-action - when the pipeline is on the last action
  * @fires pipeline-status - the current status of the pipeline.
+ * @fires pipeline-conflict - when the pipeline can't be created or resumed because another
+ * process is already running for the same target (detail is the PipelineConflict).
  */
 export declare class JumooPipelineElement extends UmbLitElement {
     private context?;
@@ -35,6 +37,7 @@ export declare class JumooPipelineElement extends UmbLitElement {
     private results;
     private message;
     private backgroundState;
+    private conflict;
     constructor();
     connectedCallback(): void;
     private process;
@@ -57,6 +60,7 @@ export declare class JumooPipelineElement extends UmbLitElement {
      */
     private onLastAction;
     render(): import("lit-html").TemplateResult<1>;
+    private renderConflict;
     private renderDebug;
     private renderStatus;
     private renderBackground;

package/dist/pipeline/pipeline.element.js

@@ -16,6 +16,8 @@ import { PipelineStatus, JUMOO_PROCESSING_CONTEXT, } from '@jumoo/processing';
  * @fires pipeline-waiting - when the pipeline is waiting for user input
  * @fires pipeline-last-action - when the pipeline is on the last action
  * @fires pipeline-status - the current status of the pipeline.
+ * @fires pipeline-conflict - when the pipeline can't be created or resumed because another
+ * process is already running for the same target (detail is the PipelineConflict).
  */
 let JumooPipelineElement = class JumooPipelineElement extends UmbLitElement {
     constructor() {
@@ -73,6 +75,17 @@ let JumooPipelineElement = class JumooPipelineElement extends UmbLitElement {
             this.observe(this.context.results, (results) => {
                 this.results = results;
             });
+            this.observe(this.context.conflict, (conflict) => {
+                const isNew = conflict && !this.conflict;
+                this.conflict = conflict;
+                if (isNew) {
+                    this.dispatchEvent(new CustomEvent('pipeline-conflict', {
+                        bubbles: true,
+                        composed: true,
+                        detail: conflict,
+                    }));
+                }
+            });
         });
     }
     connectedCallback() {
@@ -139,7 +152,52 @@ let JumooPipelineElement = class JumooPipelineElement extends UmbLitElement {
         this.fireEvent('pipeline-last-action');
     }
     render() {
-        return html `${this.renderStatus()}${this.renderDebug()}`;
+        return html `${this.conflict ? this.renderConflict(this.conflict) : this.renderStatus()}${this.renderDebug()}`;
+    }
+    renderConflict(conflict) {
+        const holder = conflict.holder;
+        return html `<div class="conflict">
+			<div class="header">
+				<uui-icon name="icon-alert"></uui-icon>
+				<h3>
+					<umb-localize key="jumooProcConflict_headline">Already running</umb-localize>
+				</h3>
+			</div>
+			<p>
+				<umb-localize key="jumooProcConflict_message">
+					Another process is already running for this target. Wait for it to finish, or
+					cancel it, then try again.
+				</umb-localize>
+			</p>
+			${holder
+            ? html `<dl>
+							<dt><umb-localize key="jumooProcConflict_status">Status</umb-localize></dt>
+							<dd>${holder.status}</dd>
+							${holder.startedBy
+                ? html `<dt>
+												<umb-localize key="jumooProcConflict_startedBy"
+													>Started by</umb-localize
+												>
+											</dt>
+											<dd>${holder.startedBy}</dd>`
+                : nothing}
+							${holder.created
+                ? html `<dt>
+												<umb-localize key="jumooProcConflict_started"
+													>Started</umb-localize
+												>
+											</dt>
+											<dd>
+												${this.localize.date(holder.created, { dateStyle: 'medium', timeStyle: 'short' })}
+											</dd>`
+                : nothing}
+							<dt>
+								<umb-localize key="jumooProcConflict_progress">Progress</umb-localize>
+							</dt>
+							<dd>${Math.round(holder.progress.percentage)}%</dd>
+						</dl>`
+            : nothing}
+		</div>`;
     }
     renderDebug() {
         return this.debug
@@ -155,6 +213,7 @@ let JumooPipelineElement = class JumooPipelineElement extends UmbLitElement {
             case PipelineStatus.RUNNING:
                 return this.renderSteps();
             case PipelineStatus.FAILED:
+            case PipelineStatus.CANCELLED:
                 return this.renderFail();
             case PipelineStatus.BACKGROUND:
                 return this.renderBackground();
@@ -219,6 +278,40 @@ JumooPipelineElement.styles = css `
 		umb-extension-slot {
 			height: 100%;
 		}
+
+		.conflict {
+			padding: var(--uui-size-space-5);
+			border: 1px solid var(--uui-color-warning-standalone);
+			border-left-width: 4px;
+			border-radius: var(--uui-border-radius);
+			background-color: var(--uui-color-surface);
+		}
+
+		.conflict .header {
+			display: flex;
+			align-items: center;
+			gap: var(--uui-size-space-3);
+			color: var(--uui-color-warning-standalone);
+		}
+
+		.conflict h3 {
+			margin: 0;
+		}
+
+		.conflict dl {
+			display: grid;
+			grid-template-columns: max-content 1fr;
+			gap: var(--uui-size-space-2) var(--uui-size-space-5);
+			margin: var(--uui-size-space-4) 0;
+		}
+
+		.conflict dt {
+			font-weight: bold;
+		}
+
+		.conflict dd {
+			margin: 0;
+		}
 	`;
 __decorate([
     property({ type: String })
@@ -253,6 +346,9 @@ __decorate([
 __decorate([
     state()
 ], JumooPipelineElement.prototype, "backgroundState", void 0);
+__decorate([
+    state()
+], JumooPipelineElement.prototype, "conflict", void 0);
 JumooPipelineElement = __decorate([
     customElement('jumoo-pipeline')
 ], JumooPipelineElement);

package/dist/pipeline/pipeline.repository.d.ts

@@ -14,6 +14,32 @@ export declare class PipelineRepository extends UmbControllerBase {
     getProcessors(): Promise<string[]>;
     Get(id: string): Promise<import("@jumoo/processing").Pipeline>;
     create(processor: string, strategy: string, options: ProcessingOptions | undefined): Promise<string>;
+    /**
+     * @description create, returning the whole response rather than just the id, so the caller
+     * can tell a 409 "already running" (see getPipelineConflict) from any other failure.
+     */
+    tryCreate(processor: string, strategy: string, options: ProcessingOptions | undefined): Promise<import("@umbraco-cms/backoffice/resources").UmbApiResponse<{
+        data: string;
+        request: Request;
+        response: Response;
+    }>>;
+    /**
+     * @description process, returning the whole response - see tryCreate.
+     */
+    tryProcess(id: string, clientId: string | null): Promise<import("@umbraco-cms/backoffice/resources").UmbApiResponse<{
+        data: import("@jumoo/processing").Pipeline;
+        request: Request;
+        response: Response;
+    }>>;
+    /**
+     * @description update, returning the whole response - see tryCreate.
+     */
+    tryUpdate(id: string, body: ProcessingOptions | undefined): Promise<import("@umbraco-cms/backoffice/resources").UmbApiResponse<{
+        data: import("@jumoo/processing").ProcessingOptionsResults;
+        request: Request;
+        response: Response;
+    }>>;
+    getRunStatus(id: string): Promise<import("@jumoo/processing").PipelineRunStatus>;
     complete(id: string): Promise<void>;
     getResults(id: string): Promise<import("@jumoo/processing").ProcessingResults>;
     listPipelines(status: PipelineStatus): Promise<import("@jumoo/processing").Pipeline[]>;

package/dist/pipeline/pipeline.repository.js

@@ -29,6 +29,28 @@ export class PipelineRepository extends UmbControllerBase {
     async create(processor, strategy, options) {
         return (await this.source.create(processor, strategy, options)).data;
     }
+    /**
+     * @description create, returning the whole response rather than just the id, so the caller
+     * can tell a 409 "already running" (see getPipelineConflict) from any other failure.
+     */
+    async tryCreate(processor, strategy, options) {
+        return await this.source.create(processor, strategy, options);
+    }
+    /**
+     * @description process, returning the whole response - see tryCreate.
+     */
+    async tryProcess(id, clientId) {
+        return await this.source.process(id, clientId);
+    }
+    /**
+     * @description update, returning the whole response - see tryCreate.
+     */
+    async tryUpdate(id, body) {
+        return await this.source.update(id, body);
+    }
+    async getRunStatus(id) {
+        return (await this.source.getRunStatus(id)).data;
+    }
     async complete(id) {
         console.debug('complete', id);
     }

package/dist/pipeline/pipeline.source.d.ts

@@ -3,6 +3,10 @@ import { PipelineStatus } from '../api';
 export declare class PipelineSource {
     private readonly host;
     constructor(host: UmbControllerHost);
+    /**
+     * @description a 409 (another pipeline holds this one's concurrency key, so it can't resume)
+     * is returned as the error without a notification - see getPipelineConflict.
+     */
     process(id: string, clientId: string | null): Promise<import("@umbraco-cms/backoffice/resources").UmbApiResponse<{
         data: import("..").Pipeline;
         request: Request;
@@ -19,6 +23,10 @@ export declare class PipelineSource {
         request: Request;
         response: Response;
     }>>;
+    /**
+     * @description a 409 (the new options' concurrency key is held) is returned as the error
+     * without a notification - see getPipelineConflict.
+     */
     update(id: string, body: any): Promise<import("@umbraco-cms/backoffice/resources").UmbApiResponse<{
         data: import("..").ProcessingOptionsResults;
         request: Request;
@@ -42,7 +50,8 @@ export declare class PipelineSource {
     /**
      *
      * @param strategy alias of the strategy to use for the pipeline
-     * @returns
+     * @returns the new pipeline's id. A 409 (another pipeline holds its concurrency key) is
+     * returned as the error without a notification - see getPipelineConflict.
      */
     create(processor: string, strategy: string, options: any): Promise<import("@umbraco-cms/backoffice/resources").UmbApiResponse<{
         data: string;
@@ -68,6 +77,15 @@ export declare class PipelineSource {
         request: Request;
         response: Response;
     }>>;
+    /**
+     * @param id guid id of the pipeline
+     * @returns its run status, or an error (without a notification) if the user can't see it.
+     */
+    getRunStatus(id: string): Promise<import("@umbraco-cms/backoffice/resources").UmbApiResponse<{
+        data: import("..").PipelineRunStatus;
+        request: Request;
+        response: Response;
+    }>>;
     listPiplelines(status: PipelineStatus): Promise<import("@umbraco-cms/backoffice/resources").UmbApiResponse<{
         data: import("..").Pipeline[];
         request: Request;

package/dist/pipeline/pipeline.source.js

@@ -1,11 +1,16 @@
 import { tryExecute } from '@umbraco-cms/backoffice/resources';
 import { PipelinesService } from '../api';
+import { tryExecuteAllowingConflict } from './pipeline-conflict.js';
 export class PipelineSource {
     constructor(host) {
         this.host = host;
     }
+    /**
+     * @description a 409 (another pipeline holds this one's concurrency key, so it can't resume)
+     * is returned as the error without a notification - see getPipelineConflict.
+     */
     async process(id, clientId) {
-        const result = await tryExecute(this.host, PipelinesService.processPipeline({
+        const result = await tryExecuteAllowingConflict(this.host, PipelinesService.processPipeline({
             path: { id: id },
             query: { clientId: clientId ?? undefined },
         }));
@@ -24,8 +29,12 @@ export class PipelineSource {
         }));
         return result;
     }
+    /**
+     * @description a 409 (the new options' concurrency key is held) is returned as the error
+     * without a notification - see getPipelineConflict.
+     */
     async update(id, body) {
-        return await tryExecute(this.host, PipelinesService.updatePipeline({
+        return await tryExecuteAllowingConflict(this.host, PipelinesService.updatePipeline({
             path: { id: id },
             body: body,
         }));
@@ -44,10 +53,11 @@ export class PipelineSource {
     /**
      *
      * @param strategy alias of the strategy to use for the pipeline
-     * @returns
+     * @returns the new pipeline's id. A 409 (another pipeline holds its concurrency key) is
+     * returned as the error without a notification - see getPipelineConflict.
      */
     async create(processor, strategy, options) {
-        return await tryExecute(this.host, PipelinesService.createPipeline({
+        return await tryExecuteAllowingConflict(this.host, PipelinesService.createPipeline({
             body: {
                 alias: processor,
                 strategy: strategy,
@@ -73,6 +83,15 @@ export class PipelineSource {
             path: { id: id },
         }));
     }
+    /**
+     * @param id guid id of the pipeline
+     * @returns its run status, or an error (without a notification) if the user can't see it.
+     */
+    async getRunStatus(id) {
+        return await tryExecute(this.host, PipelinesService.pipelineStatus({ path: { id: id } }), {
+            disableNotifications: true,
+        });
+    }
     async listPiplelines(status) {
         return await tryExecute(this.host, PipelinesService.listPipelines({ path: { status: status } }));
     }

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@jumoo/processing",
 	"licence": "custom",
-	"version": "17.4.3-prerelease.2",
+	"version": "17.4.3-prerelease.4",
 	"type": "module",
 	"description": "Jumoo processing library",
 	"exports": {