​
Amplication AST Libraries

These AST libraries are used by Blueprint and .NET engines. Node.js plugins use different methods for code generation as detailed in the Node.js Plugin Events documentation.

Amplication AST libraries provide functionality for generating Abstract Syntax Trees (AST) for different programming languages in the Amplication platform. These libraries are used to generate type-safe, well-structured code for various programming languages.

​
Key Features

  • Type-safe AST generation
  • Support for multiple programming languages
  • Common interfaces and types across language implementations
  • Extensible architecture for adding new language support

​
Scope and Purpose

The AST libraries are not intended to cover all language functionality. Instead, they focus on the elements needed to create the foundation and boilerplate code with Amplication plugins. These libraries provide the essential building blocks for generating well-structured code across different languages.

When more specialized or custom code is needed, the CodeBlock can be used as a generic node that can include any code as a string. This flexibility allows you to generate both structured AST-based code and custom code blocks when necessary.

import { CodeBlock } from '@amplication/java-ast'; // or '@amplication/csharp-ast'

// Create a custom code block when needed
const customLogic = new CodeBlock(`
  // Custom implementation that may not be supported by the AST library directly
  if (condition) {
    specialFunction();
    return customResult;
  }
`);

​
Available Libraries

Amplication provides several AST libraries:

  • AST Types - Common interfaces and types used across different language implementations
  • C# AST - Library for generating C# code through an abstract syntax tree
  • Java AST - Library for generating Java code through an abstract syntax tree
  • Python AST - Library for generating Python code through an abstract syntax tree

​
Installation

To install the libraries:

# For AST Types
npm install @amplication/ast-types

# For C# AST
npm install @amplication/csharp-ast

# For Java AST
npm install @amplication/java-ast

# For Python AST
npm install @amplication/python-ast

​
Getting Started

To use these libraries in your project:

// For Java AST
import { Class, Interface, Method } from '@amplication/java-ast';

// For C# AST
import { Class, Interface, Method } from '@amplication/csharp-ast';

// For Python AST
import { Class, Interface, Method } from '@amplication/python-ast';

​
Documentation

AST Libraries API Documentation

Complete API reference for all AST libraries. Explore class definitions, method signatures, type hierarchies, and usage examples to help you build powerful code generation plugins.

​
Using AST Libraries in Plugins

Amplication’s plugin architecture is built around the AST libraries. When developing plugins, you can leverage these libraries to generate code that integrates seamlessly with Amplication’s code generation process.

​
Plugin Integration

All Amplication plugins work with objects of type IAstNode from the AST libraries. Plugins typically:

  1. Create AST nodes using the appropriate library (Java, C#, etc.)
  2. Create an IFile<IAstNode> object that references the AST node
  3. Add the file to the context using context.files.set()

This approach allows plugins to generate code that’s properly integrated into Amplication’s code generation pipeline.

​
Example: Using AST in a Plugin

Here’s an example of how a plugin might use the Java AST library to create a class:

import { IAstNode } from "@amplication/ast-types";
import {
  blueprintPluginEventsParams as blueprint,
  blueprintPluginEventsTypes,
  blueprintTypes,
  IFile,
} from "@amplication/code-gen-types";
import {
  Access,
  Class,
  Field,
  Method,
  MethodType,
  Type,
} from "@amplication/java-ast";
import { pascalCase } from "pascal-case";

class JavaTestPlugin implements blueprintTypes.AmplicationPlugin {
  register(): blueprintPluginEventsTypes.BlueprintEvents {
    return {
      createBlueprint: {
        before: this.beforeCreateBlueprint,
      },
    };
  }
  async beforeCreateBlueprint(
    context: blueprintTypes.DsgContext,
    eventParams: blueprint.CreateBlueprintParams,
  ): Promise<blueprint.CreateBlueprintParams> {
    context.logger.info("Generating Java test classes...");

    const params = {} as Record<string, string>;

    params.SERVICE_DISPLAY_NAME = context.resourceInfo?.name || "User";
    params.SERVICE_NAME = pascalCase(params.SERVICE_DISPLAY_NAME);

    const testClass = new Class({
      name: "MyJavaTestClass",
      packageName: "com.example.test",
      access: Access.Public,
    });

    testClass.addField(
      new Field({
        name: "myMockField",
        type: Type.string(),
        access: Access.Private,
      }),
    );

    testClass.addField(
      new Field({
        name: "myServiceField",
        type: Type.string(),
        access: Access.Private,
      }),
    );

    testClass.addMethod(
      new Method({
        name: "myTestMethod1",
        type: MethodType.INSTANCE,
        access: Access.Public,
      }),
    );

    testClass.addMethod(
      new Method({
        name: "myTestMethod2",
        type: MethodType.INSTANCE,
        access: Access.Public,
      }),
    );

    const javaFile: IFile<IAstNode> = {
      path: "MyJavaTestClass.java",
      code: testClass,
    };

    context.files.set(javaFile);

    return eventParams;
  }
}

export default JavaTestPlugin;

Using the AST libraries gives you fine-grained control over code generation while ensuring the generated code integrates correctly with the rest of the Amplication-generated codebase.

Was this page helpful?