leds-spark-lib/dist/backend/java-generator/webservice/module-generator.js

Biblioteca de geração de código

import path from "path";
import fs from "fs";
import { isLocalEntity, isModule, getRef, expandToString, expandToStringWithNL, toString, capitalizeString, createPath } from "../../models/model.js";
export function generateModules(model, target_folder) {
    const package_path = model.configuration?.package_path ?? 'base';
    const modules = model.abstractElements.filter(isModule);
    if (model.configuration) {
        const package_name_application = `${package_path}.service.${model.configuration?.name?.toLocaleLowerCase()}.application`;
        const APPLICATION_PATH = createPath(target_folder, "src/main/java/", package_name_application.replaceAll(".", "/"));
        fs.writeFileSync(path.join(APPLICATION_PATH, `Application.java`), applicationGenerator(package_name_application, model.configuration));
    }
    for (const mod of modules) {
        const package_name = `${package_path}.service.${model.configuration?.name}.${mod.name.toLowerCase()}`;
        const MODULE_PATH = createPath(target_folder, "src/main/java/", package_name.replaceAll(".", "/"));
        const REPOSITORIES_PATH = createPath(MODULE_PATH, 'repositories');
        const CONTROLLERS_PATH = createPath(MODULE_PATH, 'controllers');
        const RECORDS_PATH = createPath(MODULE_PATH, 'records');
        const mod_classes = mod.elements.filter(isLocalEntity);
        for (const cls of mod_classes) {
            const class_name = cls.name;
            if (!cls.is_abstract) {
                fs.writeFileSync(path.join(REPOSITORIES_PATH, `${class_name}RepositoryWeb.java`), toString(generateClassRepository(cls, package_name)));
                fs.writeFileSync(path.join(CONTROLLERS_PATH, `${class_name}Controller.java`), toString(generateClassController(cls, package_name)));
                fs.writeFileSync(path.join(RECORDS_PATH, `${class_name}Input.java`), toString(generateRecord(cls, package_name)));
            }
        }
    }
}
function applicationGenerator(path_package, configuration) {
    return expandToStringWithNL `
  package ${path_package};

  import org.springframework.boot.SpringApplication;
  import org.springframework.boot.autoconfigure.SpringBootApplication;
  import org.springframework.boot.SpringApplication;
  import org.springframework.boot.autoconfigure.SpringBootApplication;
  import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
  import org.springframework.boot.autoconfigure.*;
  import org.springframework.context.annotation.*;
  import org.springframework.boot.autoconfigure.domain.EntityScan;
  import org.springframework.data.jpa.repository.config.EnableJpaRepositories;

  import io.swagger.v3.oas.annotations.OpenAPIDefinition;
  import io.swagger.v3.oas.annotations.info.Info;

  @SpringBootApplication
  @EnableAutoConfiguration
  @ComponentScan(basePackages = {"${path_package.replace("application", "")}*"})
  @EntityScan(basePackages = {"${path_package.replace("application", "").replace("service", "entity")}*"})
  @EnableJpaRepositories(basePackages = {"${path_package.replace("application", "")}*"})
  @OpenAPIDefinition(info = @Info(
    title = "${configuration.name ?? "-"}", 
    version = "1.0", 
    description = "${configuration.description}"))

  public class Application {

    public static void main(String[] args) {
      SpringApplication.run(Application.class, args);
    }
  }
  `;
}
function generateClassRepository(cls, package_name) {
    return expandToStringWithNL `
    package ${package_name.toLowerCase()}.repositories;

    import ${package_name.replace("service", "entity")}.models.${cls.name};
    import ${package_name.replace("service", "entity")}.repositories.${cls.name}Repository;

    import org.springframework.data.rest.core.annotation.RestResource;
    import org.springframework.data.rest.core.annotation.RepositoryRestResource;

    @RepositoryRestResource(collectionResourceRel = "${cls.name.toLowerCase()}", path = "${cls.name.toLowerCase()}")
    public interface ${cls.name}RepositoryWeb extends ${cls.name}Repository {
    
    }
  `;
}
function generateRecord(cls, package_name) {
    let att = cls.attributes;
    const superTypeRef = getRef(cls.superType);
    if (isLocalEntity(superTypeRef)) {
        att = cls.attributes.concat(superTypeRef.attributes ?? []);
    }
    return expandToStringWithNL `
  package ${package_name.toLowerCase()}.records;
  import java.time.LocalDate;
  import java.time.LocalDateTime;
  import java.math.BigDecimal;
  import java.util.UUID;
  public record ${cls.name}Input( ${att.map(att => generateRecordAtribute(att)).join(',')} ) {
  }
  `;
}
function generateRecordAtribute(attribute) {
    return expandToString `
${capitalizeString(toString(generateTypeAttribute(attribute))) ?? 'Not Type'} ${attribute.name} 
`;
}
function generateTypeAttribute(attribute) {
    const type = attribute.type.toString().toLowerCase();
    switch (type) {
        case "date":
            return "LocalDate";
        case "datetime":
            return "LocalDateTime";
        case "cpf":
        case "cnpj":
        case "email":
        case "mobilephonenumber":
        case "phonenumber":
        case "zipcode":
        case "string":
            return "String";
        case "boolean":
            return "Boolean";
        case "integer":
            return "Integer";
        case "decimal":
        case "currency":
            return "BigDecimal";
        case "file":
            return "byte[]";
        case "uuid":
            return "UUID";
        case "void":
            return "void";
        default:
            return "String"; // fallback para tipos não reconhecidos
    }
}
function generateClassController(cls, package_name) {
    let att = cls.attributes;
    const superTypeRef = getRef(cls.superType);
    if (isLocalEntity(superTypeRef)) {
        att = cls.attributes.concat(superTypeRef.attributes ?? []);
    }
    return expandToStringWithNL `
    package ${package_name.toLowerCase()}.controllers;

    import ${package_name.replace("service", "entity")}.models.${cls.name};
    import ${package_name.replace("service", "entity")}.repositories.${cls.name}Repository;
    import ${package_name.toLowerCase()}.records.${cls.name}Input;

    import org.springframework.beans.factory.annotation.Autowired;
    
    import org.springframework.graphql.data.method.annotation.Argument;
    import org.springframework.graphql.data.method.annotation.MutationMapping;
    import org.springframework.graphql.data.method.annotation.QueryMapping;
    
    import org.springframework.stereotype.Controller;

    import java.util.List;

    @Controller
    public class ${cls.name}Controller  {

      @Autowired
      ${cls.name}Repository repository;

      @QueryMapping
      public List<${cls.name}> findAll${cls.name}s() {
        return repository.findAll();
      }

      @QueryMapping
      public ${cls.name} findByID${cls.name}(@Argument Long id) {
        return repository.findById(id).orElse(null);
      }

      /* https://github.com/danvega/graphql-books
      Usar isso para relacao entre os conceitos https://www.danvega.dev/blog/2023/03/20/graphql-mutations/
      */

      @MutationMapping
      public ${cls.name} create${cls.name}(@Argument ${cls.name}Input input) {
        ${cls.name} instance = ${cls.name}.builder().${att.map(att => `${att.name}(input.${att.name}())`).join(".\n")}.build();  

        return repository.save(instance);
      }

      @MutationMapping
      public ${cls.name} update${cls.name}(@Argument Long id, @Argument ${cls.name}Input input) {
        ${cls.name} instance = repository.findById(id).orElse(null);
        if(instance == null) {
            throw new RuntimeException("${cls.name} not found");
        }
        ${att.map(att => `instance.set${capitalizeString(att.name)}(input.${att.name}());`).join("\n")}
        repository.save(instance);
        return instance;
      }
      
      @MutationMapping
      public void delete${cls.name}(@Argument Long id) {
        repository.deleteById(id);
      }
    
    }
  `;
}
//# sourceMappingURL=module-generator.js.map