nsj-rest-lib2 0.0.18__py3-none-any.whl → 0.0.20__py3-none-any.whl

nsj_rest_lib2/compiler/compiler.py

@@ -12,9 +12,15 @@ from nsj_rest_lib2.compiler.edl_model.entity_model_base import EntityModelBase
 from nsj_rest_lib2.compiler.edl_model.entity_model_root import EntityModelRoot
 from nsj_rest_lib2.compiler.edl_model.primitives import REGEX_EXTERNAL_REF
 from nsj_rest_lib2.compiler.entity_compiler import EntityCompiler
-from nsj_rest_lib2.compiler.model import CompilerResult
+from nsj_rest_lib2.compiler.model import CompilerResult, RelationDependency
 from nsj_rest_lib2.compiler.property_compiler import EDLPropertyCompiler
 
+from nsj_rest_lib2.compiler.util.type_naming_util import (
+    compile_dto_class_name,
+    compile_entity_class_name,
+    compile_namespace_keys,
+)
+
 from nsj_rest_lib2.compiler.edl_model.entity_model import EntityModel
 
 from nsj_rest_lib2.settings import get_logger
@@ -96,6 +102,27 @@ class EDLCompiler:
         if not escopo:
             raise Exception(f"Escopo não definido para a entidade: {entity_model.id}.")
 
+        # Tratando dos dados base para a extensão parcial
+        partial_metadata: dict[str, str] | None = None
+        partial_base_model: EntityModel | None = None
+        if isinstance(entity_model, EntityModel) and entity_model.partial_of:
+            if entity_model.partial_of not in entity_models:
+                raise Exception(
+                    f"Entidade base '{entity_model.partial_of}' não encontrada para a extensão parcial '{entity_model.id}'."
+                )
+
+            base_model_candidate = entity_models[entity_model.partial_of]
+            if not isinstance(base_model_candidate, EntityModel):
+                raise Exception(
+                    f"Entidade base '{entity_model.partial_of}' da extensão parcial '{entity_model.id}' é inválida."
+                )
+
+            self._validate_partial_model(entity_model, base_model_candidate, entity_models)
+            partial_metadata = self._build_partial_metadata(
+                entity_model, base_model_candidate
+            )
+            partial_base_model = base_model_candidate
+
         # Criando um mapa de índices por nome de property
         # TODO Implementar tratamento dos índices de apoio às query (não de unicidade)
         map_indexes_by_property: dict[str, list[IndexCompilerStructure]] = {}
@@ -131,6 +158,18 @@ class EDLCompiler:
             prefx_class_name,
         )
 
+        # Adicionando os imports da extensão parcial
+        if partial_metadata:
+            related_imports.append(
+                (
+                    partial_metadata["module"],
+                    partial_metadata["dto_class"],
+                    partial_metadata["entity_class"],
+                )
+            )
+
+        related_imports = self._deduplicate_related_imports(related_imports)
+
         # Gerando o buffer para os códigos de DTO e Entity
         dto_code = ""
         entity_code = ""
@@ -175,6 +214,7 @@ class EDLCompiler:
             related_imports,
             fixed_filters,
             prefx_class_name,
+            partial_metadata,
         )
 
         # Gerando o código da Entity
@@ -183,13 +223,29 @@ class EDLCompiler:
             ast_entity_attributes,
             props_pk,
             prefx_class_name,
+            partial_metadata,
         )
 
         # Extendendo os buffers com os códigos gerados
         dto_code += code_dto
         entity_code += code_entity
+
+        # Adicionando as dependências das relações
         relations_dependencies_complete.extend(relations_dependencies)
 
+        # Adicionando as dependências da extensão parcial
+        if partial_metadata and partial_base_model:
+            relation_dependency = RelationDependency()
+            if not partial_base_model.api or not partial_base_model.api.resource:
+                raise Exception(
+                    f"Entidade base '{partial_base_model.id}' não possui configuração de API necessária para extensão parcial."
+                )
+            relation_dependency.entity_resource = partial_base_model.api.resource
+            relation_dependency.entity_scope = partial_base_model.escopo
+            relation_dependency.tenant = partial_base_model.tenant
+            relation_dependency.grupo_empresarial = partial_base_model.grupo_empresarial
+            relations_dependencies_complete.append(relation_dependency)
+
         # Construindo o resultado
         compiler_result = CompilerResult()
         compiler_result.entity_class_name = entity_class_name
@@ -212,6 +268,138 @@ class EDLCompiler:
 
         return compiler_result
 
+    def _validate_partial_model(
+        self,
+        partial_model: EntityModel,
+        base_model: EntityModel,
+        entity_models: dict[str, EntityModel],
+    ) -> None:
+        base_properties_structure = PropertiesCompilerStructure()
+        self._make_properties_structures(
+            base_properties_structure,
+            base_model,
+            entity_models,
+        )
+        aggregated_base_properties = set(base_properties_structure.properties.keys())
+
+        duplicated_properties = aggregated_base_properties.intersection(
+            set(partial_model.properties.keys())
+        )
+        if duplicated_properties:
+            raise Exception(
+                f"Extensão parcial '{partial_model.id}' redefine propriedades da entidade base '{base_model.id}': {sorted(duplicated_properties)}."
+            )
+
+        lists_to_check = {
+            "required": partial_model.required,
+            "main_properties": partial_model.main_properties,
+            "partition_data": partial_model.partition_data,
+            "search_properties": partial_model.search_properties,
+            "metric_label": partial_model.metric_label,
+        }
+
+        for list_name, values in lists_to_check.items():
+            if not values:
+                continue
+
+            conflicts = [
+                value
+                for value in values
+                if isinstance(value, str) and value in aggregated_base_properties
+            ]
+            if conflicts:
+                raise Exception(
+                    f"Extensão parcial '{partial_model.id}' utiliza propriedades da entidade base '{base_model.id}' em '{list_name}': {conflicts}."
+                )
+
+        link = partial_model.repository.link_to_base
+        if not link:
+            raise Exception(
+                f"Extensão parcial '{partial_model.id}' requer configuração 'link_to_base' no bloco 'repository'."
+            )
+
+        if not link.base_property:
+            raise Exception(
+                f"Extensão parcial '{partial_model.id}' requer 'base_property' definido em 'link_to_base'."
+            )
+
+        if not link.column:
+            raise Exception(
+                f"Extensão parcial '{partial_model.id}' requer 'column' definido em 'link_to_base'."
+            )
+
+        if link.base_property not in aggregated_base_properties:
+            raise Exception(
+                f"'base_property' '{link.base_property}' não corresponde a uma propriedade da entidade base '{base_model.id}'."
+            )
+
+        # if not base_model.api or not base_model.api.resource:
+        #     raise Exception(
+        #         f"Entidade base '{base_model.id}' não possui configuração de API compatível com extensões parciais."
+        #     )
+
+    def _build_partial_metadata(
+        self, partial_model: EntityModel, base_model: EntityModel
+    ) -> dict[str, str]:
+        link = partial_model.repository.link_to_base
+        if link is None:
+            raise Exception(
+                f"Extensão parcial '{partial_model.id}' está sem configuração 'link_to_base'."
+            )
+
+        grupo_key, tenant_key, default_key = compile_namespace_keys(
+            base_model.tenant, base_model.grupo_empresarial
+        )
+        namespace = self._resolve_namespace_key(
+            base_model.tenant,
+            base_model.grupo_empresarial,
+            grupo_key,
+            tenant_key,
+            default_key,
+        )
+
+        return {
+            "module": namespace,
+            "dto_class": compile_dto_class_name(base_model.id),
+            "entity_class": compile_entity_class_name(base_model.id),
+            "relation_field": link.column,
+            "related_entity_field": link.base_property,
+        }
+
+    def _resolve_namespace_key(
+        self,
+        tenant: str | int | None,
+        grupo_empresarial,
+        grupo_key: str,
+        tenant_key: str,
+        default_key: str,
+    ) -> str:
+        has_tenant = tenant not in (None, 0, "0")
+        has_grupo = (
+            grupo_empresarial
+            and str(grupo_empresarial) != "00000000-0000-0000-0000-000000000000"
+        )
+
+        if has_tenant and has_grupo:
+            return grupo_key
+        if has_tenant:
+            return tenant_key
+        return default_key
+
+    def _deduplicate_related_imports(
+        self, related_imports: list[tuple[str, str, str]]
+    ) -> list[tuple[str, str, str]]:
+        deduped: list[tuple[str, str, str]] = []
+        seen: set[tuple[str, str, str]] = set()
+
+        for import_tuple in related_imports:
+            if import_tuple in seen:
+                continue
+            seen.add(import_tuple)
+            deduped.append(import_tuple)
+
+        return deduped
+
     def _make_components_structures(
         self,
         components_structure: ComponentsCompilerStructure,
@@ -290,7 +478,35 @@ class EDLCompiler:
         # Populando com as propriedades da entidade atual
         properties_structure.properties.update(entity_model.properties)
         if entity_model.main_properties:
-            properties_structure.main_properties.extend(entity_model.main_properties)
+            for main_property in entity_model.main_properties:
+                if not isinstance(main_property, str):
+                    continue
+
+                if "/" in main_property:
+                    path_parts = [
+                        part.strip() for part in main_property.split("/") if part
+                    ]
+                    if len(path_parts) < 2 or not path_parts[0]:
+                        raise Exception(
+                            f"Propriedade resumo inválida '{main_property}' na entidade '{entity_model.id}'."
+                        )
+
+                    relation_name = path_parts[0]
+                    resume_path_parts = path_parts[1:]
+                    resume_field = ".".join(resume_path_parts)
+
+                    if relation_name not in properties_structure.main_properties:
+                        properties_structure.main_properties.append(relation_name)
+
+                    resume_fields = properties_structure.main_resume_fields.setdefault(
+                        relation_name, []
+                    )
+
+                    if resume_field and resume_field not in resume_fields:
+                        resume_fields.append(resume_field)
+                else:
+                    if main_property not in properties_structure.main_properties:
+                        properties_structure.main_properties.append(main_property)
         if entity_model.required:
             properties_structure.required.extend(entity_model.required)
         if entity_model.partition_data:
@@ -404,6 +620,10 @@ class EDLCompiler:
         if entity_model.trait_from:
             entities.append(entity_model.trait_from)
 
+        # Adicionando dependências por classes parciais
+        if isinstance(entity_model, EntityModel) and entity_model.partial_of:
+            entities.append(entity_model.partial_of)
+
         # Populando com as dependências de propriedades de relacionamento
         relations = self._list_dependencies_relations(entity_model)
 
@@ -486,19 +706,19 @@ if __name__ == "__main__":
     compiler = EDLCompiler()
     compiler_results = compiler.compile_models(entities)
 
-    for compiler_result in compiler_results:
-        print("==========================================================")
-        print(f"Entity: {compiler_result.entity_class_name}")
-        print(f"{compiler_result.entity_code}")
-        print("\n")
-        print("==========================================================")
-        print(f"DTO: {compiler_result.dto_class_name}")
-        print(f"{compiler_result.dto_code}")
-        print("\n")
-
-        print("==========================================================")
-        print("API Expose: ", compiler_result.api_expose)
-        print("API Route Path: ", compiler_result.api_resource)
-        print("API Verbs: ", compiler_result.api_verbs)
-        print("==========================================================")
-        print("\n")
+    with open("output_compilacao_local.py", "w") as f:
+        for compiler_result in compiler_results:
+            f.write("==========================================================\n")
+            f.write(f"Entity: {compiler_result.entity_class_name}\n")
+            f.write(f"{compiler_result.entity_code}\n")
+            f.write("\n")
+            f.write("==========================================================\n")
+            f.write(f"DTO: {compiler_result.dto_class_name}\n")
+            f.write(f"{compiler_result.dto_code}\n")
+            f.write("\n")
+            f.write("==========================================================\n")
+            f.write(f"API Expose: {compiler_result.api_expose}\n")
+            f.write(f"API Route Path: {compiler_result.api_resource}\n")
+            f.write(f"API Verbs: {compiler_result.api_verbs}\n")
+            f.write("==========================================================\n")
+            f.write("\n")

nsj_rest_lib2/compiler/compiler_structures.py

@@ -18,6 +18,7 @@ class PropertiesCompilerStructure:
     def __init__(self) -> None:
         self.properties: dict[str, PropertyMetaModel] = {}
         self.main_properties: list[str] = []
+        self.main_resume_fields: dict[str, list[str]] = {}
         self.required: list[str] = []
         self.partition_data: list[str] = []
         self.search_properties: list[str] = []

nsj_rest_lib2/compiler/dto_compiler.py

@@ -20,6 +20,7 @@ class DTOCompiler:
         related_imports: list[tuple[str, str, str]],
         fixed_filters: list[tuple[str, BasicTypes]],
         prefx_class_name: str,
+        partial_metadata: dict[str, str] | None,
     ) -> tuple[str, str]:
         """
         Compila o código do DTO a partir do AST e retorna o código compilado.
@@ -110,15 +111,42 @@ class DTOCompiler:
                 )
             )
 
+        # Keywords para a extensão parcial
+        decorator_keywords: list[ast.keyword] = []
+
+        if partial_metadata:
+            partial_dict_keys = [
+                ast.Constant(value="dto"),
+                ast.Constant(value="relation_field"),
+            ]
+            partial_dict_values = [
+                ast.Name(id=partial_metadata["dto_class"], ctx=ast.Load()),
+                ast.Constant(value=partial_metadata["relation_field"]),
+            ]
+
+            related_field = partial_metadata.get("related_entity_field")
+            if related_field:
+                partial_dict_keys.append(ast.Constant(value="related_entity_field"))
+                partial_dict_values.append(ast.Constant(value=related_field))
+
+            decorator_keywords.append(
+                ast.keyword(
+                    arg="partial_of",
+                    value=ast.Dict(
+                        keys=partial_dict_keys,
+                        values=partial_dict_values,
+                    ),
+                )
+            )
+
         # Keywords para tipos usados em fixed_filters
-        keywords_decorator_dto = []
-        for fixed_filter in fixed_filters:
-            keywords_decorator_dto.append(
+        if fixed_filters:
+            decorator_keywords.append(
                 ast.keyword(
                     arg="fixed_filters",
                     value=ast.Dict(
-                        keys=[ast.Constant(value=fixed_filter[0])],
-                        values=[ast.Constant(value=fixed_filter[1])],
+                        keys=[ast.Constant(value=item[0]) for item in fixed_filters],
+                        values=[ast.Constant(value=item[1]) for item in fixed_filters],
                     ),
                 )
             )
@@ -133,7 +161,7 @@ class DTOCompiler:
                 ast.Call(
                     func=ast.Name(id="DTO", ctx=ast.Load()),
                     args=[],
-                    keywords=keywords_decorator_dto,
+                    keywords=decorator_keywords,
                 )
             ],
             body=ast_dto_attributes,

nsj_rest_lib2/compiler/edl_model/entity_model_base.py

@@ -29,6 +29,10 @@ class EntityModelBase(BaseModel):
     trait_from: Optional[str] = Field(
         None, description="Identificador da entidade que a trait estende."
     )
+    partial_of: Optional[str] = Field(
+        None,
+        description="Identificador da entidade base estendida por esta extensão parcial (relacionamento 1x1 transparente).",
+    )
     mixins: Optional[List[str]] = Field(
         None,
         description="Lista de mixins (blocos reutilizáveis) aplicados ao modelo.",

nsj_rest_lib2/compiler/edl_model/repository_model.py

@@ -5,6 +5,25 @@ from nsj_rest_lib2.compiler.edl_model.column_meta_model import ColumnMetaModel
 from nsj_rest_lib2.compiler.edl_model.index_model import IndexModel
 
 
+class RepositoryLinkToBaseModel(BaseModel):
+    base_property: str = Field(
+        ...,
+        description="Nome da propriedade na entidade base utilizada para o relacionamento 1x1.",
+    )
+    column: str = Field(
+        ...,
+        description="Nome da coluna (ou propriedade) na entidade parcial responsável por referenciar a entidade base.",
+    )
+    on_delete: Optional[str] = Field(
+        None,
+        description="Política de exclusão configurada no relacionamento com a entidade base.",
+    )
+    nullable: Optional[bool] = Field(
+        False,
+        description="Indica se o relacionamento com a entidade base pode ser nulo.",
+    )
+
+
 class RepositoryModel(BaseModel):
     map: str = Field(
         ..., description="Nome da tabela, no BD, para a qual a entidade é mapeada."
@@ -22,3 +41,7 @@ class RepositoryModel(BaseModel):
     indexes: Optional[List[IndexModel]] = Field(
         None, description="Lista de índices de banco de dados, associados à entidade."
     )
+    link_to_base: Optional[RepositoryLinkToBaseModel] = Field(
+        None,
+        description="Configuração de relacionamento 1x1 com a entidade base (extensões parciais).",
+    )

nsj_rest_lib2/compiler/entity_compiler.py

@@ -18,6 +18,7 @@ class EntityCompiler:
         ast_entity_attributes: list[ast.stmt],
         props_pk: list[str],
         prefix_class_name: str,
+        partial_metadata: dict[str, str] | None,
     ) -> tuple[str, str]:
         # Imports
         imports = [
@@ -39,25 +40,53 @@ class EntityCompiler:
             ),
         ]
 
+        if partial_metadata:
+            imports.append(
+                ast.ImportFrom(
+                    module=f"dynamic.{partial_metadata['module']}",
+                    names=[
+                        ast.alias(name=partial_metadata["entity_class"], asname=None)
+                    ],
+                    level=0,
+                )
+            )
+
         # Entity
         if len(props_pk) > 1:
             raise Exception(
                 f"Entidade '{entity_model.id}' possui mais de uma chave primária (ainda não suportado): {props_pk}"
             )
-        elif len(props_pk) <= 0:
+
+        if len(props_pk) == 0 and not partial_metadata:
             raise Exception(
                 f"Entidade '{entity_model.id}' não possui nenhuma chave primária (ainda não suportado)."
             )
 
         default_order_props = []
 
-        key_field = props_pk[0]
-        if entity_model.repository.properties:
-            if (
-                key_field in entity_model.repository.properties
-                and entity_model.repository.properties[key_field].column
-            ):
-                key_field = entity_model.repository.properties[props_pk[0]].column
+        # Resolvendo o nome da coluna da chave primária
+        if len(props_pk) == 1:
+            key_field_property = props_pk[0]
+        else:
+            key_field_property = (
+                partial_metadata["relation_field"] if partial_metadata else None
+            )
+
+        key_field = key_field_property
+        if (
+            len(props_pk) == 1
+            and entity_model.repository.properties
+            and key_field_property in entity_model.repository.properties
+            and entity_model.repository.properties[key_field_property].column
+        ):
+            key_field = entity_model.repository.properties[key_field_property].column
+        elif partial_metadata and partial_metadata.get("relation_field"):
+            key_field = partial_metadata["relation_field"]
+
+        if key_field is None:
+            raise Exception(
+                f"Não foi possível determinar a chave primária para a entidade '{entity_model.id}'."
+            )
 
         if (
             isinstance(entity_model, EntityModel)
@@ -90,28 +119,9 @@ class EntityCompiler:
                 ast.Call(
                     func=ast.Name(id="Entity", ctx=ast.Load()),
                     args=[],
-                    keywords=[
-                        ast.keyword(
-                            arg="table_name",
-                            value=ast.Constant(value=entity_model.repository.map),
-                        ),
-                        ast.keyword(
-                            arg="pk_field",
-                            value=ast.Constant(
-                                value=CompilerStrUtil.to_snake_case(key_field)
-                            ),
-                        ),
-                        ast.keyword(
-                            arg="default_order_fields",
-                            value=ast.List(
-                                elts=[
-                                    ast.Constant(value=field)
-                                    for field in default_order_fields
-                                ],
-                                ctx=ast.Load(),
-                            ),
-                        ),
-                    ],
+                    keywords=self._build_entity_decorator_keywords(
+                        entity_model, key_field, default_order_fields, partial_metadata
+                    ),
                 )
             ],
             body=ast_entity_attributes,
@@ -131,3 +141,50 @@ class EntityCompiler:
         code = black.format_str(code, mode=black.FileMode())
 
         return (class_name, code)
+
+    def _build_entity_decorator_keywords(
+        self,
+        entity_model: EntityModelBase,
+        key_field: str,
+        default_order_fields: list[str],
+        partial_metadata: dict[str, str] | None,
+    ) -> list[ast.keyword]:
+        keywords = [
+            ast.keyword(
+                arg="table_name",
+                value=ast.Constant(value=entity_model.repository.map),
+            ),
+        ]
+
+        if not partial_metadata:
+            keywords.extend(
+                [
+                    ast.keyword(
+                        arg="pk_field",
+                        value=ast.Constant(
+                            value=CompilerStrUtil.to_snake_case(key_field)
+                        ),
+                    ),
+                    ast.keyword(
+                        arg="default_order_fields",
+                        value=ast.List(
+                            elts=[
+                                ast.Constant(value=field)
+                                for field in default_order_fields
+                            ],
+                            ctx=ast.Load(),
+                        ),
+                    ),
+                ]
+            )
+
+        if partial_metadata:
+            keywords.insert(
+                0,
+                ast.keyword(
+                    arg="partial_of",
+                    value=ast.Name(id=partial_metadata["entity_class"], ctx=ast.Load()),
+                ),
+            )
+
+        return keywords

nsj_rest_lib2/compiler/property_compiler.py

@@ -64,12 +64,16 @@ class EDLPropertyCompiler:
                 if prop.pk:
                     pk_keys.append(pkey)
 
+        is_partial_extension = (
+            isinstance(entity_model, EntityModel) and bool(entity_model.partial_of)
+        )
+
         if not entity_model.mixin:
             if len(pk_keys) > 1:
                 raise Exception(
                     f"Entidade '{entity_model.id}' possui mais de uma chave primária (ainda não suportado): {pk_keys}"
                 )
-            elif len(pk_keys) == 0:
+            elif len(pk_keys) == 0 and not is_partial_extension:
                 raise Exception(
                     f"Entidade '{entity_model.id}' não tem nenhuma chave primária (ainda não suportado)"
                 )
@@ -670,6 +674,18 @@ class EDLPropertyCompiler:
                 )
             )
 
+        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(),
+                    ),
+                )
+            )
+
         # Resolvendo a coluna usada no relacionamento
         if (
             not properties_structure.entity_properties
@@ -736,6 +752,18 @@ class EDLPropertyCompiler:
         ):
             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(

{nsj_rest_lib2-0.0.18.dist-info → nsj_rest_lib2-0.0.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nsj_rest_lib2
-Version: 0.0.18
+Version: 0.0.20
 Summary: Biblioteca para permitir a distribuição de rotas dinâmicas numa API, configuradas por meio de EDLs declarativos (em formato JSON).
 Home-page: https://github.com/Nasajon/nsj_rest_lib2
 Author: Nasajon Sistemas

{nsj_rest_lib2-0.0.18.dist-info → nsj_rest_lib2-0.0.20.dist-info}/RECORD

@@ -4,23 +4,23 @@ nsj_rest_lib2/redis_config.py,sha256=4KLcvYS3nJO7PMQgF6F9_j6r-TyqcS7TBbd3LEQuKDU
 nsj_rest_lib2/settings.py,sha256=Hn_o1HZmievnYb8D1kNT2Nq-OEjxbyNjOiOpbnFsMwE,367
 nsj_rest_lib2/compiler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nsj_rest_lib2/compiler/ai_compiler.py,sha256=shAtN4T0ai_52qh15L3mK1QbeC6glHOR6C3J3gj14II,9029
-nsj_rest_lib2/compiler/compiler.py,sha256=xz1xYP7mY1hqzuuwDo-ATlU1X-8ldhGmFwEIUtQbOeo,18638
-nsj_rest_lib2/compiler/compiler_structures.py,sha256=cgA4ldqOoBYH8qxS99G2hd5Tgo7M1yzN0O_VIVpw3TI,1378
-nsj_rest_lib2/compiler/dto_compiler.py,sha256=qK0LHmXAlY_snm6QncIO0S4GiRtHYgtd74xSodK8MQA,5670
-nsj_rest_lib2/compiler/entity_compiler.py,sha256=A0fiLFF7dGXM2uH5cknmAX-cQ-9nu4Ubujp-m5NmgYE,4780
+nsj_rest_lib2/compiler/compiler.py,sha256=K8npaE6BPs_Bxu3uSvB-hZF5JEIxgu4sVsKYqLk6wcI,27572
+nsj_rest_lib2/compiler/compiler_structures.py,sha256=a_DF_nU4VgCt0sWJI03Ky6fPHvoIM0cjMkwQb_dYv6Q,1437
+nsj_rest_lib2/compiler/dto_compiler.py,sha256=mvZo19owtpFTjanCE20T0jmBKjhKXIVUsnR5raiGoRM,6728
+nsj_rest_lib2/compiler/entity_compiler.py,sha256=-mDA1-dHKYp0umQi1A4GbA0F1hlaC-gQRqj69vkADC4,6536
 nsj_rest_lib2/compiler/model.py,sha256=QDBoM26qoZdiNcykl1nvXCrFDhg-6Q__QzVq6uY1QzE,1460
-nsj_rest_lib2/compiler/property_compiler.py,sha256=G4xY8cX9TU2c5oNLRRKlU4sQ4b4bzR2KAjBleQmrX6Y,40471
+nsj_rest_lib2/compiler/property_compiler.py,sha256=Kqo9c1AvAjBN-7A4PBvrrXRPkngogH7FUZ6-pMuf8TE,41460
 nsj_rest_lib2/compiler/edl_model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nsj_rest_lib2/compiler/edl_model/ai_entity_edl.py,sha256=664QBDcOgVnyfwtUOXO1W7AKaZhueBG335x5DuogruY,7644
 nsj_rest_lib2/compiler/edl_model/api_model.py,sha256=pH0Uiq_64AGvkHqwY44TrulWWZXbi6M0EKJWUhSqKj0,837
 nsj_rest_lib2/compiler/edl_model/column_meta_model.py,sha256=s0sEVkoW1hV2_hto1mws4XhzKGH_b4NzhaOiwFH25Ks,694
 nsj_rest_lib2/compiler/edl_model/entity_model.py,sha256=Yc6wvjsiwacmz796mZIU-i9hxzNV9yuLPdULGKYHNbM,854
-nsj_rest_lib2/compiler/edl_model/entity_model_base.py,sha256=7AVyxmYtwZYVm6hNXQm-EBO3LMYkMHPf1ZFQrt0wZ3Q,4160
+nsj_rest_lib2/compiler/edl_model/entity_model_base.py,sha256=eRn0pirIPHvniqGpT0xE-mmgqz5RIVtqghxcnfxKNdQ,4345
 nsj_rest_lib2/compiler/edl_model/entity_model_root.py,sha256=VinsxFlNyCaKKk37ZzcbmWaWgoUP2-dZBG61Ke7NvVs,231
 nsj_rest_lib2/compiler/edl_model/index_model.py,sha256=cXWlu0hxtro5vvYoirkDW4R3PCnBW5oCCWjRJ6AX5zE,508
 nsj_rest_lib2/compiler/edl_model/primitives.py,sha256=GTo8e1mf9munvl_J1-fmaXgSJ8yQvGX56f2rwS85M1Y,1459
 nsj_rest_lib2/compiler/edl_model/property_meta_model.py,sha256=ie3roNZAqYTwz7q0TTdceMjY5khnBiED2yp0XBqqk7E,3909
-nsj_rest_lib2/compiler/edl_model/repository_model.py,sha256=Vt1HxlaoifP4w5ij1laKDkD1-COBihE8EX1HkdEDUSo,977
+nsj_rest_lib2/compiler/edl_model/repository_model.py,sha256=OmtUzSq2LKmM76VXefGrKwg8xtVFCutt3JNH2nv42qU,1821
 nsj_rest_lib2/compiler/edl_model/trait_property_meta_model.py,sha256=NtMVZeOPu3LJwXI-8tCOLVuQiGua_0t7kL1h9gL7HuM,657
 nsj_rest_lib2/compiler/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nsj_rest_lib2/compiler/util/str_util.py,sha256=lVP1yHhj1pOd6ULtTnkcfX6Gqrpe4yCBratHUhBNGcI,843
@@ -30,7 +30,7 @@ nsj_rest_lib2/controller/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 nsj_rest_lib2/controller/dynamic_controller.py,sha256=XMqxe1NW-NE5XwomXb4pSNdALQHpP74Hc26R4fnmXqg,15194
 nsj_rest_lib2/service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nsj_rest_lib2/service/entity_loader.py,sha256=uB0xXih9Px2jSTMdZNIu6_3dngE37K7adKX03cYSRug,15660
-nsj_rest_lib2-0.0.18.dist-info/METADATA,sha256=5HB_H5qhmsBFRU6DI9uMmXYyzLobZe-2aLUMFIMM_qc,1585
-nsj_rest_lib2-0.0.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nsj_rest_lib2-0.0.18.dist-info/top_level.txt,sha256=L6zh0EfH8_rur7OJ8_V-El-XEMf4qg3bkF8ADgqLVIA,14
-nsj_rest_lib2-0.0.18.dist-info/RECORD,,
+nsj_rest_lib2-0.0.20.dist-info/METADATA,sha256=SC3lNUvvmPq0kvWSdMfvbyzpo0jOTGY0VrVGR7bhBLU,1585
+nsj_rest_lib2-0.0.20.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nsj_rest_lib2-0.0.20.dist-info/top_level.txt,sha256=L6zh0EfH8_rur7OJ8_V-El-XEMf4qg3bkF8ADgqLVIA,14
+nsj_rest_lib2-0.0.20.dist-info/RECORD,,