Best pattern/practice to execute a multi-step code generation process

Question

I am working on a project that generates an API with the possibility of doing CRUD operations based on a high-level description of the resources that the user would like to have in an application. In the process of generating the code, multiple steps have to be taken (for some context, I am generating Python code from Python with Jinja2):

1. Generating code that handles the connection with the database
2. Generating Dockerfiles
3. Generating Pydantic Models for the input resources
4. Generating classes that link the application to a database using SQLAlchemy models
5. Generating methods that facilitate CRUD operations on the database's tables
6. Generating the API code

Almost all of the operations depend on the input from the user but are not directly linked in any way, so they could even be executed in parallel.

Researching for ways of how to properly handle sequential operations I have found the Chain of Responsibility pattern, but it does not really apply in my situation as I have to execute all of the steps regardless of the user input (as long as it's a valid input).

I have also thought of something like the Strategy pattern for each generation process, but I'm having a hard time deciding if any of these patterns is a right fit for my situation.

Currently I have structured my code in the following way:

1. I received the input and check for several conditions to be met (validations)
2. I process the input and change it dynamically to adjust it for the following steps
3. I execute the following steps in a procedural manner, one after the other.

r = RelationshipHandler(Input(**res).resources)
r.execute()
resources = [resource.dict() for resource in r.resources]
generate_connection()
generate_db_create_code(resources)
generate_docker_compose()
generate_pydantic_models(resources)
generate_sqlalchemy_classes(resources)
generate_model_code(resources)
generate_fastapi_code(resources)

All of these operations are executed by an orchestator/choreographer - which would basically imply that I'm at least using an extremely simple version of the Choreography pattern (more common in the context of microservices).

My question is: how are situations like this handled in general? What patterns or best practices would make the code be more clean/readable/logical and easier to maintain?

I am aware that there might be multiple ways of handling situations like the described one, I am just trying to find other, more elevated ways of solving the same problem.

Answer 1

There is nothing inherently wrong in having an orchestator doing these steps one after another. When all you need is this fixed step of sequences, don't start to throw some fancy patterns at the code base, this will only overcomplicate things for no benefit.

The key point, however, is, to make the input and output of each of the steps explicit instead of using "global state" for passing the data around.

For example:

conn=generate_connection()
my_code = generate_db_create_code(conn,resources)
generate_docker_compose(my_code)

(The above input/output might not be correct, but I guess you get the idea).

The goals behind this are the following:

• it should become more self explanatory what each step does, and

• each step should be unit testable isolation, and

• it becomes less error prone when you have to add or reorder some steps.

Those are typical goals you should have in mind for this design, not some patterns you have heard from.

Answer 2

If these steps are independent, one architecture you can use if the event driven architecture which is implemented using the pub/sub design pattern. Basically one class (the publisher) raise or fires an event "generateCode", and many consumer classes (subscribers) consume that event by running a certain piece of code.