@oronts/vendure-data-hub-plugin 0.1.1 → 0.1.3

package/dist/dashboard/hooks/api/use-entity-loaders.ts

@@ -0,0 +1,45 @@
+import { useCallback } from 'react';
+import { useQuery } from '@tanstack/react-query';
+import { api } from '@vendure/dashboard';
+import { graphql } from '../../gql';
+import { createQueryKeys } from '../../utils/query-key-factory';
+import { CACHE_TIMES } from '../../constants';
+
+const base = createQueryKeys('entity-loaders');
+const entityLoaderKeys = {
+    ...base,
+    supported: () => [...base.all, 'supported'] as const,
+};
+
+const supportedEntitiesDocument = graphql(`
+    query DataHubSupportedEntitiesApi {
+        dataHubSupportedEntities {
+            code
+            name
+            description
+            supportedOperations
+            adapterCode
+        }
+    }
+`);
+
+export function useEntityLoaders() {
+    const { data: entities, ...rest } = useQuery({
+        queryKey: entityLoaderKeys.supported(),
+        queryFn: () => api.query(supportedEntitiesDocument).then(res => res.dataHubSupportedEntities),
+        staleTime: CACHE_TIMES.ADAPTER_CATALOG,
+    });
+
+    const getLoaderAdapterCode = useCallback(
+        (entityType: string): string | undefined => {
+            return entities?.find(e => e.code === entityType)?.adapterCode;
+        },
+        [entities],
+    );
+
+    return {
+        ...rest,
+        entities: entities ?? [],
+        getLoaderAdapterCode,
+    };
+}

package/dist/dashboard/hooks/api/use-hooks.ts

@@ -0,0 +1,68 @@
+import { useQuery, useMutation } from '@tanstack/react-query';
+import { api } from '@vendure/dashboard';
+import { graphql } from '../../gql';
+import { createMutationErrorHandler } from './mutation-helpers';
+import { createQueryKeys } from '../../utils/query-key-factory';
+import { POLLING_INTERVALS } from '../../constants';
+import type { JsonObject } from '../../types';
+
+const base = createQueryKeys('pipelineHooks');
+const hookKeys = {
+    ...base,
+    events: (limit?: number) => [...base.all, 'events', limit] as const,
+};
+
+const hooksDocument = graphql(`
+    query DataHubPipelineHooksApi($pipelineId: ID!) {
+        dataHubPipelineHooks(pipelineId: $pipelineId)
+    }
+`);
+
+const hookTestDocument = graphql(`
+    mutation RunDataHubHookTestApi($pipelineId: ID!, $stage: String!, $payload: JSON) {
+        runDataHubHookTest(pipelineId: $pipelineId, stage: $stage, payload: $payload)
+    }
+`);
+
+const eventsDocument = graphql(`
+    query DataHubEventsApi($limit: Int) {
+        dataHubEvents(limit: $limit) {
+            name
+            createdAt
+            payload
+        }
+    }
+`);
+
+export function usePipelineHooks(pipelineId: string | undefined) {
+    return useQuery({
+        queryKey: hookKeys.detail(pipelineId ?? ''),
+        queryFn: () =>
+            api.query(hooksDocument, { pipelineId: pipelineId! }).then((res) => res.dataHubPipelineHooks),
+        enabled: !!pipelineId,
+    });
+}
+
+export function useEvents(limit: number = 50) {
+    return useQuery({
+        queryKey: hookKeys.events(limit),
+        queryFn: () => api.query(eventsDocument, { limit }).then((res) => res.dataHubEvents),
+        refetchInterval: POLLING_INTERVALS.EVENTS,
+    });
+}
+
+export function useTestHook() {
+    return useMutation({
+        mutationFn: ({
+            pipelineId,
+            stage,
+            payload,
+        }: {
+            pipelineId: string;
+            stage: string;
+            payload?: JsonObject;
+        }) =>
+            api.mutate(hookTestDocument, { pipelineId, stage, payload }).then((res) => res.runDataHubHookTest),
+        onError: createMutationErrorHandler('test hook'),
+    });
+}

package/dist/dashboard/hooks/api/use-logs.ts

@@ -0,0 +1,102 @@
+import { useQuery } from '@tanstack/react-query';
+import { api } from '@vendure/dashboard';
+import { graphql } from '../../gql';
+import { createQueryKeys } from '../../utils/query-key-factory';
+import { POLLING_INTERVALS } from '../../constants';
+import type { DataHubLogListOptions } from '../../types';
+
+const base = createQueryKeys('logs');
+const logKeys = {
+    ...base,
+    list: (options?: DataHubLogListOptions) => [...base.lists(), options] as const,
+    stats: (pipelineId?: string) => [...base.all, 'stats', pipelineId] as const,
+    recent: (limit?: number) => [...base.all, 'recent', limit] as const,
+};
+
+const logsDocument = graphql(`
+    query DataHubLogsApi($options: DataHubLogListOptions) {
+        dataHubLogs(options: $options) {
+            items {
+                id
+                createdAt
+                level
+                message
+                stepKey
+                context
+                metadata
+                pipelineId
+                pipeline {
+                    id
+                    code
+                    name
+                }
+                runId
+                durationMs
+                recordsProcessed
+                recordsFailed
+            }
+            totalItems
+        }
+    }
+`);
+
+const logStatsDocument = graphql(`
+    query DataHubLogStatsApi($pipelineId: ID) {
+        dataHubLogStats(pipelineId: $pipelineId) {
+            total
+            byLevel {
+                DEBUG
+                INFO
+                WARN
+                ERROR
+            }
+            errorsToday
+            warningsToday
+            avgDurationMs
+        }
+    }
+`);
+
+const recentLogsDocument = graphql(`
+    query DataHubRecentLogsApi($limit: Int) {
+        dataHubRecentLogs(limit: $limit) {
+            id
+            createdAt
+            level
+            message
+            stepKey
+            pipelineId
+            pipeline {
+                id
+                code
+                name
+            }
+            runId
+            durationMs
+            recordsProcessed
+            recordsFailed
+        }
+    }
+`);
+
+export function useLogs(options?: DataHubLogListOptions) {
+    return useQuery({
+        queryKey: logKeys.list(options),
+        queryFn: () => api.query(logsDocument, { options }).then((res) => res.dataHubLogs),
+    });
+}
+
+export function useLogStats(pipelineId?: string) {
+    return useQuery({
+        queryKey: logKeys.stats(pipelineId),
+        queryFn: () => api.query(logStatsDocument, { pipelineId }).then((res) => res.dataHubLogStats),
+    });
+}
+
+export function useRecentLogs(limit: number = 10, options?: { refetchInterval?: number | false }) {
+    return useQuery({
+        queryKey: logKeys.recent(limit),
+        queryFn: () => api.query(recentLogsDocument, { limit }).then((res) => res.dataHubRecentLogs),
+        refetchInterval: options?.refetchInterval ?? POLLING_INTERVALS.LIVE_LOGS,
+    });
+}

package/dist/dashboard/hooks/api/use-pipeline-runs.ts

@@ -0,0 +1,222 @@
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { api } from '@vendure/dashboard';
+import { graphql } from '../../gql';
+import { createMutationErrorHandler } from './mutation-helpers';
+import { createQueryKeys } from '../../utils/query-key-factory';
+import { POLLING_INTERVALS, RUN_STATUS } from '../../constants';
+import { queueKeys } from './use-queues';
+import type { DataHubPipelineRunListOptions, JsonObject } from '../../types';
+
+const base = createQueryKeys('pipelineRuns');
+export const runKeys = {
+    ...base,
+    list: (pipelineId?: string, options?: DataHubPipelineRunListOptions) =>
+        [...base.lists(), pipelineId, options] as const,
+    errors: (runId: string) => [...base.all, 'errors', runId] as const,
+    errorAudits: (errorId: string) => [...base.all, 'errorAudits', errorId] as const,
+};
+
+const runsListDocument = graphql(`
+    query DataHubPipelineRunsApi($pipelineId: ID, $options: DataHubPipelineRunListOptions) {
+        dataHubPipelineRuns(pipelineId: $pipelineId, options: $options) {
+            items {
+                id
+                status
+                startedAt
+                finishedAt
+                metrics
+            }
+            totalItems
+        }
+    }
+`);
+
+const runDetailDocument = graphql(`
+    query DataHubPipelineRunDetailApi($id: ID!) {
+        dataHubPipelineRun(id: $id) {
+            id
+            status
+            startedAt
+            finishedAt
+            metrics
+            error
+            startedByUserId
+            pipeline {
+                id
+                code
+                name
+            }
+        }
+    }
+`);
+
+const runErrorsDocument = graphql(`
+    query DataHubRunErrorsApi($runId: ID!) {
+        dataHubRunErrors(runId: $runId) {
+            id
+            stepKey
+            message
+            payload
+            stackTrace
+        }
+    }
+`);
+
+const cancelRunDocument = graphql(`
+    mutation CancelDataHubPipelineRunApi($id: ID!) {
+        cancelDataHubPipelineRun(id: $id) {
+            id
+            status
+        }
+    }
+`);
+
+const retryErrorDocument = graphql(`
+    mutation RetryDataHubRecordApi($errorId: ID!, $patch: JSON) {
+        retryDataHubRecord(errorId: $errorId, patch: $patch)
+    }
+`);
+
+const approveGateDocument = graphql(`
+    mutation ApproveDataHubGateApi($runId: ID!, $stepKey: String!) {
+        approveDataHubGate(runId: $runId, stepKey: $stepKey) {
+            success
+            message
+            run {
+                id
+                status
+            }
+        }
+    }
+`);
+
+const rejectGateDocument = graphql(`
+    mutation RejectDataHubGateApi($runId: ID!, $stepKey: String!) {
+        rejectDataHubGate(runId: $runId, stepKey: $stepKey) {
+            success
+            message
+            run {
+                id
+                status
+            }
+        }
+    }
+`);
+
+const errorAuditsDocument = graphql(`
+    query DataHubRecordRetryAuditsApi($errorId: ID!) {
+        dataHubRecordRetryAudits(errorId: $errorId) {
+            id
+            createdAt
+            userId
+            previousPayload
+            patch
+            resultingPayload
+        }
+    }
+`);
+
+export function usePipelineRuns(pipelineId?: string, options?: DataHubPipelineRunListOptions) {
+    return useQuery({
+        queryKey: runKeys.list(pipelineId, options),
+        queryFn: () =>
+            api
+                .query(runsListDocument, { pipelineId, options })
+                .then((res) => res.dataHubPipelineRuns),
+        refetchInterval: POLLING_INTERVALS.PIPELINE_RUNS,
+    });
+}
+
+export function usePipelineRun(id: string | undefined) {
+    return useQuery({
+        queryKey: runKeys.detail(id ?? ''),
+        queryFn: () =>
+            api.query(runDetailDocument, { id: id! }).then((res) => res.dataHubPipelineRun),
+        enabled: !!id,
+        refetchInterval: (query) => {
+            const status = query.state.data?.status;
+            return status === RUN_STATUS.RUNNING || status === RUN_STATUS.PENDING || status === RUN_STATUS.PAUSED
+                ? POLLING_INTERVALS.ACTIVE_RUN : false;
+        },
+    });
+}
+
+export function useRunErrors(runId: string | undefined) {
+    return useQuery({
+        queryKey: runKeys.errors(runId ?? ''),
+        queryFn: () =>
+            api.query(runErrorsDocument, { runId: runId! }).then((res) => res.dataHubRunErrors),
+        enabled: !!runId,
+    });
+}
+
+export function useErrorAudits(errorId: string | undefined) {
+    return useQuery({
+        queryKey: runKeys.errorAudits(errorId ?? ''),
+        queryFn: () =>
+            api.query(errorAuditsDocument, { errorId: errorId! }).then((res) => res.dataHubRecordRetryAudits),
+        enabled: !!errorId,
+    });
+}
+
+export function useCancelRun() {
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: (id: string) =>
+            api.mutate(cancelRunDocument, { id }).then((res) => res.cancelDataHubPipelineRun),
+        onSuccess: (data) => {
+            queryClient.invalidateQueries({ queryKey: runKeys.lists() });
+            if (data?.id) {
+                queryClient.invalidateQueries({ queryKey: runKeys.detail(String(data.id)) });
+            }
+        },
+        onError: createMutationErrorHandler('cancel pipeline run'),
+    });
+}
+
+export function useRetryError() {
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: ({ errorId, patch }: { errorId: string; patch?: JsonObject }) =>
+            api.mutate(retryErrorDocument, { errorId, patch }).then((res) => res.retryDataHubRecord),
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: runKeys.all });
+            queryClient.invalidateQueries({ queryKey: queueKeys.all });
+        },
+        onError: createMutationErrorHandler('retry record'),
+    });
+}
+
+export function useApproveGate() {
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: ({ runId, stepKey }: { runId: string; stepKey: string }) =>
+            api.mutate(approveGateDocument, { runId, stepKey }).then((res) => res.approveDataHubGate),
+        onSuccess: (data) => {
+            queryClient.invalidateQueries({ queryKey: runKeys.lists() });
+            if (data?.run?.id) {
+                queryClient.invalidateQueries({ queryKey: runKeys.detail(String(data.run.id)) });
+            }
+        },
+        onError: createMutationErrorHandler('approve gate'),
+    });
+}
+
+export function useRejectGate() {
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: ({ runId, stepKey }: { runId: string; stepKey: string }) =>
+            api.mutate(rejectGateDocument, { runId, stepKey }).then((res) => res.rejectDataHubGate),
+        onSuccess: (data) => {
+            queryClient.invalidateQueries({ queryKey: runKeys.lists() });
+            if (data?.run?.id) {
+                queryClient.invalidateQueries({ queryKey: runKeys.detail(String(data.run.id)) });
+            }
+        },
+        onError: createMutationErrorHandler('reject gate'),
+    });
+}