def transpile(self):
template = TypeScriptTemplate.open(templates.MODEL_TYPE_TEMPLATE_FILE)
source = template.render(
pk_field_name=self.pk_field_info.serializer_field_name,
pk_type=FieldTypeTranspiler.transpile(self.pk_field_info.serializer),
model_name=self.model_type.model_name,
queryset_name=model_queryset_name(self.model_type.model_cls),
field_interface_name=model_field_interface_name(self.model_type.model_cls),
# URLS
update_url=self._url_prefix + self.model_type.update_view.endpoint.url(TYPESCRIPT_THIS_PK_REF),
get_url=self._url_prefix + self.model_type.get_view.endpoint.url(TYPESCRIPT_ARG_PK_REF),
get_or_create_url=self._url_prefix + self.model_type.get_or_create_view.endpoint.url(),
create_url=self._url_prefix + self.model_type.create_view.endpoint.url(TYPESCRIPT_ARG_PK_REF),
# Todo: fix hacky
list_url=self._url_prefix + self.model_type.list_view.endpoint.url().replace('//', '/'),
delete_url=self._url_prefix + self.model_type.delete_view.endpoint.url(TYPESCRIPT_THIS_PK_REF),
# -----
model_interface_types=self.model_interface_types(),
model_class_types=self.model_class_types(),
lookups_interface_name=model_lookups_name(self.model_type.model_cls),
queryset_lookups=self.queryset_lookup_types(),
reverse_relations=self._reverse_relations(),
methods=self._methods(),
static_methods=self._static_methods(),
field_schemas=self.field_schemas(),
prefetch_type_name=model_prefetch_type_name(self.model_type.model_cls),
prefetch_type=self._prefetch_type_body()
)
return source
def field_type_declarations(self):
type_declarations = []
serializer_fields = self.serializer_cls().get_fields()
for field_name, field in serializer_fields.items():
type_declarations.append(
render_type_declaration(
name=field_name,
optional=field.allow_null,
readonly=field.read_only,
type_=FieldTypeTranspiler.transpile(field))
)
return "\n".join(type_declarations)
def serialized_type_declaration(self) -> str:
"""
Return the 'serialized' type declaration for this field. That is,
the type corresponding to the value that will be sent to the server
and serialized. These type declarations make of the body of a model's
field interface type.
"""
return render_type_declaration(
name=self.serializer_field_name,
optional=self.serializer_field.allow_null,
readonly=self.serializer_field.read_only,
type_=FieldTypeTranspiler.transpile(type_=self.serializer_field))
def lookup_declarations(self):
return [
render_type_declaration(name=self.model_field.get_attname(),
optional=True,
readonly=False,
type_=FieldTypeTranspiler.transpile(
self.serializer_field)),
render_type_declaration(
name=self.model_field.name,
optional=True,
readonly=False,
type_=model_lookups_name(
model_cls=self.model_field.related_model))
]
def serialized_type_declaration(self) -> str:
"""
Return the 'serialized' type declaration for this field. That is,
the type corresponding to the value that will be sent to the server
and serialized. These type declarations make of the body of a model's
field interface type.
"""
if self.serializer_field is None:
raise AssertionError("A serialized type declaration can only be generated "
"for fields with a corresponding `serializer_field`.")
return render_type_declaration(
name=self.serializer_field_name,
optional=self.serializer_field.allow_null,
readonly=self.serializer_field.read_only,
type_=FieldTypeTranspiler.transpile(type_=self.serializer_field)
)
def lookup_declarations(self):
declarations = list()
declarations.append(
render_type_declaration(name=self.serializer_field_name,
optional=True,
readonly=False,
type_=self._serialized_type))
for lookup_str, lookup_cls in self.model_field.get_lookups().items():
declarations.append(
render_type_declaration(name=self._lookup_key(
self.serializer_field_name, lookup_str),
optional=True,
readonly=False,
type_=FieldTypeTranspiler.transpile(
type_=self.model_field,
container_type=lookup_cls)))
return declarations
def method_sig_interface(arg_serializer_cls=None, signature: Signature = None):
type_declarations = []
if arg_serializer_cls:
serializer_fields = arg_serializer_cls().get_fields()
for field_name, field in serializer_fields.items():
type_declarations.append(
render_type_declaration(
name=field_name,
optional=field.allow_null,
readonly=field.read_only,
type_=FieldTypeTranspiler.transpile(field)))
return "data: {" + ", ".join(type_declarations) + "}"
if signature:
if len(signature) > 0:
for param_name in signature.param_names:
type_declarations.append(
render_type_declaration(name=param_name,
optional=False,
readonly=False,
type_=typescript_types.ANY))
return "data: {" + ", ".join(type_declarations) + "}"
return ''
def _serialized_type(self):
if self.model_field.choices:
return self._choices_type
return FieldTypeTranspiler.transpile(type_=self.serializer_field)