magicbell-js 1.2.0 → 1.4.0

package/src/project-client/services/workflows/models/get-run-response-status.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const getRunResponseStatus = z.lazy(() => {
+  return z.object({
+    completedAt: z.string().optional(),
+    error: z.string().optional(),
+    nextStep: z.number().optional(),
+    startedAt: z.string().optional(),
+    state: z.number().optional(),
+  });
+});
+
+/**
+ *
+ * @typedef  {GetRunResponseStatus} getRunResponseStatus
+ * @property {string}
+ * @property {string}
+ * @property {number}
+ * @property {string}
+ * @property {number}
+ */
+export type GetRunResponseStatus = z.infer<typeof getRunResponseStatus>;
+
+/**
+ * The shape of the model mapping from the api schema into the application shape.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const getRunResponseStatusResponse = z.lazy(() => {
+  return z
+    .object({
+      completed_at: z.string().optional(),
+      error: z.string().optional(),
+      next_step: z.number().optional(),
+      started_at: z.string().optional(),
+      state: z.number().optional(),
+    })
+    .transform((data) => ({
+      completedAt: data['completed_at'],
+      error: data['error'],
+      nextStep: data['next_step'],
+      startedAt: data['started_at'],
+      state: data['state'],
+    }));
+});
+
+/**
+ * The shape of the model mapping from the application shape into the api schema.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const getRunResponseStatusRequest = z.lazy(() => {
+  return z
+    .object({
+      completedAt: z.string().optional(),
+      error: z.string().optional(),
+      nextStep: z.number().optional(),
+      startedAt: z.string().optional(),
+      state: z.number().optional(),
+    })
+    .transform((data) => ({
+      completed_at: data['completedAt'],
+      error: data['error'],
+      next_step: data['nextStep'],
+      started_at: data['startedAt'],
+      state: data['state'],
+    }));
+});

package/src/project-client/services/workflows/models/get-run-response.ts

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+
+import {
+  GetRunResponseStatus,
+  getRunResponseStatus,
+  getRunResponseStatusRequest,
+  getRunResponseStatusResponse,
+} from './get-run-response-status.js';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const getRunResponse = z.lazy(() => {
+  return z.object({
+    createdAt: z.string().optional(),
+    id: z.string().optional(),
+    status: getRunResponseStatus.optional(),
+    workflowKey: z.string().optional(),
+  });
+});
+
+/**
+ *
+ * @typedef  {GetRunResponse} getRunResponse
+ * @property {string}
+ * @property {string}
+ * @property {GetRunResponseStatus}
+ * @property {string}
+ */
+export type GetRunResponse = z.infer<typeof getRunResponse>;
+
+/**
+ * The shape of the model mapping from the api schema into the application shape.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const getRunResponseResponse = z.lazy(() => {
+  return z
+    .object({
+      created_at: z.string().optional(),
+      id: z.string().optional(),
+      status: getRunResponseStatusResponse.optional(),
+      workflow_key: z.string().optional(),
+    })
+    .transform((data) => ({
+      createdAt: data['created_at'],
+      id: data['id'],
+      status: data['status'],
+      workflowKey: data['workflow_key'],
+    }));
+});
+
+/**
+ * The shape of the model mapping from the application shape into the api schema.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const getRunResponseRequest = z.lazy(() => {
+  return z
+    .object({
+      createdAt: z.string().optional(),
+      id: z.string().optional(),
+      status: getRunResponseStatusRequest.optional(),
+      workflowKey: z.string().optional(),
+    })
+    .transform((data) => ({
+      created_at: data['createdAt'],
+      id: data['id'],
+      status: data['status'],
+      workflow_key: data['workflowKey'],
+    }));
+});

package/src/project-client/services/workflows/models/index.ts

@@ -0,0 +1,9 @@
+export type { CreateRunResponse } from './create-run-response.js';
+export type { ExecuteWorkflowRequest } from './execute-workflow-request.js';
+export type { GetRunResponse } from './get-run-response.js';
+export type { GetRunResponseStatus } from './get-run-response-status.js';
+export type { Steps } from './steps.js';
+export type { WorkflowDefinition } from './workflow-definition.js';
+export type { WorkflowRun } from './workflow-run.js';
+export type { WorkflowRunCollection } from './workflow-run-collection.js';
+export type { WorkflowRunStatus } from './workflow-run-status.js';

package/src/project-client/services/workflows/models/steps.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const steps = z.lazy(() => {
+  return z.object({
+    command: z.string().regex(/^[A-Za-z0-9\_\:]+$/),
+    if: z.string().optional().nullable(),
+    input: z.any().optional().nullable(),
+  });
+});
+
+/**
+ *
+ * @typedef  {Steps} steps
+ * @property {string}
+ * @property {string}
+ * @property {any}
+ */
+export type Steps = z.infer<typeof steps>;
+
+/**
+ * The shape of the model mapping from the api schema into the application shape.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const stepsResponse = z.lazy(() => {
+  return z
+    .object({
+      command: z.string().regex(/^[A-Za-z0-9\_\:]+$/),
+      if: z.string().optional().nullable(),
+      input: z.any().optional().nullable(),
+    })
+    .transform((data) => ({
+      command: data['command'],
+      if: data['if'],
+      input: data['input'],
+    }));
+});
+
+/**
+ * The shape of the model mapping from the application shape into the api schema.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const stepsRequest = z.lazy(() => {
+  return z
+    .object({
+      command: z.string().regex(/^[A-Za-z0-9\_\:]+$/),
+      if: z.string().optional().nullable(),
+      input: z.any().optional().nullable(),
+    })
+    .transform((data) => ({
+      command: data['command'],
+      if: data['if'],
+      input: data['input'],
+    }));
+});

package/src/project-client/services/workflows/models/workflow-definition.ts

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+
+import { Steps, steps, stepsRequest, stepsResponse } from './steps.js';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const workflowDefinition = z.lazy(() => {
+  return z.object({
+    disabled: z.boolean().optional(),
+    key: z
+      .string()
+      .min(3)
+      .regex(/^[A-Za-z0-9\_\.\-\:]+$/),
+    steps: z.array(steps),
+  });
+});
+
+/**
+ *
+ * @typedef  {WorkflowDefinition} workflowDefinition
+ * @property {boolean}
+ * @property {string}
+ * @property {Steps[]}
+ */
+export type WorkflowDefinition = z.infer<typeof workflowDefinition>;
+
+/**
+ * The shape of the model mapping from the api schema into the application shape.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const workflowDefinitionResponse = z.lazy(() => {
+  return z
+    .object({
+      disabled: z.boolean().optional(),
+      key: z
+        .string()
+        .min(3)
+        .regex(/^[A-Za-z0-9\_\.\-\:]+$/),
+      steps: z.array(stepsResponse),
+    })
+    .transform((data) => ({
+      disabled: data['disabled'],
+      key: data['key'],
+      steps: data['steps'],
+    }));
+});
+
+/**
+ * The shape of the model mapping from the application shape into the api schema.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const workflowDefinitionRequest = z.lazy(() => {
+  return z
+    .object({
+      disabled: z.boolean().optional(),
+      key: z
+        .string()
+        .min(3)
+        .regex(/^[A-Za-z0-9\_\.\-\:]+$/),
+      steps: z.array(stepsRequest),
+    })
+    .transform((data) => ({
+      disabled: data['disabled'],
+      key: data['key'],
+      steps: data['steps'],
+    }));
+});

package/src/project-client/services/workflows/models/workflow-run-collection.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+
+import { Links, links, linksRequest, linksResponse } from '../../common/links.js';
+import { WorkflowRun, workflowRun, workflowRunRequest, workflowRunResponse } from './workflow-run.js';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const workflowRunCollection = z.lazy(() => {
+  return z.object({
+    data: z.array(workflowRun).optional(),
+    links: links.optional(),
+  });
+});
+
+/**
+ *
+ * @typedef  {WorkflowRunCollection} workflowRunCollection
+ * @property {WorkflowRun[]}
+ * @property {Links}
+ */
+export type WorkflowRunCollection = z.infer<typeof workflowRunCollection>;
+
+/**
+ * The shape of the model mapping from the api schema into the application shape.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const workflowRunCollectionResponse = z.lazy(() => {
+  return z
+    .object({
+      data: z.array(workflowRunResponse).optional(),
+      links: linksResponse.optional(),
+    })
+    .transform((data) => ({
+      data: data['data'],
+      links: data['links'],
+    }));
+});
+
+/**
+ * The shape of the model mapping from the application shape into the api schema.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const workflowRunCollectionRequest = z.lazy(() => {
+  return z
+    .object({
+      data: z.array(workflowRunRequest).optional(),
+      links: linksRequest.optional(),
+    })
+    .transform((data) => ({
+      data: data['data'],
+      links: data['links'],
+    }));
+});

package/src/project-client/services/workflows/models/workflow-run-status.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const workflowRunStatus = z.lazy(() => {
+  return z.object({
+    completedAt: z.string().optional(),
+    error: z.string().optional(),
+    nextStep: z.number().optional(),
+    startedAt: z.string().optional(),
+    state: z.number().optional(),
+  });
+});
+
+/**
+ *
+ * @typedef  {WorkflowRunStatus} workflowRunStatus
+ * @property {string}
+ * @property {string}
+ * @property {number}
+ * @property {string}
+ * @property {number}
+ */
+export type WorkflowRunStatus = z.infer<typeof workflowRunStatus>;
+
+/**
+ * The shape of the model mapping from the api schema into the application shape.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const workflowRunStatusResponse = z.lazy(() => {
+  return z
+    .object({
+      completed_at: z.string().optional(),
+      error: z.string().optional(),
+      next_step: z.number().optional(),
+      started_at: z.string().optional(),
+      state: z.number().optional(),
+    })
+    .transform((data) => ({
+      completedAt: data['completed_at'],
+      error: data['error'],
+      nextStep: data['next_step'],
+      startedAt: data['started_at'],
+      state: data['state'],
+    }));
+});
+
+/**
+ * The shape of the model mapping from the application shape into the api schema.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const workflowRunStatusRequest = z.lazy(() => {
+  return z
+    .object({
+      completedAt: z.string().optional(),
+      error: z.string().optional(),
+      nextStep: z.number().optional(),
+      startedAt: z.string().optional(),
+      state: z.number().optional(),
+    })
+    .transform((data) => ({
+      completed_at: data['completedAt'],
+      error: data['error'],
+      next_step: data['nextStep'],
+      started_at: data['startedAt'],
+      state: data['state'],
+    }));
+});

package/src/project-client/services/workflows/models/workflow-run.ts

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+
+import {
+  WorkflowRunStatus,
+  workflowRunStatus,
+  workflowRunStatusRequest,
+  workflowRunStatusResponse,
+} from './workflow-run-status.js';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const workflowRun = z.lazy(() => {
+  return z.object({
+    createdAt: z.string().optional(),
+    id: z.string().optional(),
+    status: workflowRunStatus.optional(),
+    workflowKey: z.string().optional(),
+  });
+});
+
+/**
+ *
+ * @typedef  {WorkflowRun} workflowRun
+ * @property {string}
+ * @property {string}
+ * @property {WorkflowRunStatus}
+ * @property {string}
+ */
+export type WorkflowRun = z.infer<typeof workflowRun>;
+
+/**
+ * The shape of the model mapping from the api schema into the application shape.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const workflowRunResponse = z.lazy(() => {
+  return z
+    .object({
+      created_at: z.string().optional(),
+      id: z.string().optional(),
+      status: workflowRunStatusResponse.optional(),
+      workflow_key: z.string().optional(),
+    })
+    .transform((data) => ({
+      createdAt: data['created_at'],
+      id: data['id'],
+      status: data['status'],
+      workflowKey: data['workflow_key'],
+    }));
+});
+
+/**
+ * The shape of the model mapping from the application shape into the api schema.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const workflowRunRequest = z.lazy(() => {
+  return z
+    .object({
+      createdAt: z.string().optional(),
+      id: z.string().optional(),
+      status: workflowRunStatusRequest.optional(),
+      workflowKey: z.string().optional(),
+    })
+    .transform((data) => ({
+      created_at: data['createdAt'],
+      id: data['id'],
+      status: data['status'],
+      workflow_key: data['workflowKey'],
+    }));
+});

package/src/project-client/services/workflows/workflows-service.ts

@@ -0,0 +1,172 @@
+import { z } from 'zod';
+
+import { Environment } from '../../http/environment.js';
+import { ThrowableError } from '../../http/errors/throwable-error.js';
+import { SerializationStyle } from '../../http/serialization/base-serializer.js';
+import { RequestBuilder } from '../../http/transport/request-builder.js';
+import { ContentType, HttpResponse, RequestConfig } from '../../http/types.js';
+import { BaseService } from '../base-service.js';
+import { CreateRunResponse, createRunResponseResponse } from './models/create-run-response.js';
+import { ExecuteWorkflowRequest, executeWorkflowRequestRequest } from './models/execute-workflow-request.js';
+import { GetRunResponse, getRunResponseResponse } from './models/get-run-response.js';
+import {
+  WorkflowDefinition,
+  workflowDefinitionRequest,
+  workflowDefinitionResponse,
+} from './models/workflow-definition.js';
+import { WorkflowRunCollection, workflowRunCollectionResponse } from './models/workflow-run-collection.js';
+
+export class WorkflowsService extends BaseService {
+  /**
+   * Creates or updates a workflow definition for the project
+   * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<WorkflowDefinition>>} - OK
+   */
+  async saveWorkflow(
+    body: WorkflowDefinition,
+    requestConfig?: RequestConfig,
+  ): Promise<HttpResponse<WorkflowDefinition>> {
+    const request = new RequestBuilder()
+      .setBaseUrl(requestConfig?.baseUrl || this.config.baseUrl || this.config.environment || Environment.DEFAULT)
+      .setConfig(this.config)
+      .setMethod('PUT')
+      .setPath('/workflows')
+      .setRequestSchema(workflowDefinitionRequest)
+      .addAccessTokenAuth(this.config.token, 'Bearer')
+      .setRequestContentType(ContentType.Json)
+      .addResponse({
+        schema: workflowDefinitionResponse,
+        contentType: ContentType.Json,
+        status: 200,
+      })
+      .setRetryAttempts(this.config, requestConfig)
+      .setRetryDelayMs(this.config, requestConfig)
+      .setResponseValidation(this.config, requestConfig)
+      .addHeaderParam({ key: 'Content-Type', value: 'application/json' })
+      .addBody(body)
+      .build();
+    return this.client.call<WorkflowDefinition>(request);
+  }
+
+  /**
+   * Retrieves a workflow definition by key
+   * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<WorkflowDefinition>>} - OK
+   */
+  async fetchWorkflow(requestConfig?: RequestConfig): Promise<HttpResponse<WorkflowDefinition>> {
+    const request = new RequestBuilder()
+      .setBaseUrl(requestConfig?.baseUrl || this.config.baseUrl || this.config.environment || Environment.DEFAULT)
+      .setConfig(this.config)
+      .setMethod('GET')
+      .setPath('/workflows/*')
+      .setRequestSchema(z.any())
+      .addAccessTokenAuth(this.config.token, 'Bearer')
+      .setRequestContentType(ContentType.Json)
+      .addResponse({
+        schema: workflowDefinitionResponse,
+        contentType: ContentType.Json,
+        status: 200,
+      })
+      .setRetryAttempts(this.config, requestConfig)
+      .setRetryDelayMs(this.config, requestConfig)
+      .setResponseValidation(this.config, requestConfig)
+      .build();
+    return this.client.call<WorkflowDefinition>(request);
+  }
+
+  /**
+   * Executes a workflow with the provided input parameters
+   * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<CreateRunResponse>>} - Created
+   */
+  async createWorkflowRun(
+    body: ExecuteWorkflowRequest,
+    requestConfig?: RequestConfig,
+  ): Promise<HttpResponse<CreateRunResponse>> {
+    const request = new RequestBuilder()
+      .setBaseUrl(requestConfig?.baseUrl || this.config.baseUrl || this.config.environment || Environment.DEFAULT)
+      .setConfig(this.config)
+      .setMethod('POST')
+      .setPath('/workflows/runs')
+      .setRequestSchema(executeWorkflowRequestRequest)
+      .addAccessTokenAuth(this.config.token, 'Bearer')
+      .setRequestContentType(ContentType.Json)
+      .addResponse({
+        schema: createRunResponseResponse,
+        contentType: ContentType.Json,
+        status: 201,
+      })
+      .setRetryAttempts(this.config, requestConfig)
+      .setRetryDelayMs(this.config, requestConfig)
+      .setResponseValidation(this.config, requestConfig)
+      .addHeaderParam({ key: 'Content-Type', value: 'application/json' })
+      .addBody(body)
+      .build();
+    return this.client.call<CreateRunResponse>(request);
+  }
+
+  /**
+   * Retrieves the status and details of a workflow run
+   * @param {string} runId -
+   * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<GetRunResponse>>} - OK
+   */
+  async fetchWorkflowRun(runId: string, requestConfig?: RequestConfig): Promise<HttpResponse<GetRunResponse>> {
+    const request = new RequestBuilder()
+      .setBaseUrl(requestConfig?.baseUrl || this.config.baseUrl || this.config.environment || Environment.DEFAULT)
+      .setConfig(this.config)
+      .setMethod('GET')
+      .setPath('/workflows/runs/{run_id}')
+      .setRequestSchema(z.any())
+      .addAccessTokenAuth(this.config.token, 'Bearer')
+      .setRequestContentType(ContentType.Json)
+      .addResponse({
+        schema: getRunResponseResponse,
+        contentType: ContentType.Json,
+        status: 200,
+      })
+      .setRetryAttempts(this.config, requestConfig)
+      .setRetryDelayMs(this.config, requestConfig)
+      .setResponseValidation(this.config, requestConfig)
+      .addPathParam({
+        key: 'run_id',
+        value: runId,
+      })
+      .build();
+    return this.client.call<GetRunResponse>(request);
+  }
+
+  /**
+   * Retrieves all runs for a specific workflow
+   * @param {string} workflowKey -
+   * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<WorkflowRunCollection>>} - OK
+   */
+  async listWorkflowRuns(
+    workflowKey: string,
+    requestConfig?: RequestConfig,
+  ): Promise<HttpResponse<WorkflowRunCollection>> {
+    const request = new RequestBuilder()
+      .setBaseUrl(requestConfig?.baseUrl || this.config.baseUrl || this.config.environment || Environment.DEFAULT)
+      .setConfig(this.config)
+      .setMethod('GET')
+      .setPath('/workflows/{workflow_key}/runs')
+      .setRequestSchema(z.any())
+      .addAccessTokenAuth(this.config.token, 'Bearer')
+      .setRequestContentType(ContentType.Json)
+      .addResponse({
+        schema: workflowRunCollectionResponse,
+        contentType: ContentType.Json,
+        status: 200,
+      })
+      .setRetryAttempts(this.config, requestConfig)
+      .setRetryDelayMs(this.config, requestConfig)
+      .setResponseValidation(this.config, requestConfig)
+      .addPathParam({
+        key: 'workflow_key',
+        value: workflowKey,
+      })
+      .build();
+    return this.client.call<WorkflowRunCollection>(request);
+  }
+}