Generating TypeScript Models

Provide your controller file content and I'll generate the corresponding model.ts file following the established patterns.

Example Input:

TypeScript
// controllers
export const getUsersController = async (
  qsParams: User.QueryStringParams
): Promise<AxiosResponse<App.Pagination<User.User>, any>> => {
  // ... implementation
};

export const createUserController = async (
  body: User.CreateParams
): Promise<AxiosResponse<User.User, any>> => {
  // ... implementation
};

Example Output:

TypeScript
// model.ts
import { defaultPaginationValues } from '@/constants/pagination';
import useLoading from '@/hooks/use-loading';
import { updateArrayItem } from '@/utils/update-array-item';
import { message } from 'antd';
import { useState } from 'react';
import {
  createUserController,
  getUsersController,
} from './user.controller';

export default () => {
  const [users, setUsers] = useState<App.Pagination<User.User>>(defaultPaginationValues);
  const { loading, startLoading, stopLoading } = useLoading();

  const getUsers = async (...args: Parameters<typeof getUsersController>) => {
    try {
      startLoading();
      const response = await getUsersController(...args);
      const { data } = response;
      setUsers(data);
    } catch (error) {
      message.error('Não foi possível obter os dados');
      return Promise.reject();
    } finally {
      stopLoading();
    }
  };

  const createUser = async (...args: Parameters<typeof createUserController>) => {
    try {
      startLoading();
      const response = await createUserController(...args);
      const { data } = response;
      setUsers((previousData) => ({
        ...previousData,
        results: [data, ...(previousData?.results || [])],
        count: previousData.count + 1,
      }));
      message.success('Criado com sucesso');
      return Promise.resolve();
    } catch (error) {
      message.error('Não foi possível criar');
      return Promise.reject();
    } finally {
      stopLoading();
    }
  };

  return {
    userLoading: loading,
    users,
    getUsers,
    createUser,
  };
};

1. Analyze controllers - Identify available CRUD operations
2. Determine data structure - Paginated vs simple array based on get controller return type
3. Generate state management - Create useState for data storage
4. Implement CRUD functions - Map each controller to a model function
5. Handle parameter mapping - Use args[n] for multi-parameter operations
6. Add error handling - Generic messages without entity names
7. Return interface - Export all functions and state

Progress:

• Parse controller functions
• Identify pagination pattern
• Generate state variables
• Create CRUD operations
• Add parameter handling
• Implement error messages
• Define return interface

Example 1: Paginated with no parameters

TypeScript
// Controller signature determines model structure
getAreasController(qsParams) → Pagination<Area>
// Results in:
const [areas, setAreas] = useState<App.Pagination<Area>>(defaultPaginationValues);

Example 2: Simple array without pagination

TypeScript
// Controller signature
getVersoesController() → Versao[]
// Results in:
const [versoes, setVersoes] = useState<Versao[]>([]);

Example 3: Multi-parameter operations

TypeScript
// Controller signature
updateAdicionalNoturnoController(versao, id, params)
// Results in updateArrayItem using:
identification: args[1], // The id parameter