Ide Plugins Intellij

Actions

public class GenerateEntityAction extends AnAction {

    @Override
    public void actionPerformed(@NotNull AnActionEvent e) {
        Project project = e.getProject();
        if (project == null) return;

        // Show dialog
        GenerateEntityDialog dialog = new GenerateEntityDialog(project);
        if (!dialog.showAndGet()) return;

        // Generate files
        WriteCommandAction.runWriteCommandAction(project, () -> {
            EntityGeneratorService generator =
                project.getService(EntityGeneratorService.class);

            generator.generateEntity(dialog.getTableDefinition(),
                                      dialog.getOptions());
        });
    }

    @Override
    public void update(@NotNull AnActionEvent e) {
        // Only enable in Java project
        Project project = e.getProject();
        boolean enabled = project != null &&
            ProjectRootManager.getInstance(project).getProjectSdk() != null;
        e.getPresentation().setEnabledAndVisible(enabled);
    }

    @Override
    public @NotNull ActionUpdateThread getActionUpdateThread() {
        return ActionUpdateThread.BGT;
    }
}

Services

@Service(Service.Level.PROJECT)
public final class ApigenProjectService {

    private final Project project;
    private final Map<String, ApigenModule> modules = new HashMap<>();

    public ApigenProjectService(Project project) {
        this.project = project;
        loadConfiguration();
    }

    private void loadConfiguration() {
        // Find apigen configuration files
        VirtualFile baseDir = project.getBaseDir();
        VirtualFile configFile = baseDir.findFileByRelativePath(
            "src/main/resources/application.yml");

        if (configFile != null) {
            parseConfiguration(configFile);
        }
    }

    public boolean isApigenProject() {
        // Check for apigen dependencies in build.gradle
        return modules.containsKey("apigen-core");
    }

    public List<String> getConfiguredEntities() {
        return modules.values().stream()
            .flatMap(m -> m.getEntities().stream())
            .map(EntityConfig::getName)
            .toList();
    }
}

Code Completion

public class YamlCompletionContributor extends CompletionContributor {

    public YamlCompletionContributor() {
        // Completion for app.* properties
        extend(CompletionType.BASIC,
            PlatformPatterns.psiElement()
                .inside(YAMLKeyValue.class)
                .withLanguage(YAMLLanguage.INSTANCE),
            new ApigenYamlCompletionProvider());
    }

    private static class ApigenYamlCompletionProvider extends CompletionProvider<CompletionParameters> {

        @Override
        protected void addCompletions(@NotNull CompletionParameters parameters,
                                       @NotNull ProcessingContext context,
                                       @NotNull CompletionResultSet result) {

            PsiElement position = parameters.getPosition();
            String prefix = getPrefix(position);

            if (prefix.startsWith("app.")) {
                // Add apigen-core properties
                addCoreProperties(result);
            } else if (prefix.startsWith("apigen.security.")) {
                // Add security properties
                addSecurityProperties(result);
            }
        }

        private void addCoreProperties(CompletionResultSet result) {
            result.addElement(LookupElementBuilder.create("app.cache.enabled")
                .withTypeText("boolean")
                .withTailText(" = true", true));

            result.addElement(LookupElementBuilder.create("app.pagination.default-size")
                .withTypeText("int")
                .withTailText(" = 20", true));

            result.addElement(LookupElementBuilder.create("app.rate-limit.enabled")
                .withTypeText("boolean")
                .withTailText(" = false", true));
        }
    }
}

PSI Annotator

public class ApigenAnnotator implements Annotator {

    @Override
    public void annotate(@NotNull PsiElement element, @NotNull AnnotationHolder holder) {
        if (!(element instanceof PsiClass psiClass)) return;

        // Check if extends BaseService
        PsiClass superClass = psiClass.getSuperClass();
        if (superClass != null && "BaseService".equals(superClass.getName())) {
            checkServiceImplementation(psiClass, holder);
        }

        // Check Entity annotations
        if (hasAnnotation(psiClass, "jakarta.persistence.Entity")) {
            checkEntityConfiguration(psiClass, holder);
        }
    }

    private void checkServiceImplementation(PsiClass psiClass, AnnotationHolder holder) {
        // Check for required methods
        if (findMethod(psiClass, "getRepository") == null) {
            holder.newAnnotation(HighlightSeverity.WARNING,
                "BaseService subclass should implement getRepository()")
                .range(psiClass.getNameIdentifier())
                .withFix(new ImplementGetRepositoryFix(psiClass))
                .create();
        }
    }

    private void checkEntityConfiguration(PsiClass psiClass, AnnotationHolder holder) {
        // Check for ID field
        boolean hasId = Arrays.stream(psiClass.getFields())
            .anyMatch(f -> hasAnnotation(f, "jakarta.persistence.Id"));

        if (!hasId) {
            holder.newAnnotation(HighlightSeverity.ERROR,
                "Entity must have an @Id field")
                .range(psiClass.getNameIdentifier())
                .create();
        }
    }
}

Quick Fixes

public class ImplementGetRepositoryFix implements LocalQuickFix {

    private final PsiClass psiClass;

    @Override
    public @NotNull String getFamilyName() {
        return "Implement getRepository() method";
    }

    @Override
    public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
        WriteCommandAction.runWriteCommandAction(project, () -> {
            PsiElementFactory factory = JavaPsiFacade.getElementFactory(project);

            // Find entity type from generic parameter
            String entityType = extractEntityType(psiClass);

            String methodText = String.format("""
                @Override
                protected JpaRepository<%s, UUID> getRepository() {
                    return repository;
                }
                """, entityType);

            PsiMethod method = factory.createMethodFromText(methodText, psiClass);
            psiClass.add(method);

            // Format and optimize imports
            CodeStyleManager.getInstance(project).reformat(method);
            JavaCodeStyleManager.getInstance(project).optimizeImports(psiClass.getContainingFile());
        });
    }
}

Tool Window

public class ApigenToolWindowFactory implements ToolWindowFactory {

    @Override
    public void createToolWindowContent(@NotNull Project project, @NotNull ToolWindow toolWindow) {
        ApigenToolWindowPanel panel = new ApigenToolWindowPanel(project);
        ContentFactory contentFactory = ContentFactory.getInstance();
        Content content = contentFactory.createContent(panel, "Entities", false);
        toolWindow.getContentManager().addContent(content);
    }
}

public class ApigenToolWindowPanel extends SimpleToolWindowPanel {

    private final Tree entityTree;

    public ApigenToolWindowPanel(Project project) {
        super(true, true);

        ApigenProjectService service = project.getService(ApigenProjectService.class);

        // Build tree model
        DefaultMutableTreeNode root = new DefaultMutableTreeNode("Entities");
        for (String entity : service.getConfiguredEntities()) {
            root.add(new DefaultMutableTreeNode(entity));
        }

        entityTree = new Tree(new DefaultTreeModel(root));
        setContent(ScrollPaneFactory.createScrollPane(entityTree));

        // Add toolbar
        ActionToolbar toolbar = ActionManager.getInstance()
            .createActionToolbar("ApigenToolbar", createActionGroup(), true);
        toolbar.setTargetComponent(this);
        setToolbar(toolbar.getComponent());
    }

    private ActionGroup createActionGroup() {
        DefaultActionGroup group = new DefaultActionGroup();
        group.add(new RefreshAction());
        group.add(new GenerateAction());
        return group;
    }
}

File Templates

// fileTemplates/internal/APiGen Controller.java.ft
#if (${PACKAGE_NAME} && ${PACKAGE_NAME} != "")package ${PACKAGE_NAME};#end

import com.jnzader.apigen.core.web.BaseController;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/${ENTITY_PATH}")
public class ${NAME} extends BaseController<${ENTITY}, ${DTO}, ${ID_TYPE}> {

    private final ${SERVICE} service;

    public ${NAME}(${SERVICE} service) {
        this.service = service;
    }

    @Override
    protected BaseService<${ENTITY}, ${DTO}, ${ID_TYPE}> getService() {
        return service;
    }
}

Testing

public class ApigenAnnotatorTest extends LightJavaCodeInsightFixtureTestCase {