[10785] Add SDK samples to all screens.

.gitignore

@@ -81,3 +81,5 @@ crashlytics-build.properties
 fabric.properties
 .DS_Store
 .env.development
+.env.development.local
+

src/core/__test__/MetadataClient.test.ts

@@ -0,0 +1,129 @@
+import { expect, describe, test, jest } from "@jest/globals";
+import { MetadataClient, taskDefinition } from "..";
+import { orkesConductorClient, OrkesApiConfig } from "../../orkes";
+
+const playConfig: Partial<OrkesApiConfig> = {
+  keyId: `${process.env.KEY_ID}`,
+  keySecret: `${process.env.KEY_SECRET}`,
+  serverUrl: `${process.env.SERVER_URL}`,
+  refreshTokenInterval: 0,
+};
+
+describe("MetadataClient", () => {
+  const clientPromise = orkesConductorClient(playConfig);
+
+  jest.setTimeout(15000);
+  test("Should register a task definition", async () => {
+    const client = await clientPromise;
+    const metadataClient = new MetadataClient(client);
+
+    const newTaskDefinition = taskDefinition({
+      name: "test_task_definition",
+      description: "New Task Definition",
+      retryCount: 4,
+      timeoutSeconds: 7200,
+      inputKeys: ["inputKey1", "inputKey2"],
+      outputKeys: ["outputKey1", "outputKey2"],
+      timeoutPolicy: "TIME_OUT_WF",
+      retryLogic: "FIXED",
+      retryDelaySeconds: 61,
+      responseTimeoutSeconds: 601,
+      concurrentExecLimit: 1,
+      inputTemplate: {
+        "inputKey1": "${workflow.input.inputKey1}",
+      },
+      rateLimitPerFrequency: 1,
+      rateLimitFrequencyInSeconds: 2,
+      pollTimeoutSeconds: 3601,
+      backoffScaleFactor: 1,
+    });
+
+    await expect(
+      metadataClient.registerTask(newTaskDefinition)
+    ).resolves.not.toThrowError();
+    const taskDefinitionFromApi = await client.metadataResource.getTaskDef(
+      newTaskDefinition.name
+    );
+
+    expect(taskDefinitionFromApi.name).toEqual(newTaskDefinition.name);
+    expect(taskDefinitionFromApi.description).toEqual(newTaskDefinition.description);
+    expect(taskDefinitionFromApi.retryCount).toEqual(newTaskDefinition.retryCount);
+    expect(taskDefinitionFromApi.timeoutSeconds).toEqual(newTaskDefinition.timeoutSeconds);
+    expect(taskDefinitionFromApi.inputKeys).toEqual(newTaskDefinition.inputKeys);
+    expect(taskDefinitionFromApi.outputKeys).toEqual(newTaskDefinition.outputKeys);
+    expect(taskDefinitionFromApi.timeoutPolicy).toEqual(newTaskDefinition.timeoutPolicy);
+    expect(taskDefinitionFromApi.retryLogic).toEqual(newTaskDefinition.retryLogic);
+    expect(taskDefinitionFromApi.retryDelaySeconds).toEqual(newTaskDefinition.retryDelaySeconds);
+    expect(taskDefinitionFromApi.responseTimeoutSeconds).toEqual(newTaskDefinition.responseTimeoutSeconds);
+    expect(taskDefinitionFromApi.concurrentExecLimit).toEqual(newTaskDefinition.concurrentExecLimit);
+    expect(taskDefinitionFromApi.inputTemplate).toEqual(newTaskDefinition.inputTemplate);
+    expect(taskDefinitionFromApi.rateLimitPerFrequency).toEqual(newTaskDefinition.rateLimitPerFrequency);
+    expect(taskDefinitionFromApi.rateLimitFrequencyInSeconds).toEqual(newTaskDefinition.rateLimitFrequencyInSeconds);
+    expect(taskDefinitionFromApi.pollTimeoutSeconds).toEqual(newTaskDefinition.pollTimeoutSeconds);
+    expect(taskDefinitionFromApi.backoffScaleFactor).toEqual(newTaskDefinition.backoffScaleFactor);
+  });
+
+  test("Should update a task definition", async () => {
+    const client = await clientPromise;
+    const metadataClient = new MetadataClient(client);
+
+    const newTaskDefinition = taskDefinition({
+      name: "test_task_definition",
+      description: "New Task Definition Update",
+      retryCount: 5,
+      timeoutSeconds: 7201,
+      inputKeys: ["inputKey1_1", "inputKey2_1"],
+      outputKeys: ["outputKey1_1", "outputKey2_2"],
+      timeoutPolicy: "TIME_OUT_WF",
+      retryLogic: "FIXED",
+      retryDelaySeconds: 62,
+      responseTimeoutSeconds: 602,
+      concurrentExecLimit: 1,
+      inputTemplate: {
+        "inputKey2": "${workflow.input.inputKey2}",
+      },
+      rateLimitPerFrequency: 1,
+      rateLimitFrequencyInSeconds: 3,
+      pollTimeoutSeconds: 3602,
+      backoffScaleFactor: 1,
+    });
+
+    await expect(
+      metadataClient.updateTask(newTaskDefinition)
+    ).resolves.not.toThrowError();
+    const taskDefinitionFromApi = await client.metadataResource.getTaskDef(
+      newTaskDefinition.name
+    );
+
+    expect(taskDefinitionFromApi.description).toEqual(newTaskDefinition.description);
+    expect(taskDefinitionFromApi.retryCount).toEqual(newTaskDefinition.retryCount);
+    expect(taskDefinitionFromApi.timeoutSeconds).toEqual(newTaskDefinition.timeoutSeconds);
+    expect(taskDefinitionFromApi.inputKeys).toEqual(newTaskDefinition.inputKeys);
+    expect(taskDefinitionFromApi.outputKeys).toEqual(newTaskDefinition.outputKeys);
+    expect(taskDefinitionFromApi.timeoutPolicy).toEqual(newTaskDefinition.timeoutPolicy);
+    expect(taskDefinitionFromApi.retryLogic).toEqual(newTaskDefinition.retryLogic);
+    expect(taskDefinitionFromApi.retryDelaySeconds).toEqual(newTaskDefinition.retryDelaySeconds);
+    expect(taskDefinitionFromApi.responseTimeoutSeconds).toEqual(newTaskDefinition.responseTimeoutSeconds);
+    expect(taskDefinitionFromApi.concurrentExecLimit).toEqual(newTaskDefinition.concurrentExecLimit);
+    expect(taskDefinitionFromApi.inputTemplate).toEqual(newTaskDefinition.inputTemplate);
+    expect(taskDefinitionFromApi.rateLimitPerFrequency).toEqual(newTaskDefinition.rateLimitPerFrequency);
+    expect(taskDefinitionFromApi.rateLimitFrequencyInSeconds).toEqual(newTaskDefinition.rateLimitFrequencyInSeconds);
+    expect(taskDefinitionFromApi.pollTimeoutSeconds).toEqual(newTaskDefinition.pollTimeoutSeconds);
+    expect(taskDefinitionFromApi.backoffScaleFactor).toEqual(newTaskDefinition.backoffScaleFactor);
+
+  });
+
+  test("Should unregister a task definition", async () => {
+    const client = await clientPromise;
+    const metadataClient = new MetadataClient(client);
+    const name ="test_task_definition";
+
+    await expect(
+      metadataClient.unregisterTask("test_task_definition")
+    ).resolves.not.toThrowError();
+
+    await expect(client.metadataResource.getTaskDef(
+      name
+    )).rejects.toThrowError();
+  })
+});

src/core/index.ts

@@ -4,3 +4,6 @@ export * from "./human";
 export * from "./sdk";
 export * from "./generators";
 export * from "./schedulerClient";
+export * from "./taskClient";
+export * from "./templateClient";
+export * from "./metadataClient";

src/core/metadataClient.ts

@@ -0,0 +1,49 @@
+import {
+  ConductorClient,
+  TaskDef,
+} from "../common";
+import { tryCatchReThrow } from "./helpers";
+
+export class MetadataClient {
+  public readonly _client: ConductorClient;
+
+  constructor(client: ConductorClient) {
+    this._client = client;
+  }
+
+  /**
+   * Unregisters an existing task definition by name
+   *
+   * @param name
+   * @returns
+   */
+  public unregisterTask(name: string): Promise<void> {
+    return tryCatchReThrow(() =>
+      this._client.metadataResource.unregisterTaskDef(name)
+    );
+  }
+
+  /**
+   * Registers a new task definition
+   *
+   * @param taskDef
+   * @returns
+   */
+  public registerTask(taskDef: TaskDef): Promise<void> {
+    return tryCatchReThrow(() =>
+      this._client.metadataResource.registerTaskDef([taskDef])
+    );
+  }
+
+  /**
+   * Update an existing task definition
+   *
+   * @param taskDef
+   * @returns
+   */
+  public updateTask(taskDef: TaskDef): Promise<void> {
+    return tryCatchReThrow(() =>
+      this._client.metadataResource.updateTaskDef(taskDef)
+    );
+  }
+}

src/core/sdk/index.ts

@@ -11,6 +11,7 @@ export * from "./setVariable";
 export * from "./simple";
 export * from "./subWorkflow";
 export * from "./switch";
+export * from "./taskDefinition";
 export * from "./terminate";
 export * from "./wait";
 export * from "./workflow";

src/core/sdk/taskDefinition.ts

@@ -0,0 +1,41 @@
+import type { TaskDef } from '../../common/open-api/models/TaskDef';
+
+export const taskDefinition = ({
+  name,
+  ownerApp = "",
+  description = "",
+  retryCount = 3,
+  timeoutSeconds = 3600,
+  inputKeys = [],
+  outputKeys = [],
+  timeoutPolicy = "TIME_OUT_WF",
+  retryLogic = "FIXED",
+  retryDelaySeconds = 60,
+  responseTimeoutSeconds = 600,
+  concurrentExecLimit = 0,
+  inputTemplate = {},
+  rateLimitPerFrequency = 0,
+  rateLimitFrequencyInSeconds = 1,
+  ownerEmail = "",
+  pollTimeoutSeconds = 3600,
+  backoffScaleFactor = 1,
+}: TaskDef) : TaskDef => ({
+  name,
+  ownerApp,
+  description,
+  retryCount,
+  timeoutSeconds,
+  inputKeys,
+  outputKeys,
+  timeoutPolicy,
+  retryLogic,
+  retryDelaySeconds,
+  responseTimeoutSeconds,
+  concurrentExecLimit,
+  inputTemplate,
+  rateLimitPerFrequency,
+  rateLimitFrequencyInSeconds,
+  ownerEmail,
+  pollTimeoutSeconds,
+  backoffScaleFactor,
+})

src/core/taskClient.ts

@@ -0,0 +1,81 @@
+import { TaskResultStatus } from "../../dist";
+import {
+  ConductorClient,
+  SearchResultTask,
+  Task,
+  TaskResult,
+} from "../common";
+import { tryCatchReThrow } from "./helpers";
+
+export class TaskClient {
+  public readonly _client: ConductorClient;
+
+  constructor(client: ConductorClient) {
+    this._client = client;
+  }
+
+  /**
+   * Searches for existing scheduler execution based on below parameters
+   *
+   * @param start
+   * @param size
+   * @param sort
+   * @param freeText
+   * @param query
+   * @returns SearchResultWorkflowScheduleExecutionModel
+   */
+  public search(
+    start: number,
+    size: number,
+    sort: string = "",
+    freeText: string,
+    query: string
+  ): Promise<SearchResultTask> {
+    return tryCatchReThrow(() =>
+      this._client.taskResource.search(
+        start,
+        size,
+        sort,
+        freeText,
+        query
+      )
+    );
+  }
+
+  /**
+   * Get an existing schedule by Id
+   * @param taskId
+   * @returns Task
+   */
+  public getTask(taskId: string): Promise<Task> {
+    return tryCatchReThrow(() =>
+      this._client.taskResource.getTask(taskId)
+    );
+  }
+
+  /**
+   * Update task result status
+   *
+   * @param workflowId
+   * @param taskReferenceName
+   * @param status
+   * @param outputData
+   * @param workerId
+   * @returns
+   */
+  public updateTaskResult(
+    workflowId: string,
+    taskReferenceName: string,
+    status: TaskResultStatus,
+    outputData: Record<string, unknown>,
+  ): Promise<TaskResult> {
+    return tryCatchReThrow(() =>
+      this._client.taskResource.updateTask(
+        workflowId,
+        taskReferenceName,
+        status,
+        outputData
+      )
+    );
+  }
+}

src/core/templateClient.ts

@@ -0,0 +1,29 @@
+import {
+  ConductorClient,
+  HumanTaskTemplate,
+} from "../common";
+import { tryCatchReThrow } from "./helpers";
+
+
+export class TemplateClient {
+  public readonly _client: ConductorClient;
+
+  constructor(client: ConductorClient) {
+    this._client = client;
+  }
+
+  /**
+   * Register a new human task template
+   *
+   * @param template
+   * @returns
+   */
+  public async registerTemplate(
+    template: HumanTaskTemplate,
+    asNewVersion: boolean = false
+  ): Promise<HumanTaskTemplate> {
+    return tryCatchReThrow(() =>
+      this._client.humanTask.saveTemplate(template, asNewVersion)
+    );
+  }
+}