ruch/src/templates/domains/hooks.ts

Revolutionary React TypeScript CLI with hexagonal architecture & AI-powered development assistance. Create maintainable, scalable applications with domain-driven design and integrated AI tooling.

export const getHookTemplate = (domainName: string): string => {
  const capitalizedName = domainName.charAt(0).toUpperCase() + domainName.slice(1);
  
  return `import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
import type { ${capitalizedName}CreationData, ${capitalizedName}UpdateData } from '../entities/${capitalizedName}';
import { ${capitalizedName}Service } from '../services/${capitalizedName}Service';
import type { ${capitalizedName}Port } from '../ports/${capitalizedName}Port';

const QUERY_KEYS = {
  all: ['${domainName}'] as const,
  lists: () => [...QUERY_KEYS.all, 'list'] as const,
  list: (filters: string) => [...QUERY_KEYS.lists(), { filters }] as const,
  details: () => [...QUERY_KEYS.all, 'detail'] as const,
  detail: (id: string) => [...QUERY_KEYS.details(), id] as const,
};

export function use${capitalizedName}Service(port: ${capitalizedName}Port) {
  return new ${capitalizedName}Service(port);
}

export function use${capitalizedName}List(port: ${capitalizedName}Port) {
  const service = use${capitalizedName}Service(port);
  return useQuery({
    queryKey: QUERY_KEYS.lists(),
    queryFn: () => service.getAll(),
  });
}

export function use${capitalizedName}Detail(port: ${capitalizedName}Port, id: string) {
  const service = use${capitalizedName}Service(port);
  return useQuery({
    queryKey: QUERY_KEYS.detail(id),
    queryFn: () => service.getById(id),
    enabled: !!id,
  });
}

export function use${capitalizedName}Create(port: ${capitalizedName}Port) {
  const queryClient = useQueryClient();
  const service = use${capitalizedName}Service(port);
  return useMutation({
    mutationFn: (data: ${capitalizedName}CreationData) => service.create(data),
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: QUERY_KEYS.lists() });
    },
  });
}

export function use${capitalizedName}Update(port: ${capitalizedName}Port) {
  const queryClient = useQueryClient();
  const service = use${capitalizedName}Service(port);
  return useMutation({
    mutationFn: ({ id, data }: { id: string; data: ${capitalizedName}UpdateData }) =>
      service.update(id, data),
    onSuccess: (_, { id }) => {
      queryClient.invalidateQueries({ queryKey: QUERY_KEYS.lists() });
      queryClient.invalidateQueries({ queryKey: QUERY_KEYS.detail(id) });
    },
  });
}

export function use${capitalizedName}Delete(port: ${capitalizedName}Port) {
  const queryClient = useQueryClient();
  const service = use${capitalizedName}Service(port);
  return useMutation({
    mutationFn: (id: string) => service.delete(id),
    onSuccess: (_, id) => {
      queryClient.invalidateQueries({ queryKey: QUERY_KEYS.lists() });
      queryClient.invalidateQueries({ queryKey: QUERY_KEYS.detail(id) });
    },
  });
}`;
};

export const getHookTestTemplate = (domainName: string): string => {
  const capitalizedName = domainName.charAt(0).toUpperCase() + domainName.slice(1);
  
  return `import { renderHook, act } from '@testing-library/react';
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
import { describe, it, expect, vi, beforeEach } from 'vitest';
import {
  use${capitalizedName}List,
  use${capitalizedName}Detail,
  use${capitalizedName}Create,
  use${capitalizedName}Update,
  use${capitalizedName}Delete,
} from './use${capitalizedName}';

describe('${capitalizedName} Hooks', () => {
  let queryClient: QueryClient;

  beforeEach(() => {
    queryClient = new QueryClient({
      defaultOptions: {
        queries: {
          retry: false,
        },
      },
    });
  });

  const wrapper = ({ children }: { children: React.ReactNode }) => (
    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
  );

  describe('use${capitalizedName}List', () => {
    it('should fetch list of entities', async () => {
      const { result } = renderHook(() => use${capitalizedName}List(), { wrapper });

      expect(result.current.isLoading).toBe(true);
      await act(async () => {
        await result.current.refetch();
      });
      expect(result.current.isLoading).toBe(false);
    });
  });

  // Add more test cases for other hooks...
});`;
};