apps/dashboard/src/api/workflows.ts - next - githubmirror/novu

apps/dashboard/src/api/workflows.ts
211 строк5 KB
Dima Grossman
feat(dashboard): replace legacy local studio with Local environment mode fixes NV-8242 (#11847)
08 июл 2026, 19:44
08 июл 2026, 19:44e390d5f
import type {
  CreateWorkflowDto,
  DuplicateWorkflowDto,
  IEnvironment,
  ListWorkflowResponse,
  PatchWorkflowDto,
  SyncWorkflowDto,
  UpdateWorkflowDto,
  WorkflowResponseDto,
  WorkflowTestDataResponseDto,
} from '@novu/shared';
import { delV2, getV2, patchV2, post, postV2, putV2 } from './api.client';

export const getWorkflow = async ({
  environment,
  workflowSlug,
  targetEnvironmentId,
}: {
  environment: IEnvironment;
  workflowSlug?: string;
  targetEnvironmentId?: string;
}): Promise<WorkflowResponseDto> => {
  const { data } = await getV2<{ data: WorkflowResponseDto }>(
    `/workflows/${workflowSlug}?${targetEnvironmentId ? `environmentId=${targetEnvironmentId}` : ''}`,
    {
      environment,
    }
  );

  return data;
};

export const getWorkflows = async ({
  environment,
  limit,
  query,
  offset,
  orderBy,
  orderDirection,
  tags,
  status,
}: {
  environment: IEnvironment;
  limit: number;
  offset: number;
  query: string;
  orderBy?: string;
  orderDirection?: string;
  tags?: string[];
  status?: string[];
}): Promise<ListWorkflowResponse> => {
  const params = new URLSearchParams({
    limit: limit.toString(),
    offset: offset.toString(),
    query,
  });

  if (orderBy) {
    params.append('orderBy', orderBy);
  }

  if (orderDirection) {
    params.append('orderDirection', orderDirection.toUpperCase());
  }

  if (tags && tags.length > 0) {
    for (const tag of tags) {
      params.append('tags[]', tag);
    }
  }

  if (status && status.length > 0) {
    for (const s of status) {
      params.append('status[]', s);
    }
  }

  const { data } = await getV2<{ data: ListWorkflowResponse }>(`/workflows?${params.toString()}`, { environment });

  return data;
};

export const getWorkflowTestData = async ({
  environment,
  workflowSlug,
}: {
  environment: IEnvironment;
  workflowSlug?: string;
}): Promise<WorkflowTestDataResponseDto> => {
  const { data } = await getV2<{ data: WorkflowTestDataResponseDto }>(`/workflows/${workflowSlug}/test-data`, {
    environment,
  });

  return data;
};

export async function triggerWorkflow({
  environment,
  name,
  payload,
  to,
  context,
  overrides,
  bridgeUrl,
  controls,
}: {
  environment: IEnvironment;
  name: string;
  payload: unknown;
  to: unknown;
  context?: unknown;
  overrides?: Record<string, unknown>;
  /** Stateless bridge URL for triggering non-persisted (local mode) workflows. */
  bridgeUrl?: string;
  /** Per-step control values for stateless triggers (job-scoped, not persisted). */
  controls?: { steps: Record<string, Record<string, unknown>> };
}) {
  return post<{ data: { transactionId?: string } }>(`/events/trigger`, {
    environment,
    body: {
      name,
      to,
      payload: { ...(payload ?? {}), __source: (payload as any)?.__source ?? 'dashboard' },
      context: context ?? undefined,
      ...(overrides && Object.keys(overrides).length > 0 ? { overrides } : {}),
      ...(bridgeUrl ? { bridgeUrl } : {}),
      ...(controls ? { controls } : {}),
    },
  });
}

export async function createWorkflow({
  environment,
  workflow,
}: {
  environment: IEnvironment;
  workflow: CreateWorkflowDto;
}) {
  return postV2<{ data: WorkflowResponseDto }>(`/workflows`, { environment, body: workflow });
}

export async function syncWorkflow({
  environment,
  workflowSlug,
  payload,
}: {
  environment: IEnvironment;
  workflowSlug: string;
  payload: SyncWorkflowDto;
}) {
  return putV2<{ data: WorkflowResponseDto }>(`/workflows/${workflowSlug}/sync`, { environment, body: payload });
}

export const updateWorkflow = async ({
  environment,
  workflow,
  workflowSlug,
}: {
  environment: IEnvironment;
  workflow: UpdateWorkflowDto;
  workflowSlug: string;
}): Promise<WorkflowResponseDto> => {
  const { data } = await putV2<{ data: WorkflowResponseDto }>(`/workflows/${workflowSlug}`, {
    environment,
    body: workflow,
  });

  return data;
};

export const deleteWorkflow = async ({
  environment,
  workflowSlug,
}: {
  environment: IEnvironment;
  workflowSlug: string;
}): Promise<void> => {
  return delV2(`/workflows/${workflowSlug}`, { environment });
};

export const patchWorkflow = async ({
  environment,
  workflow,
  workflowSlug,
}: {
  environment: IEnvironment;
  workflow: PatchWorkflowDto;
  workflowSlug: string;
}): Promise<WorkflowResponseDto> => {
  const res = await patchV2<{ data: WorkflowResponseDto }>(`/workflows/${workflowSlug}`, {
    environment,
    body: workflow,
  });

  return res.data;
};

export const duplicateWorkflow = async ({
  environment,
  workflow,
  workflowSlug,
}: {
  environment: IEnvironment;
  workflow: DuplicateWorkflowDto;
  workflowSlug: string;
}) => {
  return postV2<{ data: WorkflowResponseDto }>(`/workflows/${workflowSlug}/duplicate`, {
    environment,
    body: workflow,
  });
};