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

nsj_rest_lib2/compiler/property_compiler.py

@@ -18,6 +18,7 @@ from nsj_rest_lib2.compiler.edl_model.primitives import (
     STR_BASED_TYPES,
 )
 from nsj_rest_lib2.compiler.edl_model.property_meta_model import PropertyMetaModel
+from nsj_rest_lib2.compiler.function_model import FunctionBindingConfig
 from nsj_rest_lib2.compiler.edl_model.trait_property_meta_model import (
     TraitPropertyMetaModel,
 )
@@ -41,6 +42,7 @@ class EDLPropertyCompiler:
         entity_model: EntityModelBase,
         entity_models: dict[str, EntityModel],
         prefx_class_name: str,
+        function_bindings: FunctionBindingConfig | None = None,
     ) -> tuple[
         list[ast.stmt],
         list[ast.stmt],
@@ -76,6 +78,9 @@ class EDLPropertyCompiler:
 
         # pk_key = pk_keys[0]
 
+        function_bindings = function_bindings or FunctionBindingConfig()
+        self._function_bindings = function_bindings
+
         # Instanciando as listas de retorno
         ast_dto_attributes = []
         ast_entity_attributes = []
@@ -433,6 +438,50 @@ class EDLPropertyCompiler:
             ),
         ]
 
+        insert_binding = self._function_bindings.insert_relations.get(pkey)
+        if insert_binding:
+            if (
+                insert_binding.field_name
+                and insert_binding.field_name != CompilerStrUtil.to_snake_case(pkey)
+            ):
+                keywords.append(
+                    ast.keyword(
+                        arg="insert_function_field",
+                        value=ast.Constant(value=insert_binding.field_name),
+                    )
+                )
+            if insert_binding.function_type_class:
+                keywords.append(
+                    ast.keyword(
+                        arg="insert_function_type",
+                        value=ast.Name(
+                            id=insert_binding.function_type_class, ctx=ast.Load()
+                        ),
+                    )
+                )
+
+        update_binding = self._function_bindings.update_relations.get(pkey)
+        if update_binding:
+            if (
+                update_binding.field_name
+                and update_binding.field_name != CompilerStrUtil.to_snake_case(pkey)
+            ):
+                keywords.append(
+                    ast.keyword(
+                        arg="update_function_field",
+                        value=ast.Constant(value=update_binding.field_name),
+                    )
+                )
+            if update_binding.function_type_class:
+                keywords.append(
+                    ast.keyword(
+                        arg="update_function_type",
+                        value=ast.Name(
+                            id=update_binding.function_type_class, ctx=ast.Load()
+                        ),
+                    )
+                )
+
         # Tratando das opções básicas do descritor de propriedade
         if properties_structure.required and pkey in properties_structure.required:
             keywords.append(ast.keyword(arg="not_null", value=ast.Constant(True)))
@@ -518,6 +567,50 @@ class EDLPropertyCompiler:
             ),
         ]
 
+        insert_binding = self._function_bindings.insert_relations.get(pkey)
+        if insert_binding:
+            if (
+                insert_binding.field_name
+                and insert_binding.field_name != CompilerStrUtil.to_snake_case(pkey)
+            ):
+                keywords.append(
+                    ast.keyword(
+                        arg="insert_function_field",
+                        value=ast.Constant(value=insert_binding.field_name),
+                    )
+                )
+            if insert_binding.function_type_class:
+                keywords.append(
+                    ast.keyword(
+                        arg="insert_function_type",
+                        value=ast.Name(
+                            id=insert_binding.function_type_class, ctx=ast.Load()
+                        ),
+                    )
+                )
+
+        update_binding = self._function_bindings.update_relations.get(pkey)
+        if update_binding:
+            if (
+                update_binding.field_name
+                and update_binding.field_name != CompilerStrUtil.to_snake_case(pkey)
+            ):
+                keywords.append(
+                    ast.keyword(
+                        arg="update_function_field",
+                        value=ast.Constant(value=update_binding.field_name),
+                    )
+                )
+            if update_binding.function_type_class:
+                keywords.append(
+                    ast.keyword(
+                        arg="update_function_type",
+                        value=ast.Name(
+                            id=update_binding.function_type_class, ctx=ast.Load()
+                        ),
+                    )
+                )
+
         # Tratando das opções básicas do descritor de propriedade
         if properties_structure.required and pkey in properties_structure.required:
             keywords.append(ast.keyword(arg="not_null", value=ast.Constant(True)))
@@ -861,6 +954,24 @@ class EDLPropertyCompiler:
                 )
             )
 
+        insert_binding = self._function_bindings.insert_fields.get(pkey)
+        if insert_binding:
+            keywords.append(
+                ast.keyword(
+                    arg="insert_function_field",
+                    value=ast.Constant(value=insert_binding),
+                )
+            )
+
+        update_binding = self._function_bindings.update_fields.get(pkey)
+        if update_binding:
+            keywords.append(
+                ast.keyword(
+                    arg="update_function_field",
+                    value=ast.Constant(value=update_binding),
+                )
+            )
+
         # Resolvendo o nome da propriedade no Entity
         if (
             properties_structure.entity_properties

nsj_rest_lib2/compiler/util/type_naming_util.py

@@ -1,4 +1,5 @@
 import uuid
+from typing import Iterable
 
 from nsj_rest_lib2.compiler.util.str_util import CompilerStrUtil
 
@@ -19,3 +20,24 @@ def compile_dto_class_name(entity_id: str, prefx_class_name: str = "") -> str:
 
 def compile_entity_class_name(entity_id: str, prefx_class_name: str = "") -> str:
     return f"{CompilerStrUtil.to_pascal_case(prefx_class_name)}{CompilerStrUtil.to_pascal_case(entity_id)}Entity"
+
+
+def compile_function_class_name(
+    entity_id: str,
+    prefx_class_name: str,
+    path_parts: Iterable[str],
+    operation: str,
+) -> str:
+    """
+    Gera o nome da classe para FunctionTypes (insert/update),
+    incorporando o caminho dos relacionamentos (quando houver).
+    """
+
+    suffix = "InsertType" if operation == "insert" else "UpdateType"
+    path_suffix = "".join(CompilerStrUtil.to_pascal_case(part) for part in path_parts)
+    return (
+        f"{CompilerStrUtil.to_pascal_case(prefx_class_name)}"
+        f"{CompilerStrUtil.to_pascal_case(entity_id)}"
+        f"{path_suffix}"
+        f"{suffix}"
+    )

nsj_rest_lib2/controller/dynamic_controller.py

@@ -94,6 +94,8 @@ def setup_dynamic_routes(
                     etities_dict,
                     api_expose,
                     api_verbs,
+                    _insert_function_class_name,
+                    _update_function_class_name,
                 ) = entity_loader.load_entity_source(
                     entity_resource,
                     tenant,
@@ -148,6 +150,8 @@ def setup_dynamic_routes(
                     etities_dict,
                     api_expose,
                     api_verbs,
+                    _insert_function_class_name,
+                    _update_function_class_name,
                 ) = entity_loader.load_entity_source(
                     entity_resource,
                     tenant,
@@ -201,6 +205,8 @@ def setup_dynamic_routes(
                     etities_dict,
                     api_expose,
                     api_verbs,
+                    insert_function_class_name,
+                    _update_function_class_name,
                 ) = entity_loader.load_entity_source(
                     entity_resource,
                     tenant,
@@ -214,12 +220,19 @@ def setup_dynamic_routes(
                     return ("", 405, {})
 
                 # Executando o list pelo RestLib
+                insert_function_type_class = (
+                    etities_dict.get(insert_function_class_name)
+                    if insert_function_class_name
+                    else None
+                )
+
                 route = PostRoute(
                     url=COLLECTION_DYNAMIC_ROUTE,
                     http_method="POST",
                     dto_class=etities_dict[dto_class_name],
                     entity_class=etities_dict[entity_class_name],
                     injector_factory=injector_factory,
+                    insert_function_type_class=insert_function_type_class,
                 )
 
                 return route.handle_request(*args, **kwargs)
@@ -254,6 +267,8 @@ def setup_dynamic_routes(
                     etities_dict,
                     api_expose,
                     api_verbs,
+                    _insert_function_class_name,
+                    update_function_class_name,
                 ) = entity_loader.load_entity_source(
                     entity_resource,
                     tenant,
@@ -267,12 +282,19 @@ def setup_dynamic_routes(
                     return ("", 405, {})
 
                 # Executando o list pelo RestLib
+                update_function_type_class = (
+                    etities_dict.get(update_function_class_name)
+                    if update_function_class_name
+                    else None
+                )
+
                 route = PutRoute(
                     url=ONE_DYNAMIC_ROUTE,
                     http_method="PUT",
                     dto_class=etities_dict[dto_class_name],
                     entity_class=etities_dict[entity_class_name],
                     injector_factory=injector_factory,
+                    update_function_type_class=update_function_type_class,
                 )
 
                 return route.handle_request(*args, **kwargs)
@@ -307,6 +329,8 @@ def setup_dynamic_routes(
                     etities_dict,
                     api_expose,
                     api_verbs,
+                    _insert_function_class_name,
+                    _update_function_class_name,
                 ) = entity_loader.load_entity_source(
                     entity_resource,
                     tenant,
@@ -360,6 +384,8 @@ def setup_dynamic_routes(
                     etities_dict,
                     api_expose,
                     api_verbs,
+                    _insert_function_class_name,
+                    _update_function_class_name,
                 ) = entity_loader.load_entity_source(
                     entity_resource,
                     tenant,

nsj_rest_lib2/service/entity_config_writer.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from typing import Any, Dict, Iterator, Optional
+
+from nsj_rest_lib2.compiler.edl_model.entity_model import EntityModel
+from nsj_rest_lib2.compiler.edl_model.entity_model_base import EntityModelBase
+from nsj_rest_lib2.compiler.model import CompilerResult
+from nsj_rest_lib2.compiler.util.type_naming_util import compile_namespace_keys
+from nsj_rest_lib2.redis_config import set_redis
+from nsj_rest_lib2.settings import ESCOPO_RESTLIB2
+
+
+class EntityConfigWriter:
+    """
+    Serializa o resultado da compilação e publica no Redis usando o mesmo
+    layout consumido pelo EntityLoader.
+    """
+
+    def __init__(self, escopo: str = ESCOPO_RESTLIB2) -> None:
+        self._escopo = escopo or ESCOPO_RESTLIB2
+
+    def publish(
+        self,
+        entity_model: EntityModelBase,
+        compiler_result: CompilerResult,
+        *,
+        entity_hash: str | None = None,
+    ) -> Dict[str, Any]:
+        """
+        Serializa e grava o resultado da compilação no Redis.
+
+        :return: Payload serializado (útil para inspeção/testes).
+        """
+
+        payload = self.build_payload(
+            entity_model, compiler_result, entity_hash=entity_hash
+        )
+        namespace_key = self._resolve_namespace_key(entity_model)
+        resource = self._resolve_resource(entity_model)
+
+        set_redis(
+            "entity_config",
+            self._escopo,
+            namespace_key,
+            resource,
+            json.dumps(payload, ensure_ascii=False),
+        )
+
+        return payload
+
+    def build_payload(
+        self,
+        entity_model: EntityModelBase,
+        compiler_result: CompilerResult,
+        *,
+        entity_hash: str | None = None,
+    ) -> Dict[str, Any]:
+        """
+        Constrói o dicionário serializável que representa a entidade compilada.
+        """
+
+        resource = self._resolve_resource(entity_model)
+        relations = [
+            rd.to_dict()
+            for rd in (compiler_result.relations_dependencies or [])
+        ]
+
+        return {
+            "dto_class_name": compiler_result.dto_class_name,
+            "entity_class_name": compiler_result.entity_class_name,
+            "insert_function_class_name": compiler_result.insert_function_class_name,
+            "source_insert_function": compiler_result.source_insert_function,
+            "update_function_class_name": compiler_result.update_function_class_name,
+            "source_update_function": compiler_result.source_update_function,
+            "source_dto": compiler_result.dto_code,
+            "source_entity": compiler_result.entity_code,
+            "entity_hash": entity_hash
+            if entity_hash is not None
+            else self._build_entity_hash(compiler_result),
+            "api_expose": compiler_result.api_expose,
+            "api_resource": resource,
+            "api_verbs": compiler_result.api_verbs or [],
+            "relations_dependencies": relations,
+        }
+
+    def _resolve_namespace_key(self, entity_model: EntityModelBase) -> str:
+        tenant = getattr(entity_model, "tenant", None)
+        grupo_empresarial = getattr(entity_model, "grupo_empresarial", None)
+
+        grupo_key, tenant_key, default_key = compile_namespace_keys(
+            tenant,
+            grupo_empresarial,
+        )
+
+        if (
+            tenant
+            and tenant != 0
+            and grupo_empresarial
+            and str(grupo_empresarial) != "00000000-0000-0000-0000-000000000000"
+        ):
+            return grupo_key
+        if tenant and tenant != 0:
+            return tenant_key
+        return default_key
+
+    def _resolve_resource(self, entity_model: EntityModelBase) -> str:
+        if not isinstance(entity_model, EntityModel) or not entity_model.api:
+            raise ValueError(
+                "EntityModel precisa possuir bloco de API para publicação no Redis."
+            )
+        if not entity_model.api.resource:
+            raise ValueError("api.resource é obrigatório para publicação no Redis.")
+        return entity_model.api.resource
+
+    def _build_entity_hash(self, compiler_result: CompilerResult) -> str:
+        hasher = hashlib.sha256()
+
+        for content in self._iter_hash_chunks(
+            compiler_result.dto_code,
+            compiler_result.entity_code,
+            compiler_result.source_insert_function,
+            compiler_result.source_update_function,
+        ):
+            hasher.update(content)
+
+        return hasher.hexdigest()
+
+    @staticmethod
+    def _iter_hash_chunks(*chunks: Optional[str]) -> Iterator[bytes]:
+        for chunk in chunks:
+            if chunk:
+                yield chunk.encode("utf-8")

nsj_rest_lib2/service/entity_loader.py

@@ -24,6 +24,8 @@ class LoadedEntity:
         self.api_expose: bool = False
         self.api_verbs: list[str] = []
         self.relations_dependencies: list[RelationDependency] = []
+        self.insert_function_class_name: str | None = None
+        self.update_function_class_name: str | None = None
 
 
 class Namespace:
@@ -48,7 +50,7 @@ class EntityLoader:
         grupo_empresarial: str | None,
         escopo: str = ESCOPO_RESTLIB2,
         force_reload: bool = False,
-    ) -> tuple[str, str, dict, bool, list[str]]:
+    ) -> tuple[str, str, dict, bool, list[str], str | None, str | None]:
         # Assumind o escopo default se necessário
         if not escopo:
             escopo = ESCOPO_RESTLIB2
@@ -77,6 +79,8 @@ class EntityLoader:
             api_expose = loaded_entity.api_expose
             api_verbs = loaded_entity.api_verbs
             relations_dependencies = loaded_entity.relations_dependencies
+            insert_function_class_name = loaded_entity.insert_function_class_name
+            update_function_class_name = loaded_entity.update_function_class_name
 
             # Verificando se alguma de suas dependências precisariam ser recarregadas
             for rd in relations_dependencies:
@@ -122,6 +126,8 @@ class EntityLoader:
                         entities_dict,
                         api_expose,
                         api_verbs,
+                        insert_function_class_name,
+                        update_function_class_name,
                     )
 
                 # Desempacotando resultado
@@ -143,6 +149,8 @@ class EntityLoader:
                         entities_dict,
                         api_expose,
                         api_verbs,
+                        insert_function_class_name,
+                        update_function_class_name,
                     )
                 else:
                     (
@@ -167,6 +175,8 @@ class EntityLoader:
                     entities_dict,
                     api_expose,
                     api_verbs,
+                    insert_function_class_name,
+                    update_function_class_name,
                 )
 
         # Se não conseguir recuperar a entidade, procura no redis:
@@ -195,9 +205,15 @@ class EntityLoader:
             raise RuntimeError(
                 f"Erro desconhecido carregando entidade: {entity_resource}"
             )
-        dto_class_name, entity_class_name, namespace, api_expose, api_verbs = (
-            result_execute
-        )
+        (
+            dto_class_name,
+            entity_class_name,
+            namespace,
+            api_expose,
+            api_verbs,
+            insert_function_class_name,
+            update_function_class_name,
+        ) = result_execute
 
         return (
             dto_class_name,
@@ -205,6 +221,8 @@ class EntityLoader:
             namespace.entities_dict,
             api_expose,
             api_verbs,
+            insert_function_class_name,
+            update_function_class_name,
         )
 
     def clear_namespaces(self):
@@ -235,7 +253,7 @@ class EntityLoader:
         entity_config_key: str,
         entity_resource: str,
         check_refresh: bool = False,
-    ) -> tuple[str, str, Namespace, bool, list[str]] | None:
+    ) -> tuple[str, str, Namespace, bool, list[str], str | None, str | None] | None:
         # Interpretando o json de configuração da entidade
         try:
             entity_config = json.loads(entity_config_str)
@@ -249,6 +267,14 @@ class EntityLoader:
             api_expose = entity_config["api_expose"]
             # api_resource = entity_config["api_resource"]
             api_verbs = entity_config["api_verbs"]
+            insert_function_class_name = entity_config.get(
+                "insert_function_class_name"
+            )
+            insert_function_code = entity_config.get("source_insert_function")
+            update_function_class_name = entity_config.get(
+                "update_function_class_name"
+            )
+            update_function_code = entity_config.get("source_update_function")
             relations_dependencies = [
                 RelationDependency().from_dict(rd)
                 for rd in entity_config.get("relations_dependencies", [])
@@ -331,6 +357,20 @@ class EntityLoader:
             get_logger().debug(f"Entity source:\n{source_entity}")
             get_logger().debug(f"DTO source:\n{source_dto}")
 
+            if insert_function_code:
+                self._safe_exec(
+                    insert_function_code,
+                    namespace.entities_dict,
+                    "Insert Function source",
+                )
+
+            if update_function_code:
+                self._safe_exec(
+                    update_function_code,
+                    namespace.entities_dict,
+                    "Update Function source",
+                )
+
             self._safe_exec(source_entity, namespace.entities_dict, "Entity source")
             self._safe_exec(source_dto, namespace.entities_dict, "DTO source")
 
@@ -342,10 +382,20 @@ class EntityLoader:
             loaded_entity.api_expose = api_expose
             loaded_entity.api_verbs = api_verbs
             loaded_entity.relations_dependencies = relations_dependencies
+            loaded_entity.insert_function_class_name = insert_function_class_name
+            loaded_entity.update_function_class_name = update_function_class_name
 
             namespace.loaded_entities[entity_resource] = loaded_entity
 
-        return (dto_class_name, entity_class_name, namespace, api_expose, api_verbs)
+        return (
+            dto_class_name,
+            entity_class_name,
+            namespace,
+            api_expose,
+            api_verbs,
+            insert_function_class_name,
+            update_function_class_name,
+        )
 
     def _safe_exec(self, source_code, context, description):
         try:

{nsj_rest_lib2-0.0.26.dist-info → nsj_rest_lib2-0.0.29.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nsj_rest_lib2
-Version: 0.0.26
+Version: 0.0.29
 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
@@ -12,7 +12,7 @@ Classifier: Topic :: Software Development :: Libraries
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.4
 Description-Content-Type: text/markdown
-Requires-Dist: nsj-rest-lib<5.0.0,>=4.9.0
+Requires-Dist: nsj-rest-lib<6.0.0,>=5.1.3
 Requires-Dist: redis<7.0.0,>=6.4.0
 Requires-Dist: nsj-multi-database-lib<3.0.0,>=2.0.1
 Requires-Dist: pydantic<3.0.0,>=2.11.9

{nsj_rest_lib2-0.0.26.dist-info → nsj_rest_lib2-0.0.29.dist-info}/RECORD

@@ -4,15 +4,17 @@ 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=vSA_hukm_l3WYjNn3UfDtydCxPEAVFPpfhUgmS-q3no,27056
+nsj_rest_lib2/compiler/compiler.py,sha256=8avORndGTPOlQO3-s8PkC3fsfCLsUzBW4Qfq-UaueEE,30403
 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/dto_compiler.py,sha256=ksZ2eYd_urrs6HBNK1m5_LhQhhq7i60GfSzD-AaF0fU,6743
 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=pJMZb2JPfle_svOixuGD1JUnQUYhlWrNiay2tmTgl0Q,43600
+nsj_rest_lib2/compiler/function_compiler.py,sha256=t5e_NoDB0IckiIEuYLsvk2lPSwrcrjL91s4LTQkpRqA,18085
+nsj_rest_lib2/compiler/function_model.py,sha256=iSKMlCSZDWlP_aTdlcbYQhsEAIMH-XbSJUU0-KNtLCs,2066
+nsj_rest_lib2/compiler/model.py,sha256=8UxzTvcNgZQdLwC592o8ZMVPhG3AloBCg5q2V72Up8U,1688
+nsj_rest_lib2/compiler/property_compiler.py,sha256=7cShFGtbZwSamyS9frSd_CebdmTmWLxpFDsq6vUqj80,47894
 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/api_model.py,sha256=7RpZkUGROZmTBh2psgTG_b3e4xxjc3uBr1EYb-wiAkc,3810
 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=eRn0pirIPHvniqGpT0xE-mmgqz5RIVtqghxcnfxKNdQ,4345
@@ -24,13 +26,14 @@ nsj_rest_lib2/compiler/edl_model/repository_model.py,sha256=OmtUzSq2LKmM76VXefGr
 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=0ReIQ2Vy4zAmVMvGv0FcUehRQw15hlz0e7yDsF89ghk,1178
-nsj_rest_lib2/compiler/util/type_naming_util.py,sha256=wTfxPCezCTt-ltSg_hkaYNH7Z05k-mlJKZd-9AMA9ac,768
+nsj_rest_lib2/compiler/util/type_naming_util.py,sha256=fPyzsEsbG9sgzaUJghamijcmZ6Odh_rIv3zk-lcP5pQ,1419
 nsj_rest_lib2/compiler/util/type_util.py,sha256=HTKOH4uRTOY0YgoM8oUv_6cEcReE_bgKYXFBsQCb-3A,357
 nsj_rest_lib2/controller/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nsj_rest_lib2/controller/dynamic_controller.py,sha256=xnTeJFWFTOKmCJz42npkRfWSvwoi2XJ6B4ufaMqrFsQ,17720
+nsj_rest_lib2/controller/dynamic_controller.py,sha256=UJtlr0_A6bGJ1gD24oj3481tCbJUgshLFuBRIU-eDEs,18878
 nsj_rest_lib2/service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nsj_rest_lib2/service/entity_loader.py,sha256=zzIWYiyhn51WPS9cmhj7Wysp8nBBCkZ5LBkhCRNHgL4,15844
-nsj_rest_lib2-0.0.26.dist-info/METADATA,sha256=W3kPqu6P66Ok375qtyEelyu-kiwd5h1fJZbltT9b0J0,1094
-nsj_rest_lib2-0.0.26.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nsj_rest_lib2-0.0.26.dist-info/top_level.txt,sha256=L6zh0EfH8_rur7OJ8_V-El-XEMf4qg3bkF8ADgqLVIA,14
-nsj_rest_lib2-0.0.26.dist-info/RECORD,,
+nsj_rest_lib2/service/entity_config_writer.py,sha256=DC8M4BYKfaOkNty1YFmAmWiNvENjvmiUqDKgsAV3eNc,4688
+nsj_rest_lib2/service/entity_loader.py,sha256=I8Ua2CPCxxUovHJn8SSRz0bYfmdFqfWj-JQfNTBBypc,17842
+nsj_rest_lib2-0.0.29.dist-info/METADATA,sha256=n4ENC9nHnSZETVqLpUKWLDM8qpf6U_nzpWpG9z1Af9w,1094
+nsj_rest_lib2-0.0.29.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nsj_rest_lib2-0.0.29.dist-info/top_level.txt,sha256=L6zh0EfH8_rur7OJ8_V-El-XEMf4qg3bkF8ADgqLVIA,14
+nsj_rest_lib2-0.0.29.dist-info/RECORD,,