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

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

@@ -0,0 +1,279 @@
+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 type {
+    DataHubPipelineListOptions,
+} from '../../types';
+import { runKeys } from './use-pipeline-runs';
+
+const base = createQueryKeys('pipelines');
+export const pipelineKeys = {
+    ...base,
+    list: (options?: DataHubPipelineListOptions) => [...base.lists(), options] as const,
+    timeline: (id: string, limit?: number) => [...base.detail(id), 'timeline', limit] as const,
+};
+
+export const pipelinesListDocument = graphql(`
+    query DataHubPipelinesForList($options: DataHubPipelineListOptions) {
+        dataHubPipelines(options: $options) {
+            items {
+                id
+                code
+                name
+                enabled
+                status
+                updatedAt
+            }
+            totalItems
+        }
+    }
+`);
+
+export const pipelineDetailDocument = graphql(`
+    query DataHubPipelineDetail($id: ID!) {
+        dataHubPipeline(id: $id) {
+            id
+            createdAt
+            updatedAt
+            code
+            name
+            enabled
+            status
+            version
+            publishedAt
+            definition
+        }
+    }
+`);
+
+export const createPipelineDocument = graphql(`
+    mutation CreateDataHubPipelineApi($input: CreateDataHubPipelineInput!) {
+        createDataHubPipeline(input: $input) {
+            id
+            code
+            name
+        }
+    }
+`);
+
+export const updatePipelineDocument = graphql(`
+    mutation UpdateDataHubPipelineApi($input: UpdateDataHubPipelineInput!) {
+        updateDataHubPipeline(input: $input) {
+            id
+            code
+            name
+        }
+    }
+`);
+
+export const deletePipelineDocument = graphql(`
+    mutation DeleteDataHubPipelineApi($id: ID!) {
+        deleteDataHubPipeline(id: $id) {
+            result
+        }
+    }
+`);
+
+const runPipelineDocument = graphql(`
+    mutation RunDataHubPipelineApi($pipelineId: ID!) {
+        startDataHubPipelineRun(pipelineId: $pipelineId) {
+            id
+            status
+        }
+    }
+`);
+
+export const validatePipelineDefinitionDocument = graphql(`
+    query ValidateDataHubPipelineDefinitionApi($definition: JSON!, $level: String) {
+        validateDataHubPipelineDefinition(definition: $definition, level: $level) {
+            isValid
+            issues {
+                message
+                stepKey
+                reason
+                field
+            }
+            warnings {
+                message
+                stepKey
+                reason
+                field
+            }
+            level
+        }
+    }
+`);
+
+const dryRunPipelineDocument = graphql(`
+    mutation DryRunDataHubPipelineApi($pipelineId: ID!) {
+        startDataHubPipelineDryRun(pipelineId: $pipelineId) {
+            metrics
+            notes
+            sampleRecords { step before after }
+        }
+    }
+`);
+
+export const pipelineTimelineDocument = graphql(`
+    query DataHubPipelineTimelineApi($pipelineId: ID!, $limit: Int) {
+        dataHubPipelineTimeline(pipelineId: $pipelineId, limit: $limit) {
+            revision {
+                id
+                createdAt
+                version
+                type
+                commitMessage
+                authorName
+                changesSummary
+                isLatest
+                isCurrent
+            }
+            runCount
+            lastRunAt
+            lastRunStatus
+        }
+    }
+`);
+
+const submitPipelineForReviewDocument = graphql(`
+    mutation SubmitDataHubPipelineForReviewApi($id: ID!) {
+        submitDataHubPipelineForReview(id: $id) {
+            id
+            status
+        }
+    }
+`);
+
+const approvePipelineDocument = graphql(`
+    mutation ApproveDataHubPipelineApi($id: ID!) {
+        approveDataHubPipeline(id: $id) {
+            id
+            status
+        }
+    }
+`);
+
+const rejectPipelineDocument = graphql(`
+    mutation RejectDataHubPipelineReviewApi($id: ID!) {
+        rejectDataHubPipelineReview(id: $id) {
+            id
+            status
+        }
+    }
+`);
+
+const publishPipelineDocument = graphql(`
+    mutation PublishDataHubPipelineApi($id: ID!) {
+        publishDataHubPipeline(id: $id) {
+            id
+            status
+            publishedAt
+        }
+    }
+`);
+
+const archivePipelineDocument = graphql(`
+    mutation ArchiveDataHubPipelineApi($id: ID!) {
+        archiveDataHubPipeline(id: $id) {
+            id
+            status
+        }
+    }
+`);
+
+export function usePipelines(options?: DataHubPipelineListOptions) {
+    return useQuery({
+        queryKey: pipelineKeys.list(options),
+        queryFn: () =>
+            api.query(pipelinesListDocument, { options }).then((res) => res.dataHubPipelines),
+    });
+}
+
+export function useRunPipeline() {
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: (pipelineId: string) =>
+            api.mutate(runPipelineDocument, { pipelineId }).then((res) => res.startDataHubPipelineRun),
+        onSuccess: (_data, pipelineId) => {
+            queryClient.invalidateQueries({ queryKey: runKeys.lists() });
+            queryClient.invalidateQueries({ queryKey: pipelineKeys.detail(pipelineId) });
+        },
+        onError: createMutationErrorHandler('run pipeline'),
+    });
+}
+
+interface ValidatePipelineDefinitionInput {
+    definition: Record<string, unknown>;
+    level?: string;
+}
+
+export function useValidatePipelineDefinition() {
+    return useMutation({
+        mutationFn: ({ definition, level }: ValidatePipelineDefinitionInput) =>
+            api
+                .query(validatePipelineDefinitionDocument, { definition, level })
+                .then((res) => res.validateDataHubPipelineDefinition),
+        onError: createMutationErrorHandler('validate pipeline definition'),
+    });
+}
+
+export function useDryRunPipeline(pipelineId: string | undefined) {
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: () => {
+            if (!pipelineId) {
+                return Promise.reject(new Error('Pipeline ID is required'));
+            }
+            return api
+                .mutate(dryRunPipelineDocument, { pipelineId })
+                .then((res) => res.startDataHubPipelineDryRun);
+        },
+        onSuccess: () => {
+            if (pipelineId) {
+                queryClient.invalidateQueries({ queryKey: pipelineKeys.detail(pipelineId) });
+            }
+        },
+        onError: createMutationErrorHandler('dry run pipeline'),
+    });
+}
+
+function createPipelineStatusHook<TDoc extends Parameters<typeof api.mutate>[0]>(
+    document: TDoc,
+    resultKey: string,
+    actionName: string,
+) {
+    return function usePipelineStatusMutation() {
+        const queryClient = useQueryClient();
+        return useMutation({
+            mutationFn: (id: string) =>
+                api.mutate(document, { id }).then((res) => (res as Record<string, unknown>)[resultKey]),
+            onSuccess: (data) => {
+                queryClient.invalidateQueries({ queryKey: pipelineKeys.lists() });
+                if (data && typeof data === 'object' && 'id' in data) {
+                    queryClient.invalidateQueries({ queryKey: pipelineKeys.detail(String(data.id)) });
+                }
+            },
+            onError: createMutationErrorHandler(actionName),
+        });
+    };
+}
+
+export const useSubmitPipelineForReview = createPipelineStatusHook(
+    submitPipelineForReviewDocument, 'submitDataHubPipelineForReview', 'submit pipeline for review',
+);
+export const useApprovePipeline = createPipelineStatusHook(
+    approvePipelineDocument, 'approveDataHubPipeline', 'approve pipeline',
+);
+export const useRejectPipeline = createPipelineStatusHook(
+    rejectPipelineDocument, 'rejectDataHubPipelineReview', 'reject pipeline',
+);
+export const usePublishPipeline = createPipelineStatusHook(
+    publishPipelineDocument, 'publishDataHubPipeline', 'publish pipeline',
+);
+export const useArchivePipeline = createPipelineStatusHook(
+    archivePipelineDocument, 'archiveDataHubPipeline', 'archive pipeline',
+);

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

@@ -0,0 +1,141 @@
+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 } from '../../constants';
+
+const base = createQueryKeys('queues');
+export const queueKeys = {
+    ...base,
+    stats: () => [...base.all, 'stats'] as const,
+    deadLetters: () => [...base.all, 'deadLetters'] as const,
+    consumers: () => [...base.all, 'consumers'] as const,
+};
+
+const statsDocument = graphql(`
+    query DataHubQueueStatsApi {
+        dataHubQueueStats {
+            pending
+            running
+            failed
+            completedToday
+            byPipeline {
+                code
+                pending
+                running
+            }
+            recentFailed {
+                id
+                code
+                finishedAt
+                error
+            }
+        }
+    }
+`);
+
+const deadLettersDocument = graphql(`
+    query DataHubDeadLettersApi {
+        dataHubDeadLetters {
+            id
+            stepKey
+            message
+            payload
+        }
+    }
+`);
+
+const consumersDocument = graphql(`
+    query DataHubConsumersApi {
+        dataHubConsumers {
+            pipelineCode
+            queueName
+            isActive
+            messagesProcessed
+            messagesFailed
+            lastMessageAt
+        }
+    }
+`);
+
+const startConsumerDocument = graphql(`
+    mutation StartDataHubConsumerApi($pipelineCode: String!) {
+        startDataHubConsumer(pipelineCode: $pipelineCode)
+    }
+`);
+
+const stopConsumerDocument = graphql(`
+    mutation StopDataHubConsumerApi($pipelineCode: String!) {
+        stopDataHubConsumer(pipelineCode: $pipelineCode)
+    }
+`);
+
+const markDeadLetterDocument = graphql(`
+    mutation MarkDataHubDeadLetterApi($id: ID!, $deadLetter: Boolean!) {
+        markDataHubDeadLetter(id: $id, deadLetter: $deadLetter)
+    }
+`);
+
+export function useQueueStats() {
+    return useQuery({
+        queryKey: queueKeys.stats(),
+        queryFn: () => api.query(statsDocument).then((res) => res.dataHubQueueStats),
+        refetchInterval: POLLING_INTERVALS.QUEUES,
+    });
+}
+
+export function useDeadLetters() {
+    return useQuery({
+        queryKey: queueKeys.deadLetters(),
+        queryFn: () => api.query(deadLettersDocument).then((res) => res.dataHubDeadLetters),
+    });
+}
+
+export function useConsumers() {
+    return useQuery({
+        queryKey: queueKeys.consumers(),
+        queryFn: () => api.query(consumersDocument).then((res) => res.dataHubConsumers),
+        refetchInterval: POLLING_INTERVALS.CONSUMERS,
+    });
+}
+
+export function useStartConsumer() {
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: ({ pipelineCode }: { pipelineCode: string }) =>
+            api.mutate(startConsumerDocument, { pipelineCode }).then((res) => res.startDataHubConsumer),
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: queueKeys.consumers() });
+        },
+        onError: createMutationErrorHandler('start consumer'),
+    });
+}
+
+export function useStopConsumer() {
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: ({ pipelineCode }: { pipelineCode: string }) =>
+            api.mutate(stopConsumerDocument, { pipelineCode }).then((res) => res.stopDataHubConsumer),
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: queueKeys.consumers() });
+        },
+        onError: createMutationErrorHandler('stop consumer'),
+    });
+}
+
+export function useMarkDeadLetter() {
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: ({ id, deadLetter }: { id: string; deadLetter: boolean }) =>
+            api.mutate(markDeadLetterDocument, { id, deadLetter }).then((res) => res.markDataHubDeadLetter),
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: queueKeys.deadLetters() });
+            queryClient.invalidateQueries({ queryKey: queueKeys.stats() });
+        },
+        onError: createMutationErrorHandler('mark dead letter'),
+    });
+}

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

@@ -0,0 +1,75 @@
+import { useQuery } from '@tanstack/react-query';
+import { api } from '@vendure/dashboard';
+import { graphql } from '../../gql';
+import { createQueryKeys } from '../../utils/query-key-factory';
+import type {
+    DataHubSecretListOptions,
+} from '../../types';
+
+const base = createQueryKeys('secrets');
+const secretKeys = {
+    ...base,
+    list: (options?: DataHubSecretListOptions) => [...base.lists(), options] as const,
+    codes: () => [...base.all, 'codes'] as const,
+};
+
+export const secretsListDocument = graphql(`
+    query DataHubSecretsForList($options: DataHubSecretListOptions) {
+        dataHubSecrets(options: $options) {
+            items {
+                id
+                code
+                provider
+            }
+            totalItems
+        }
+    }
+`);
+
+export const secretDetailDocument = graphql(`
+    query DataHubSecretDetailApi($id: ID!) {
+        dataHubSecret(id: $id) {
+            id
+            code
+            provider
+            value
+            metadata
+        }
+    }
+`);
+
+export const createSecretDocument = graphql(`
+    mutation CreateDataHubSecretApi($input: CreateDataHubSecretInput!) {
+        createDataHubSecret(input: $input) {
+            id
+            code
+        }
+    }
+`);
+
+export const updateSecretDocument = graphql(`
+    mutation UpdateDataHubSecretApi($input: UpdateDataHubSecretInput!) {
+        updateDataHubSecret(input: $input) {
+            id
+            code
+        }
+    }
+`);
+
+export const deleteSecretDocument = graphql(`
+    mutation DeleteDataHubSecretApi($id: ID!) {
+        deleteDataHubSecret(id: $id) {
+            result
+        }
+    }
+`);
+
+export function useSecrets(options?: DataHubSecretListOptions) {
+    return useQuery({
+        queryKey: secretKeys.list(options),
+        queryFn: () =>
+            api.query(secretsListDocument, { options }).then((res) => res.dataHubSecrets),
+    });
+}
+
+

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

@@ -0,0 +1,55 @@
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { api } from '@vendure/dashboard';
+import { graphql } from '../../gql';
+import { createMutationErrorHandler, createMutationSuccessHandler } from './mutation-helpers';
+import { createQueryKeys } from '../../utils/query-key-factory';
+import type { DataHubSettingsInput } from '../../types';
+
+const base = createQueryKeys('settings');
+const settingsKeys = {
+    all: base.all,
+    detail: base.details,
+};
+
+const settingsDocument = graphql(`
+    query DataHubSettingsApi {
+        dataHubSettings {
+            retentionDaysRuns
+            retentionDaysErrors
+            retentionDaysLogs
+            logPersistenceLevel
+        }
+    }
+`);
+
+const setSettingsDocument = graphql(`
+    mutation UpdateDataHubSettingsApi($input: DataHubSettingsInput!) {
+        updateDataHubSettings(input: $input) {
+            retentionDaysRuns
+            retentionDaysErrors
+            retentionDaysLogs
+            logPersistenceLevel
+        }
+    }
+`);
+
+export function useSettings() {
+    return useQuery({
+        queryKey: settingsKeys.detail(),
+        queryFn: () => api.query(settingsDocument).then((res) => res.dataHubSettings),
+    });
+}
+
+export function useUpdateSettings() {
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: (input: DataHubSettingsInput) =>
+            api.mutate(setSettingsDocument, { input }).then((res) => res.updateDataHubSettings),
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: settingsKeys.detail() });
+            createMutationSuccessHandler('Settings updated')();
+        },
+        onError: createMutationErrorHandler('update settings'),
+    });
+}

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

@@ -0,0 +1,79 @@
+import { api } from '@vendure/dashboard';
+import { graphql } from '../../gql';
+import type { JsonObject } from '../../types';
+
+/** Record type used in step testing */
+type TestRecord = JsonObject;
+
+const previewExtractDocument = graphql(`
+    mutation PreviewDataHubExtractApi($step: JSON!, $limit: Int) {
+        previewDataHubExtract(step: $step, limit: $limit) { records }
+    }
+`);
+
+const simulateTransformDocument = graphql(`
+    mutation SimulateDataHubTransformApi($step: JSON!, $records: JSON!) {
+        simulateDataHubTransform(step: $step, records: $records)
+    }
+`);
+
+const simulateLoadDocument = graphql(`
+    mutation SimulateDataHubLoadApi($step: JSON!, $records: JSON!) {
+        simulateDataHubLoad(step: $step, records: $records)
+    }
+`);
+
+const simulateValidateDocument = graphql(`
+    mutation SimulateDataHubValidateApi($step: JSON!, $records: JSON!) {
+        simulateDataHubValidate(step: $step, records: $records) {
+            records
+            summary { input passed failed passRate }
+        }
+    }
+`);
+
+const previewFeedDocument = graphql(`
+    mutation PreviewDataHubFeedApi($feedCode: String!, $limit: Int) {
+        previewDataHubFeed(feedCode: $feedCode, limit: $limit) { content contentType itemCount }
+    }
+`);
+
+interface PreviewExtractInput {
+    step: JsonObject;
+    limit: number;
+}
+
+interface SimulateStepInput {
+    step: JsonObject;
+    records: TestRecord[];
+}
+
+interface PreviewFeedInput {
+    feedCode: string;
+    limit: number;
+}
+
+export async function previewExtract(step: JsonObject, limit: number): Promise<TestRecord[]> {
+    const res = await api.mutate(previewExtractDocument, { step, limit });
+    return (res?.previewDataHubExtract?.records ?? []) as TestRecord[];
+}
+
+export async function simulateTransform(step: JsonObject, records: TestRecord[]): Promise<TestRecord[]> {
+    const res = await api.mutate(simulateTransformDocument, { step, records });
+    return (res?.simulateDataHubTransform ?? []) as TestRecord[];
+}
+
+export async function simulateLoad(step: JsonObject, records: TestRecord[]): Promise<JsonObject> {
+    const res = await api.mutate(simulateLoadDocument, { step, records });
+    return (res?.simulateDataHubLoad ?? {}) as JsonObject;
+}
+
+export async function simulateValidate(step: JsonObject, records: TestRecord[]) {
+    const res = await api.mutate(simulateValidateDocument, { step, records });
+    return res?.simulateDataHubValidate;
+}
+
+export async function previewFeed(feedCode: string, limit: number) {
+    const res = await api.mutate(previewFeedDocument, { feedCode, limit });
+    return res?.previewDataHubFeed;
+}

package/dist/dashboard/hooks/index.ts

@@ -0,0 +1,13 @@
+export { useAdapterCatalog } from './use-adapter-catalog';
+export type {
+    AdapterMetadata,
+} from './use-adapter-catalog';
+
+export * from './api';
+
+export { useStableKeys } from './use-stable-keys';
+
+export { useLoadMore } from './use-load-more';
+
+export { useTriggerTypes, useTriggerIconResolver } from './use-trigger-types';
+export type { TriggerTypeConfig, WizardTriggerOption } from './use-trigger-types';