Consistent column naming in M2M through tables.

[PieceOfGood]

With the following model description:

class Book(Model):
    id = fields.IntField(pk=True)
    name = fields.CharField(100)
    count = fields.IntField(default=1)
    release_date = fields.DatetimeField(null=False)

    author: fields.ForeignKeyRelation["Author"] = fields.ForeignKeyField(
        "models.Author", related_name="books"
    )

    given_to: fields.ManyToManyRelation["Student"] = fields.ManyToManyField(
        "models.Student",
        related_name="received_books",
        through="receiving_books",
        # backward_key="book_id"
    )

    class Meta:
        table = "custom_books"


class Author(Model):
    id = fields.IntField(pk=True)
    name = fields.CharField(100)
    surname = fields.CharField(100)

    books: fields.ReverseRelation["Book"]

    class Meta:
        table = "authors"


class Student(Model):
    id = fields.IntField(pk=True)
    name = fields.CharField(100, null=False)
    surname = fields.CharField(100, null=False)
    phone = fields.CharField(100, null=False)
    email = fields.CharField(100, null=False)
    average_score = fields.FloatField(default=0.0)
    scholarship = fields.BooleanField(default=False)

    received_books: fields.ManyToManyRelation["Book"]

    class Meta:
        table = "custom_students"


class ReceivingBooks(Model):
    id = fields.IntField(pk=True)
    date_of_issue = fields.DatetimeField(auto_now_add=True)
    date_of_return = fields.DatetimeField(null=True)

    student: fields.ForeignKeyRelation["Student"] = fields.ForeignKeyField(
        "models.Student"
    )
    book: fields.ForeignKeyRelation["Book"] = fields.ForeignKeyField(
        "models.Book"
    )

    class Meta:
        table = "receiving_books"

The following code:

async def main() -> None:
    await Tortoise.init(...)
    await Tortoise.generate_schemas()

    tolstoy, _ = await Author.get_or_create(name="Lev", surname="Tolstoy")

    if not (war_and_peace := await Book.filter(name="War and Peace").first()):
        war_and_peace = await Book.create(
            name="War and Peace", count=5, release_date=now(), author=tolstoy)

    if not (anna_karenina := await Book.filter(name="Anna Karenina").first()):
        anna_karenina = await Book.create(
            name="Anna Karenina", count=5, release_date=now(), author=tolstoy)

    student, _ = await Student.get_or_create(
        name="Ivan", surname="Ivanov", phone="1234567890",
        email="a@b.com", average_score=4.0, scholarship=True
    )

    await student.received_books.add(anna_karenina, war_and_peace)

    async for book in student.received_books:
        print(book.name)

    await Tortoise.close_connections()


if __name__ == '__main__':
    asyncio.run(main())

Ends with an exception:

tortoise.exceptions.OperationalError: table receiving_books has no column named custom_books_id

Since the names for relations are created: student_id and book_id, according to the names described in the model, in the format [association_model_field_name]_id, while they are requested in a different format [relation_table_name]_id - for the field, in which defines the relation and [association_model_field_name]_id for the second field.

This problem is solved by specifying the backward_key property in the relation definition, which is commented out in this example for demonstration purposes. But this is rather non-obvious behavior. In the event that the associated table needs to be expanded with additional data, as in this example, the source of the problem becomes unclear, since it is not clear where custom_books_id came from, especially when looking at a table whose columns are marked as described in the model:

Since the most expected behavior is for the developer to be unaware of these subtleties and expect the code to work as described, is it possible to make this situation more consistent?