@vertesia/client 0.42.2

package/src/store/WorkflowsApi.ts

@@ -0,0 +1,121 @@
+import { ApiTopic, ClientBase } from '@vertesia/api-fetch-client';
+import { ActivityCatalog, CreateWorkflowRulePayload, DSLWorkflowDefinition, DSLWorkflowSpec, ExecuteWorkflowPayload, ListWorkflowRunsPayload, ListWorkflowRunsResponse, WorkflowDefinitionRef, WorkflowRule, WorkflowRuleItem, WorkflowRunWithDetails } from '@vertesia/common';
+
+export class WorkflowsApi extends ApiTopic {
+
+    constructor(parent: ClientBase) {
+        super(parent, "/api/v1/workflows");
+    }
+
+    getActivityCatalog(): Promise<ActivityCatalog> {
+        return this.get("/activity-catalog");
+    }
+
+    listRuns(documentId: string, eventName: string, ruleId: string): Promise<ListWorkflowRunsResponse> {
+        return this.post(`/runs`, { payload: { documentId, eventName, ruleId } });
+    }
+
+    searchRuns(payload: ListWorkflowRunsPayload): Promise<ListWorkflowRunsResponse> {
+        return this.post(`/runs`, { payload: payload });
+    }
+
+    getRunDetails(runId: string, workflowId: string): Promise<WorkflowRunWithDetails> {
+        return this.get(`/runs/${workflowId}/${runId}`, { query: { workflowId } });
+    }
+
+    terminate(workflowId: string, runId: string, reason?: string): Promise<{ message: string }> {
+        return this.post(`/runs/${workflowId}/${runId}/terminate`, { payload: { reason } });
+    }
+
+    cancel(workflowId: string, runId: string, reason?: string): Promise<{ message: string }> {
+        return this.post(`/runs/${workflowId}/${runId}/cancel`, { payload: { reason } });
+    }
+
+    execute(name: string, payload: ExecuteWorkflowPayload = {}): Promise<{ runIds: string[] }> {
+        return this.post(`/execute/${name}`, { payload });
+    }
+
+    rules = new WorkflowsRulesApi(this);
+    definitions = new WorkflowsDefinitionApi(this);
+
+}
+
+
+export class WorkflowsRulesApi extends ApiTopic {
+
+    constructor(parent: WorkflowsApi) {
+        super(parent, "/rules");
+    }
+
+
+    list(): Promise<WorkflowRuleItem[]> {
+        return this.get("/");
+    }
+
+
+    retrieve(id: string): Promise<WorkflowRule> {
+        return this.get(`/${id}`);
+    }
+
+    update(id: string, payload: any): Promise<WorkflowRule> {
+        return this.put(`/${id}`, {
+            payload
+        });
+    }
+
+    create(payload: CreateWorkflowRulePayload): Promise<WorkflowRule> {
+        return this.post("/", {
+            payload
+        });
+    }
+
+    delete(id: string) {
+        return this.del(`/${id}`);
+    }
+
+
+    execute(id: string, objectIds?: string[], vars?: Record<string, any>): Promise<{ runIds: string[] }> {
+        const payload: ExecuteWorkflowPayload = {
+            objectIds,
+            vars
+        };
+        return this.post(`/${id}/execute`, { payload });
+    }
+
+}
+
+export class WorkflowsDefinitionApi extends ApiTopic {
+
+    //model: DSLWorkflowDefinition;
+
+    constructor(parent: WorkflowsApi) {
+        super(parent, "/definitions");
+    }
+
+    list(): Promise<WorkflowDefinitionRef[]> {
+        return this.get("/");
+    }
+
+
+    retrieve(id: string): Promise<DSLWorkflowDefinition> {
+        return this.get(`/${id}`);
+    }
+
+    update(id: string, payload: any): Promise<DSLWorkflowDefinition> {
+        return this.put(`/${id}`, {
+            payload
+        });
+    }
+
+    create(payload: DSLWorkflowSpec): Promise<DSLWorkflowDefinition> {
+        return this.post("/", {
+            payload
+        });
+    }
+
+    delete(id: string) {
+        return this.del(`/${id}`);
+    }
+
+
+}

package/src/store/client.ts

@@ -0,0 +1,61 @@
+import { AbstractFetchClient, RequestError } from "@vertesia/api-fetch-client";
+import { BulkOperationPayload, BulkOperationResult } from "@vertesia/common";
+import { CommandsApi } from "./CommandsApi.js";
+import { ZenoClientNotFoundError } from "./errors.js";
+import { FilesApi } from "./FilesApi.js";
+import { ObjectsApi } from "./ObjectsApi.js";
+import { TypesApi } from "./TypesApi.js";
+import { WorkflowsApi } from "./WorkflowsApi.js";
+
+export interface ZenoClientProps {
+    serverUrl?: string;
+    apikey?: string;
+    onRequest?: (request: Request) => void;
+    onResponse?: (response: Response) => void;
+}
+
+function ensureDefined(serverUrl: string | undefined) {
+    if (!serverUrl) {
+        throw new Error("zeno client serverUrl is required");
+    }
+    return serverUrl;
+}
+
+export class ZenoClient extends AbstractFetchClient<ZenoClient> {
+
+    constructor(
+        opts: ZenoClientProps = {}
+    ) {
+        super(ensureDefined(opts.serverUrl));
+        if (opts.apikey) {
+            this.withApiKey(opts.apikey);
+        }
+        this.onRequest = opts.onRequest;
+        this.onResponse = opts.onResponse;
+        this.errorFactory = (err: RequestError) => {
+            if (err.status === 404) {
+                return new ZenoClientNotFoundError(err.request, err);
+            } else {
+                return err;
+            }
+        }
+    }
+
+    withApiKey(apiKey: string | null) {
+        return this.withAuthCallback(
+            apiKey ? () => Promise.resolve(`Bearer ${apiKey}`) : undefined
+        );
+    }
+
+    runOperation(payload: BulkOperationPayload): Promise<BulkOperationResult> {
+        return this.post("/api/v1/operations", {
+            payload
+        });
+    }
+
+    objects = new ObjectsApi(this);
+    types = new TypesApi(this);
+    workflows = new WorkflowsApi(this);
+    files = new FilesApi(this);
+    commands = new CommandsApi(this);
+}

package/src/store/errors.ts

@@ -0,0 +1,7 @@
+import { RequestError } from "@vertesia/api-fetch-client";
+
+export class ZenoClientNotFoundError extends RequestError {
+    constructor(req: Request, error: RequestError) {
+        super("Resource not found: " + error.message, req, 404, error.payload);
+    }
+}

package/src/store/index.ts

@@ -0,0 +1,6 @@
+export * from "./client.js";
+export * from "./CommandsApi.js";
+export * from "./ObjectsApi.js";
+export * from "./TypesApi.js";
+export * from "./WorkflowsApi.js";
+