nsj-rest-lib2 0.0.29__py3-none-any.whl → 0.0.31__py3-none-any.whl

nsj_rest_lib2/compiler/migration_compiler_alter_table.py

@@ -0,0 +1,201 @@
+from __future__ import annotations
+
+from typing import Any
+
+from nsj_rest_lib2.compiler.migration_compiler_util import MigrationCompilerUtil
+
+
+class MigrationCompilerAlterTable:
+    def compile(
+        self,
+        table_name: str,
+        column_specs: list[dict[str, Any]],
+        pk_columns: list[str],
+        rename_operations: list[tuple[str, str]] | None = None,
+        fk_specs: list[dict[str, str]] | None = None,
+    ) -> list[str]:
+        lines: list[str] = []
+        rename_operations = rename_operations or []
+        fk_specs = fk_specs or []
+
+        for old_col, new_col in rename_operations:
+            lines.append(
+                f"        IF exists_column('{table_name}', '{old_col}') AND NOT exists_column('{table_name}', '{new_col}') THEN"
+            )
+            lines.append(
+                f"            ALTER TABLE {table_name} RENAME COLUMN {old_col} TO {new_col};"
+            )
+            lines.append("        END IF;")
+
+        for spec in column_specs:
+            column_name = spec["column_name"]
+            default_literal = (
+                MigrationCompilerUtil.quote_literal(spec["default"])
+                if spec["default"] is not None
+                else None
+            )
+            default_literal_text = (
+                f"{default_literal}::text" if default_literal is not None else None
+            )
+            not_null_literal = "TRUE" if spec["not_null"] else "FALSE"
+
+            lines.append(f"        -- coluna {column_name}")
+            lines.append(
+                f"        IF NOT exists_column('{table_name}', '{column_name}') THEN"
+            )
+            lines.append(
+                MigrationCompilerUtil.indent_sql(
+                    self._build_add_column_sql(table_name, spec), 12
+                )[0]
+            )
+
+            self._append_enum_and_max_checks(lines, table_name, column_name, spec, 12)
+
+            if spec["description"]:
+                lines.append(
+                    "            "
+                    + MigrationCompilerUtil.comment_on_column(
+                        table_name, column_name, spec["description"]
+                    )
+                    + ";"
+                )
+
+            lines.append("        ELSE")
+
+            # Alteração de tipo
+            lines.append(
+                f"            IF NOT validate_column_properties('{table_name}', '{column_name}', '{spec['sql_type']}') THEN"
+            )
+            lines.append(
+                f"                ALTER TABLE {table_name} ALTER COLUMN {column_name} TYPE {spec['sql_type']};"
+            )
+            lines.append("            END IF;")
+
+            # Alteração de nulidade
+            lines.append(f"            IF {not_null_literal} THEN")
+            lines.append(
+                f"                IF NOT column_is_not_null('{table_name}', '{column_name}') THEN"
+            )
+            lines.append(
+                f"                    ALTER TABLE {table_name} ALTER COLUMN {column_name} SET NOT NULL;"
+            )
+            lines.append("                END IF;")
+            lines.append("            ELSE")
+            lines.append(
+                f"                IF column_is_not_null('{table_name}', '{column_name}') THEN"
+            )
+            lines.append(
+                f"                    ALTER TABLE {table_name} ALTER COLUMN {column_name} DROP NOT NULL;"
+            )
+            lines.append("                END IF;")
+            lines.append("            END IF;")
+
+            # Alteração de default
+            if default_literal is None:
+                lines.append(
+                    f"            IF column_default_expr('{table_name}', '{column_name}') IS NOT NULL THEN"
+                )
+                lines.append(
+                    f"                ALTER TABLE {table_name} ALTER COLUMN {column_name} DROP DEFAULT;"
+                )
+                lines.append("            END IF;")
+            else:
+                lines.append(
+                    f"            IF NOT column_default_equals('{table_name}', '{column_name}', {default_literal_text}) THEN"
+                )
+                lines.append(
+                    f"                ALTER TABLE {table_name} ALTER COLUMN {column_name} SET DEFAULT {default_literal};"
+                )
+                lines.append("            END IF;")
+
+            # Checks e comentários
+            self._append_enum_and_max_checks(lines, table_name, column_name, spec, 12)
+
+            if spec["description"]:
+                lines.append(
+                    "            "
+                    + MigrationCompilerUtil.comment_on_column(
+                        table_name, column_name, spec["description"]
+                    )
+                    + ";"
+                )
+
+            lines.append("        END IF;")
+
+        if pk_columns:
+            lines.append(f"        IF NOT table_has_primary_key('{table_name}') THEN")
+            lines.append(
+                f"            {MigrationCompilerUtil.add_primary_key(table_name, pk_columns)};"
+            )
+            lines.append("        END IF;")
+
+        for fk in fk_specs:
+            lines.append(
+                f"        IF NOT fk_constraint_matches('{table_name}', '{fk['column_name']}', '{fk['ref_table']}', '{fk['ref_column']}') THEN"
+            )
+            fk_constraint_name = MigrationCompilerUtil.check_constraint_name(
+                table_name, fk["column_name"], "fk"
+            )
+            lines.append(
+                f"            {MigrationCompilerUtil.drop_constraint_if_exists(table_name, fk_constraint_name)};"
+            )
+            lines.append(
+                f"            ALTER TABLE {table_name} ADD CONSTRAINT {fk_constraint_name} FOREIGN KEY ({fk['column_name']}) REFERENCES {fk['ref_table']}({fk['ref_column']});"
+            )
+            lines.append("        END IF;")
+
+        return lines
+
+    def _append_enum_and_max_checks(
+        self,
+        lines: list[str],
+        table_name: str,
+        column_name: str,
+        spec: dict[str, Any],
+        indent: int,
+    ) -> None:
+        if spec["enum_values"]:
+            formatted_values = ", ".join(
+                MigrationCompilerUtil.quote_literal(v) for v in spec["enum_values"]
+            )
+            lines.append(
+                f"{' ' * indent}IF NOT enum_constraint_matches('{table_name}', '{column_name}', ARRAY[{formatted_values}]) THEN"
+            )
+            lines.extend(
+                MigrationCompilerUtil.indent_sql(
+                    ";\n".join(
+                        MigrationCompilerUtil.add_enum_check_constraint(
+                            table_name, column_name, spec["enum_values"]
+                        )
+                    )
+                    + ";",
+                    indent + 4,
+                )
+            )
+            lines.append(f"{' ' * indent}END IF;")
+
+        if spec["maximum"] is not None and spec["is_numeric"]:
+            lines.append(
+                f"{' ' * indent}IF NOT max_constraint_matches('{table_name}', '{column_name}', {spec['maximum']}) THEN"
+            )
+            lines.extend(
+                MigrationCompilerUtil.indent_sql(
+                    ";\n".join(
+                        MigrationCompilerUtil.add_max_check_constraint(
+                            table_name, column_name, spec["maximum"]
+                        )
+                    )
+                    + ";",
+                    indent + 4,
+                )
+            )
+            lines.append(f"{' ' * indent}END IF;")
+
+    def _build_add_column_sql(self, table_name: str, spec: dict[str, Any]) -> str:
+        clause = f"ALTER TABLE {table_name} ADD COLUMN {spec['column_name']} {spec['sql_type']}"
+        if spec["not_null"]:
+            clause += " NOT NULL"
+        if spec["default"] is not None:
+            clause += f" DEFAULT {MigrationCompilerUtil.quote_literal(spec['default'])}"
+        clause += ";"
+        return clause

nsj_rest_lib2/compiler/migration_compiler_create_table.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from typing import Any
+
+from nsj_rest_lib2.compiler.migration_compiler_util import MigrationCompilerUtil
+
+
+class MigrationCompilerCreateTable:
+    def compile(
+        self,
+        table_name: str,
+        column_specs: list[dict[str, Any]],
+        pk_columns: list[str],
+        fk_specs: list[dict[str, str]],
+    ) -> str:
+        column_definitions: list[str] = []
+        for spec in column_specs:
+            col_def = f"{spec['column_name']} {spec['sql_type']}"
+            if spec["not_null"]:
+                col_def += " NOT NULL"
+            if spec["default"] is not None:
+                col_def += f" DEFAULT {MigrationCompilerUtil.quote_literal(spec['default'])}"
+            column_definitions.append(col_def)
+
+        if pk_columns:
+            pk_constraint = (
+                f"CONSTRAINT {table_name}_pkey PRIMARY KEY ({', '.join(pk_columns)})"
+            )
+            column_definitions.append(pk_constraint)
+
+        for fk in fk_specs:
+            fk_name = MigrationCompilerUtil.check_constraint_name(
+                table_name, fk["column_name"], "fk"
+            )
+            column_definitions.append(
+                f"CONSTRAINT {fk_name} FOREIGN KEY ({fk['column_name']}) REFERENCES {fk['ref_table']}({fk['ref_column']})"
+            )
+
+        columns_block = ",\n    ".join(column_definitions)
+        create_lines = [
+            f"CREATE TABLE {table_name} (",
+            f"    {columns_block}",
+            ");",
+        ]
+
+        for spec in column_specs:
+            if spec["description"]:
+                create_lines.append(
+                    MigrationCompilerUtil.comment_on_column(
+                        table_name, spec["column_name"], spec["description"]
+                    )
+                    + ";"
+                )
+
+            if spec["enum_values"]:
+                create_lines.extend(
+                    [
+                        stmt + ";"
+                        for stmt in MigrationCompilerUtil.add_enum_check_constraint(
+                            table_name, spec["column_name"], spec["enum_values"]
+                        )
+                    ]
+                )
+
+            if spec["maximum"] is not None and spec["is_numeric"]:
+                create_lines.extend(
+                    [
+                        stmt + ";"
+                        for stmt in MigrationCompilerUtil.add_max_check_constraint(
+                            table_name, spec["column_name"], spec["maximum"]
+                        )
+                    ]
+                )
+
+        return "\n".join(create_lines)

nsj_rest_lib2/compiler/migration_compiler_util.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+from typing import Any
+
+from nsj_rest_lib2.compiler.edl_model.primitives import PrimitiveTypes, PropertyType
+
+
+class MigrationCompilerUtil:
+    """
+    Funções utilitárias para montagem de trechos SQL usados nas migrações.
+    """
+
+    SQL_TYPE_MAP = {
+        PrimitiveTypes.STRING: "varchar(250)",
+        PrimitiveTypes.TEXT: "varchar",
+        PrimitiveTypes.NUMBER: "numeric(20,8)",
+        PrimitiveTypes.INTEGER: "integer",
+        PrimitiveTypes.BOOLEAN: "boolean",
+        PrimitiveTypes.UUID: "uuid",
+        PrimitiveTypes.CURRENCY: "numeric(20,4)",
+        PrimitiveTypes.QUANTITY: "numeric(20,4)",
+        PrimitiveTypes.CPF: "varchar(20)",
+        PrimitiveTypes.CNPJ: "varchar(20)",
+        PrimitiveTypes.CPF_CNPJ: "varchar(20)",
+        PrimitiveTypes.EMAIL: "varchar(100)",
+        PrimitiveTypes.DATE: "date",
+        PrimitiveTypes.DATETIME: "timestamp with time zone",
+        PrimitiveTypes.DURATION: "interval",
+    }
+
+    @staticmethod
+    def resolve_sql_type(datatype: PropertyType, max_length: int | None) -> str:
+        if not isinstance(datatype, PrimitiveTypes):
+            raise ValueError(f"Tipo de propriedade não suportado para SQL: {datatype}")
+
+        base_type = MigrationCompilerUtil.SQL_TYPE_MAP.get(datatype)
+        if not base_type:
+            raise ValueError(f"Tipo de propriedade não mapeado para SQL: {datatype}")
+
+        if datatype in (PrimitiveTypes.STRING, PrimitiveTypes.TEXT) and max_length:
+            return f"varchar({max_length})"
+
+        return base_type
+
+    @staticmethod
+    def is_numeric(datatype: PropertyType) -> bool:
+        if not isinstance(datatype, PrimitiveTypes):
+            return False
+        return datatype in (
+            PrimitiveTypes.NUMBER,
+            PrimitiveTypes.INTEGER,
+            PrimitiveTypes.CURRENCY,
+            PrimitiveTypes.QUANTITY,
+        )
+
+    @staticmethod
+    def quote_literal(value: Any) -> str:
+        if value is None:
+            return "null"
+        if isinstance(value, bool):
+            return "true" if value else "false"
+        if isinstance(value, (int, float)):
+            return str(value)
+        escaped = str(value).replace("'", "''")
+        return f"'{escaped}'"
+
+    @staticmethod
+    def comment_on_column(table_name: str, column_name: str, description: str) -> str:
+        escaped = description.replace("'", "''")
+        return (
+            f"COMMENT ON COLUMN {table_name}.{column_name} IS '{escaped}'"
+        )
+
+    @staticmethod
+    def drop_constraint_if_exists(table_name: str, constraint_name: str) -> str:
+        return f"ALTER TABLE {table_name} DROP CONSTRAINT IF EXISTS {constraint_name}"
+
+    @staticmethod
+    def check_constraint_name(table_name: str, column_name: str, suffix: str) -> str:
+        safe_table = table_name.replace(".", "_")
+        return f"{safe_table}_{column_name}_{suffix}"
+
+    @staticmethod
+    def add_enum_check_constraint(
+        table_name: str, column_name: str, values: list[Any]
+    ) -> list[str]:
+        statements: list[str] = []
+        constraint_name = MigrationCompilerUtil.check_constraint_name(
+            table_name, column_name, "enum_chk"
+        )
+        statements.append(
+            MigrationCompilerUtil.drop_constraint_if_exists(
+                table_name, constraint_name
+            )
+        )
+        if values:
+            formatted_values = ", ".join(
+                MigrationCompilerUtil.quote_literal(v) for v in values
+            )
+            statements.append(
+                f"ALTER TABLE {table_name} ADD CONSTRAINT {constraint_name} "
+                f"CHECK ({column_name} IN ({formatted_values}))"
+            )
+        return statements
+
+    @staticmethod
+    def add_max_check_constraint(
+        table_name: str, column_name: str, maximum: int | float
+    ) -> list[str]:
+        statements: list[str] = []
+        constraint_name = MigrationCompilerUtil.check_constraint_name(
+            table_name, column_name, "max_chk"
+        )
+        statements.append(
+            MigrationCompilerUtil.drop_constraint_if_exists(
+                table_name, constraint_name
+            )
+        )
+        statements.append(
+            f"ALTER TABLE {table_name} ADD CONSTRAINT {constraint_name} "
+            f"CHECK ({column_name} <= {maximum})"
+        )
+        return statements
+
+    @staticmethod
+    def add_primary_key(
+        table_name: str, column_names: list[str], constraint_name: str | None = None
+    ) -> str:
+        constraint = constraint_name or f"{table_name}_pkey"
+        columns = ", ".join(column_names)
+        return (
+            f"ALTER TABLE {table_name} "
+            f"ADD CONSTRAINT {constraint} PRIMARY KEY ({columns})"
+        )
+
+    @staticmethod
+    def drop_primary_key(table_name: str, constraint_name: str | None = None) -> str:
+        constraint = constraint_name or f"{table_name}_pkey"
+        return f"ALTER TABLE {table_name} DROP CONSTRAINT IF EXISTS {constraint}"
+
+    @staticmethod
+    def indent_sql(sql: str, spaces: int) -> list[str]:
+        prefix = " " * spaces
+        return [prefix + line if line else prefix for line in sql.split("\n")]

nsj_rest_lib2/compiler/property_compiler.py

@@ -1,6 +1,5 @@
 import ast
 import datetime
-import re
 import uuid
 
 from nsj_rest_lib2.compiler.compiler_structures import (
@@ -13,8 +12,6 @@ from nsj_rest_lib2.compiler.edl_model.primitives import (
     BasicTypes,
     CardinalityTypes,
     PrimitiveTypes,
-    REGEX_EXTERNAL_REF,
-    REGEX_INTERNAL_REF,
     STR_BASED_TYPES,
 )
 from nsj_rest_lib2.compiler.edl_model.property_meta_model import PropertyMetaModel
@@ -30,6 +27,7 @@ from nsj_rest_lib2.compiler.util.type_naming_util import (
     compile_namespace_keys,
 )
 from nsj_rest_lib2.compiler.util.type_util import TypeUtil
+from nsj_rest_lib2.compiler.util.relation_ref import RelationRef, RelationRefParser
 
 
 class EDLPropertyCompiler:
@@ -164,18 +162,15 @@ class EDLPropertyCompiler:
                     fixed_filters.append((pkey, trait_fixed_filters[pkey]))
 
             elif isinstance(prop.type, str):
-                # Tratando propriedade de relacionamento
-                external_match = re.match(REGEX_EXTERNAL_REF, prop.type)
-                internal_match = re.match(REGEX_INTERNAL_REF, prop.type)
-
-                if external_match:
-                    # Resolvendo o id da entidade
-                    related_entity_id = external_match.group(2)
-                    related_entity_key = external_match.group(0)
+                relation_ref = RelationRefParser.parse(prop.type)
+                if not relation_ref:
+                    raise Exception(
+                        f"Tipo da propriedade '{pkey}' não suportado: {prop.type}"
+                    )
 
+                if relation_ref.is_external:
                     self._compile_external_relation(
-                        related_entity_id,
-                        related_entity_key,
+                        relation_ref,
                         entity_model,
                         entity_models,
                         properties_structure,
@@ -187,11 +182,9 @@ class EDLPropertyCompiler:
                         prop,
                     )
 
-                elif internal_match:
-                    related_entity_id = internal_match.group(1)
-
+                elif relation_ref.ref_type == "internal":
                     self._compile_internal_relation(
-                        related_entity_id,
+                        relation_ref,
                         entity_model,
                         properties_structure,
                         target_dto_attributes,
@@ -277,8 +270,7 @@ class EDLPropertyCompiler:
 
     def _compile_external_relation(
         self,
-        related_entity_id: str,
-        related_entity_key: str,
+        relation_ref: RelationRef,
         entity_model: EntityModelBase,
         entity_models: dict[str, EntityModel],
         properties_structure: PropertiesCompilerStructure,
@@ -289,17 +281,22 @@ class EDLPropertyCompiler:
         pkey: str,
         prop: PropertyMetaModel,
     ):
-        # Resolvendo o nome das classes de DTO e Entity
-        related_dto_class_name = compile_dto_class_name(related_entity_id)
-        related_entity_class_name = compile_entity_class_name(related_entity_id)
+        related_entity_key = relation_ref.entity_key
+        if not related_entity_key:
+            raise Exception(
+                f"Entidade '{entity_model.id}' possui uma referência externa inválida em '{pkey}': {prop.type}"
+            )
 
-        # Resolvendo o caminho do import
         related_entity = entity_models.get(related_entity_key)
         if not related_entity:
             raise Exception(
                 f"Entidade '{entity_model.id}' possui uma referência externa para uma entidade inexistente: '{related_entity_key}', por meio da propriedade: '{pkey}'."
             )
 
+        related_dto_class_name, related_entity_class_name = (
+            self._resolve_related_class_names(relation_ref)
+        )
+
         tenant = related_entity.tenant
         grupo_empresarial = related_entity.grupo_empresarial
         grupo_key, tenant_key, default_key = compile_namespace_keys(
@@ -355,6 +352,7 @@ class EDLPropertyCompiler:
                 related_dto_class_name,
                 related_entity_class_name,
                 prop,
+                relation_type="AGGREGATION",
             )
 
         elif prop.cardinality == CardinalityTypes.CN_N:
@@ -365,9 +363,20 @@ class EDLPropertyCompiler:
                 f"Propriedade '{pkey}' da entidade '{entity_model.id}' possui cardinalidade inválida ou não suportada: {prop.cardinality}"
             )
 
+    def _resolve_related_class_names(
+        self, relation_ref: RelationRef
+    ) -> tuple[str, str]:
+        prefix = relation_ref.prefx_class_name
+        target_id = relation_ref.target_id
+
+        return (
+            compile_dto_class_name(target_id, prefix),
+            compile_entity_class_name(target_id, prefix),
+        )
+
     def _compile_internal_relation(
         self,
-        related_entity_id: str,
+        relation_ref: RelationRef,
         entity_model: EntityModelBase,
         properties_structure: PropertiesCompilerStructure,
         ast_dto_attributes: list[ast.stmt],
@@ -378,10 +387,10 @@ class EDLPropertyCompiler:
     ):
         # Resolvendo o nome das classes de DTO e Entity
         related_dto_class_name = compile_dto_class_name(
-            related_entity_id, f"{prefx_class_name}_{entity_model.id}"
+            relation_ref.entity, f"{prefx_class_name}_{entity_model.id}"
         )
         related_entity_class_name = compile_entity_class_name(
-            related_entity_id, f"{prefx_class_name}_{entity_model.id}"
+            relation_ref.entity, f"{prefx_class_name}_{entity_model.id}"
         )
 
         # Instanciando o ast
@@ -405,6 +414,7 @@ class EDLPropertyCompiler:
                 related_dto_class_name,
                 related_entity_class_name,
                 prop,
+                relation_type="COMPOSITION",
             )
 
         elif prop.cardinality == CardinalityTypes.CN_N:
@@ -558,8 +568,9 @@ class EDLPropertyCompiler:
         related_dto_class_name: str,
         related_entity_class_name: str,
         prop: PropertyMetaModel,
+        relation_type: str,
     ):
-        # Propriedade do property descriptor
+        # Keywords for DTOOneToOneField
         keywords = [
             ast.keyword(
                 arg="entity_type",
@@ -615,32 +626,13 @@ class EDLPropertyCompiler:
         if properties_structure.required and pkey in properties_structure.required:
             keywords.append(ast.keyword(arg="not_null", value=ast.Constant(True)))
 
+        # 'resume' now belongs to the inner DTOField (matches desired format)
         if (
             properties_structure.main_properties
             and pkey in properties_structure.main_properties
         ):
             keywords.append(ast.keyword(arg="resume", value=ast.Constant(True)))
 
-        resume_fields = properties_structure.main_resume_fields.get(pkey)
-        if resume_fields:
-            keywords.append(
-                ast.keyword(
-                    arg="resume_fields",
-                    value=ast.List(
-                        elts=[ast.Constant(value=field) for field in resume_fields],
-                        ctx=ast.Load(),
-                    ),
-                )
-            )
-
-        if prop.validator:
-            keywords.append(
-                ast.keyword(
-                    arg="validator",
-                    value=ast.Name(prop.validator, ctx=ast.Load()),
-                )
-            )
-
         # Resolvendo a coluna usada no relacionamento
         if (
             not properties_structure.entity_properties
@@ -659,13 +651,23 @@ class EDLPropertyCompiler:
         if "/" in relation_column:
             owner_relation = True
             relation_column = relation_column.split("/")[-1]
+        
 
-        # TODO Verificar, porque desconfio que o apontamento para a coluna de relacionamento
-        # para o caso do relacionamento OTHER, não é suportado pelo RestLib (acho que, quando
-        # o dono é OTHER, o RestLib sempre aponta para a PK da entidade corrente).
         keywords.append(
             ast.keyword(
-                arg="relation_field",
+                arg="relation_type",
+                value=ast.Attribute(
+                    value=ast.Name(id="OTORelationType", ctx=ast.Load()),
+                    attr=relation_type,
+                    ctx=ast.Load(),
+                ),
+            )
+        )
+            
+        # Build the inner field descriptor with the entity column mapping
+        keywords.append(
+            ast.keyword(
+                arg="entity_field",
                 value=ast.Constant(value=relation_column),
             )
         )
@@ -682,22 +684,18 @@ class EDLPropertyCompiler:
                 )
             )
         else:
-            dto_property_name = f"relation_1_1_self_column_{relation_column}"
-            # Adicionando propriedade, para o campo de relação, no DTO (quando for o dono da relação)
-            ast_dto_attributes.append(
-                self._build_dto_property_ast(
-                    dto_property_name,
-                    PrimitiveTypes.UUID,
-                    keywords=[
-                        ast.keyword(
-                            arg="entity_field",
-                            value=ast.Constant(value=relation_column),
-                        ),
-                    ],
+            # Dono da relação: informa explicitamente como SELF e garante o atributo na Entity
+            keywords.append(
+                ast.keyword(
+                    arg="entity_relation_owner",
+                    value=ast.Attribute(
+                        value=ast.Name(id="EntityRelationOwner", ctx=ast.Load()),
+                        attr="SELF",
+                        ctx=ast.Load(),
+                    ),
                 )
             )
-
-            # Adicionando propriedade, para o campo de relação, no Entity (quando for o dono da relação)
+            # Adicionando propriedade no Entity para a coluna de relação
             ast_entity_attributes.append(
                 self._build_entity_property_ast(relation_column, PrimitiveTypes.UUID)
             )
@@ -710,7 +708,7 @@ class EDLPropertyCompiler:
                 ctx=ast.Load(),
             ),
             value=ast.Call(
-                func=ast.Name(id="DTOObjectField", ctx=ast.Load()),
+                func=ast.Name(id="DTOOneToOneField", ctx=ast.Load()),
                 args=[],
                 keywords=keywords,
             ),