UncountablePythonSDK 0.0.8__py3-none-any.whl → 0.0.92__py3-none-any.whl

pkgs/type_spec/emit_typescript.py

@@ -1,82 +1,21 @@
 import io
 import os
-from typing import Any, Tuple
 
 from . import builder, util
-from .builder import SpecTypeDefnObject
 from .config import TypeScriptConfig
 from .emit_io_ts import emit_type_io_ts
 from .emit_typescript_util import (
-    INDENT,
     MODIFY_NOTICE,
     EmitTypescriptContext,
+    emit_namespace_imports_ts,
+    emit_type_ts,
+    emit_value_ts,
+    resolve_namespace_name,
     resolve_namespace_ref,
-    ts_name,
     ts_type_name,
 )
 
 
-def ts_enum_name(name: str, name_case: builder.NameCase) -> str:
-    if name_case == builder.NameCase.js_upper:
-        return name.upper()
-    return ts_name(name, name_case)
-
-
-def _resolve_namespace_name(namespace: builder.SpecNamespace) -> str:
-    return namespace.name
-
-
-def _emit_value(ctx: EmitTypescriptContext, stype: builder.SpecType, value: Any) -> str:
-    """Mimics emit_python even if not all types are used in TypeScript yet"""
-    literal = builder.unwrap_literal_type(stype)
-    if literal is not None:
-        return _emit_value(ctx, literal.value_type, literal.value)
-
-    if stype.is_base_type(builder.BaseTypeName.s_string):
-        assert isinstance(value, str)
-        return util.encode_common_string(value)
-    elif stype.is_base_type(builder.BaseTypeName.s_integer):
-        assert isinstance(value, int)
-        return str(value)
-    elif stype.is_base_type(builder.BaseTypeName.s_boolean):
-        assert isinstance(value, bool)
-        return "true" if value else "false"
-    elif stype.is_base_type(builder.BaseTypeName.s_lossy_decimal):
-        return str(value)
-    elif stype.is_base_type(builder.BaseTypeName.s_decimal):
-        return f"'{value}'"
-    elif isinstance(stype, builder.SpecTypeInstance):
-        if stype.defn_type.is_base_type(builder.BaseTypeName.s_list):
-            sub_type = stype.parameters[0]
-            return "[" + ", ".join([_emit_value(ctx, sub_type, x) for x in value]) + "]"
-
-        if stype.defn_type.is_base_type(builder.BaseTypeName.s_dict):
-            key_type = stype.parameters[0]
-            value_type = stype.parameters[1]
-            return (
-                "{\n\t"
-                + ",\n\t".join(
-                    "["
-                    + _emit_value(ctx, key_type, dkey)
-                    + "]: "
-                    + _emit_value(ctx, value_type, dvalue)
-                    for dkey, dvalue in value.items()
-                )
-                + "\n}"
-            )
-
-        if stype.defn_type.is_base_type(builder.BaseTypeName.s_optional):
-            sub_type = stype.parameters[0]
-            if value is None:
-                return "null"
-            return _emit_value(ctx, sub_type, value)
-
-    elif isinstance(stype, builder.SpecTypeDefnStringEnum):
-        return f"{refer_to(ctx, stype)}.{ts_enum_name(value, stype.name_case)}"
-
-    raise Exception("invalid constant type", value, stype)
-
-
 def emit_typescript(builder: builder.SpecBuilder, config: TypeScriptConfig) -> None:
     _emit_types(builder, config)
     _emit_id_source(builder, config)
@@ -90,11 +29,11 @@ def _emit_types(builder: builder.SpecBuilder, config: TypeScriptConfig) -> None:
 
     for namespace in sorted(
         builder.namespaces.values(),
-        key=lambda ns: _resolve_namespace_name(ns),
+        key=lambda ns: resolve_namespace_name(ns),
     ):
-        ctx = EmitTypescriptContext(out=io.StringIO(), namespace=namespace, config=config)
+        ctx = EmitTypescriptContext(out=io.StringIO(), namespace=namespace)
 
-        _emit_namespace(ctx, namespace)
+        _emit_namespace(ctx, config, namespace)
 
         prepart = builder.preparts["typescript"].get(namespace.name)
         part = builder.parts["typescript"].get(namespace.name)
@@ -121,16 +60,7 @@ def _emit_types(builder: builder.SpecBuilder, config: TypeScriptConfig) -> None:
             full.write(f"// === END section from {namespace.name}.ts.prepart ===\n")
             full.write("\n")
 
-        for ns in sorted(
-            ctx.namespaces,
-            key=lambda name: _resolve_namespace_name(name),
-        ):
-            import_as = resolve_namespace_ref(ns)
-            import_path = (
-                "./" if len(namespace.path) == 1 else "../" * (len(namespace.path) - 1)
-            )
-            import_from = f"{import_path}{_resolve_namespace_name(ns)}"
-            full.write(f'import * as {import_as} from "{import_from}"\n')  # noqa: E501
+        emit_namespace_imports_ts(ctx.namespaces, out=full, current_namespace=namespace)
         if namespace.emit_io_ts:
             full.write("import * as IO from 'io-ts';")
         full.write(ctx.out.getvalue())
@@ -150,7 +80,7 @@ def _emit_types(builder: builder.SpecBuilder, config: TypeScriptConfig) -> None:
 
         if len(namespace.path) == 1:
             index_out.write(
-                f"import * as {resolve_namespace_ref(namespace)} from './{_resolve_namespace_name(namespace)}'\n"
+                f"import * as {resolve_namespace_ref(namespace)} from './{resolve_namespace_name(namespace)}'\n"
             )  # noqa: E501
             index_out_end.write(f"export {{{resolve_namespace_ref(namespace)}}}\n")
 
@@ -161,22 +91,27 @@ def _emit_types(builder: builder.SpecBuilder, config: TypeScriptConfig) -> None:
     util.rewrite_file(f"{config.types_output}/index.ts", index_out.getvalue())
 
 
-def _emit_namespace(ctx: EmitTypescriptContext, namespace: builder.SpecNamespace) -> None:
+def _emit_namespace(
+    ctx: EmitTypescriptContext,
+    config: TypeScriptConfig,
+    namespace: builder.SpecNamespace,
+) -> None:
     for stype in namespace.types.values():
         if namespace.emit_io_ts:
             emit_type_io_ts(ctx, stype, namespace.derive_types_from_io_ts)
         if not namespace.emit_io_ts or not namespace.derive_types_from_io_ts:
-            _emit_type(ctx, stype)
+            emit_type_ts(ctx, stype)
 
     for sconst in namespace.constants.values():
         _emit_constant(ctx, sconst)
 
     if namespace.endpoint is not None:
-        _emit_endpoint(ctx, namespace, namespace.endpoint)
+        _emit_endpoint(ctx, config, namespace, namespace.endpoint)
 
 
 def _emit_endpoint(
     ctx: EmitTypescriptContext,
+    config: TypeScriptConfig,
     namespace: builder.SpecNamespace,
     endpoint: builder.SpecEndpoint,
 ) -> None:
@@ -188,6 +123,7 @@ def _emit_endpoint(
     has_data = "Data" in namespace.types
     has_deprecated_result = "DeprecatedResult" in namespace.types
     is_binary = endpoint.result_type == builder.ResultType.binary
+    has_multiple_endpoints = len(endpoint.path_per_api_endpoint) > 1
 
     result_type_count = sum([has_data, has_deprecated_result, is_binary])
     assert result_type_count < 2
@@ -222,51 +158,90 @@ def _emit_endpoint(
     wrap_call = (
         f"{wrap_name}<Arguments>" if is_binary else f"{wrap_name}<Arguments, Response>"
     )
-    type_path = f"unc_mat/types/{'/'.join(namespace.path)}"
 
-    if is_binary:
-        tsx_response_part = f"""import {{ {wrap_name} }} from "unc_base/api"
-import {{ Arguments }} from "{type_path}"
+    unc_base_api_imports = (
+        f"appSpecificApiPath, {wrap_name}" if has_multiple_endpoints else wrap_name
+    )
+    unc_types_imports = (
+        'import { ApplicationT } from "unc_types"\n' if has_multiple_endpoints else ""
+    )
 
+    type_path = f"unc_types/{'/'.join(namespace.path)}"
+
+    if is_binary:
+        tsx_response_part = f"""import {{ {unc_base_api_imports} }} from "unc_base/api"
+import type {{ Arguments }} from "{type_path}"
+{unc_types_imports}
 export type {{ Arguments }}
 """
     elif has_data and endpoint.has_attachment:
-        tsx_response_part = f"""import {{ {wrap_name}, AttachmentResponse }} from "unc_base/api"
-import {{ Arguments, Data }} from "{type_path}"
-
+        tsx_response_part = f"""import {{ {unc_base_api_imports}, type AttachmentResponse }} from "unc_base/api"
+import type {{ Arguments, Data }} from "{type_path}"
+{unc_types_imports}
 export type {{ Arguments, Data }}
 export type Response = AttachmentResponse<Data>
 """
     elif has_data:
-        tsx_response_part = f"""import {{ {wrap_name}, JsonResponse }} from "unc_base/api"
-import {{ Arguments, Data }} from "{type_path}"
-
+        tsx_response_part = f"""import {{ {unc_base_api_imports}, type JsonResponse }} from "unc_base/api"
+import type {{ Arguments, Data }} from "{type_path}"
+{unc_types_imports}
 export type {{ Arguments, Data }}
 export type Response = JsonResponse<Data>
 """
 
     else:
         assert has_deprecated_result
-        tsx_response_part = f"""import {{ {wrap_name} }} from "unc_base/api"
-import {{ Arguments, DeprecatedResult }} from "{type_path}"
-
+        tsx_response_part = f"""import {{ {unc_base_api_imports} }} from "unc_base/api"
+import type {{ Arguments, DeprecatedResult }} from "{type_path}"
+{unc_types_imports}
 export type {{ Arguments }}
 export type Response = DeprecatedResult
 """
 
+    """
+
+    export const apiCall = buildWrappedGetCall<Arguments, Response>(
+      appSpecificApiPath({
+        [ApplicationT.FrontendApplication.materials]: "api/materials/common/list_id_source",
+      }),
+    )
+
+
+    """
+
+    endpoint_path_part = (
+        f'"{endpoint.path_root}/{endpoint.path_dirname}/{endpoint.path_basename}",'
+    )
+
+    if has_multiple_endpoints:
+        path_lookup_map = ""
+        for (
+            api_endpoint_key,
+            endpoint_specific_path,
+        ) in endpoint.path_per_api_endpoint.items():
+            full_path = f"{endpoint_specific_path.path_root}/{endpoint_specific_path.path_dirname}/{endpoint_specific_path.path_basename}"
+            frontend_app_value = config.endpoint_to_frontend_app_type[api_endpoint_key]
+
+            path_lookup_map += (
+                f'\n    [ApplicationT.{frontend_app_value}]: "{full_path}",'
+            )
+
+        endpoint_path_part = f"""appSpecificApiPath({{{path_lookup_map}
+  }}),"""
+
     tsx_api = f"""{MODIFY_NOTICE}
 {data_loader_head}{tsx_response_part}
 export const apiCall = {wrap_call}(
-  "{endpoint.path_root}/{endpoint.path_dirname}/{endpoint.path_basename}",
+  {endpoint_path_part}
 )
 {data_loader_body}"""
 
-    output = f"{ctx.config.routes_output}/{'/'.join(namespace.path)}.tsx"
+    output = f"{config.routes_output}/{'/'.join(namespace.path)}.tsx"
     util.rewrite_file(output, tsx_api)
 
     # Hacky index support, until enough is migrated to regen entirely
     # Emits the import into the UI API index file
-    index_path = f"{ctx.config.routes_output}/{'/'.join(namespace.path[0:-1])}/index.tsx"
+    index_path = f"{config.routes_output}/{'/'.join(namespace.path[0:-1])}/index.tsx"
     api_name = f"Api{ts_type_name(namespace.path[0 - 1])}"
     if os.path.exists(index_path):
         with open(index_path) as index:
@@ -278,192 +253,18 @@ export const apiCall = {wrap_call}(
     if need_index:
         with open(index_path, "a") as index:
             print(f"Updated API Index {index_path}")
-            index.write("\n// eslint-disable-next-line import/first\n")
             index.write(f'import * as {api_name} from "./{namespace.path[-1]}"\n\n')
             index.write(f"export {{ {api_name} }}\n")
 
 
-MARKER_BEGIN = "### BEGIN:TYPE_SPEC"
-MARKER_END = "### END:TYPE_SPEC"
-
-
-def _patch_file_line(filename: str, line: str) -> None:
-    """
-    Adds a line into a file inside a marked region. The file section is
-    kept ordered. The rest of the file is untouched.
-    """
-    with open(filename) as ignore_in:
-        ignore_data = ignore_in.read()
-        need_ignore = ignore_data.find(line) == -1
-        if not need_ignore:
-            return
-
-    begin = ignore_data.find(MARKER_BEGIN)
-    end = ignore_data.find(MARKER_END)
-    if begin == -1 or end == -1:
-        predata = ignore_data
-        postdata = ""
-        linedata = ""
-    else:
-        predata = ignore_data[:begin]
-        postdata = ignore_data[(end + len(MARKER_END)) :]
-        linedata = ignore_data[begin + len(MARKER_BEGIN) : end]
-
-    lines = [y for y in [x.strip() for x in linedata.split("\n")] if len(y) > 0]
-    lines.append(line)
-
-    with open(filename, "w") as ignore_out:
-        ignore_out.write(f"{predata}{MARKER_BEGIN}\n")
-        ignore_out.write("\n".join(sorted(lines)))
-        ignore_out.write(f"\n{MARKER_END}{postdata}")
-
-
-def _emit_type(ctx: EmitTypescriptContext, stype: builder.SpecType) -> None:
-    if not isinstance(stype, builder.SpecTypeDefn):
-        return
-
-    if stype.is_base or stype.is_predefined:
-        return
-
-    ctx.out.write("\n")
-    ctx.out.write(MODIFY_NOTICE)
-
-    if isinstance(stype, builder.SpecTypeDefnExternal):
-        assert not stype.is_exported, "expecting private names"
-        ctx.out.write(stype.external_map["ts"])
-        ctx.out.write("\n")
-        return
-
-    assert stype.is_exported, "expecting exported names"
-    if isinstance(stype, builder.SpecTypeDefnAlias):
-        ctx.out.write(f"export type {stype.name} = {refer_to(ctx, stype.alias)}\n")
-        return
-
-    if isinstance(stype, builder.SpecTypeDefnStringEnum):
-        ctx.out.write(f"export enum {stype.name} {{\n")
-        assert stype.values
-        for name, entry in stype.values.items():
-            ctx.out.write(
-                f'{INDENT}{ts_enum_name(name, stype.name_case)} = "{entry.value}",\n'
-            )
-        ctx.out.write("}\n")
-        return
-
-    assert isinstance(stype, builder.SpecTypeDefnObject)
-    assert stype.base is not None
-
-    base_type = ""
-    if not stype.base.is_base:
-        base_type = f"{refer_to(ctx, stype.base)} & "
-
-    if stype.properties is None and base_type == "":
-        ctx.out.write(f"export type {stype.name} = TEmpty\n")
-    elif stype.properties is None:
-        ctx.out.write(f"export type {stype.name} = {base_type}{{}}\n")
-    else:
-        if isinstance(stype, SpecTypeDefnObject) and len(stype.parameters) > 0:
-            full_type_name = f'{stype.name}<{", ".join(stype.parameters)}>'
-        else:
-            full_type_name = stype.name
-        ctx.out.write(f"export type {full_type_name} = {base_type}{{")
-        ctx.out.write("\n")
-        for prop in stype.properties.values():
-            ref_type = refer_to(ctx, prop.spec_type)
-            prop_name = ts_name(prop.name, prop.name_case)
-            if prop.has_default and not prop.parse_require:
-                # For now, we'll assume the generated types with defaults are meant as
-                # arguments, thus treat like extant==missing
-                # IMPROVE: if we can decide they are meant as output instead, then
-                # they should be marked as required
-                ctx.out.write(f"{INDENT}{prop_name}?: {ref_type}")
-            elif prop.extant == builder.PropertyExtant.missing:
-                # Unlike optional below, missing does not imply null is possible. They
-                # treated distinctly.
-                ctx.out.write(f"{INDENT}{prop_name}?: {ref_type}")
-            elif prop.extant == builder.PropertyExtant.optional:
-                # Need to add in |null since Python side can produce null's right now
-                # IMPROVE: It would be better if the serializer could instead omit the None's
-                # Dropping the null should be forward compatible
-                ctx.out.write(f"{INDENT}{prop_name}?: {ref_type} | null")
-            else:
-                ctx.out.write(f"{INDENT}{prop_name}: {ref_type}")
-            ctx.out.write("\n")
-        ctx.out.write("}\n")
-
-
 def _emit_constant(ctx: EmitTypescriptContext, sconst: builder.SpecConstant) -> None:
     ctx.out.write("\n\n")
     ctx.out.write(MODIFY_NOTICE)
-    value = _emit_value(ctx, sconst.value_type, sconst.value)
+    value = emit_value_ts(ctx, sconst.value_type, sconst.value)
     const_name = sconst.name.upper()
     ctx.out.write(f"export const {const_name} = {value}\n")
 
 
-base_name_map = {
-    builder.BaseTypeName.s_boolean: "boolean",
-    builder.BaseTypeName.s_date: "string",  # IMPROVE: Aliased DateStr
-    builder.BaseTypeName.s_date_time: "string",  # IMPROVE: Aliased DateTimeStr
-    # Decimal's are marked as to_string_values thus are strings in the front-end
-    builder.BaseTypeName.s_decimal: "string",
-    builder.BaseTypeName.s_dict: "PartialRecord",
-    builder.BaseTypeName.s_integer: "number",
-    builder.BaseTypeName.s_lossy_decimal: "number",
-    builder.BaseTypeName.s_opaque_key: "string",
-    builder.BaseTypeName.s_none: "null",
-    builder.BaseTypeName.s_string: "string",
-    # UNC: global types
-    builder.BaseTypeName.s_json_value: "JsonValue",
-}
-
-
-def refer_to(ctx: EmitTypescriptContext, stype: builder.SpecType) -> str:
-    return refer_to_impl(ctx, stype)[0]
-
-
-def refer_to_impl(
-    ctx: EmitTypescriptContext, stype: builder.SpecType
-) -> Tuple[str, bool]:
-    """
-    @return (string-specific, multiple-types)
-    """
-    if isinstance(stype, builder.SpecTypeInstance):
-        if stype.defn_type.name == builder.BaseTypeName.s_list:
-            spec, multi = refer_to_impl(ctx, stype.parameters[0])
-            return f"({spec})[]" if multi else f"{spec}[]", False
-        if stype.defn_type.name == builder.BaseTypeName.s_union:
-            return f'({" | ".join([refer_to(ctx, p) for p in stype.parameters])})', False
-        if stype.defn_type.name == builder.BaseTypeName.s_literal:
-            parts = []
-            for parameter in stype.parameters:
-                assert isinstance(parameter, builder.SpecTypeLiteralWrapper)
-                parts.append(refer_to(ctx, parameter))
-            return f'({" | ".join(parts)})', False
-        if stype.defn_type.name == builder.BaseTypeName.s_optional:
-            return f"{refer_to(ctx, stype.parameters[0])} | null", True
-        if stype.defn_type.name == builder.BaseTypeName.s_tuple:
-            return f"[{', '.join([refer_to(ctx, p) for p in stype.parameters])}]", False
-        params = ", ".join([refer_to(ctx, p) for p in stype.parameters])
-        return f"{refer_to(ctx, stype.defn_type)}<{params}>", False
-
-    if isinstance(stype, builder.SpecTypeLiteralWrapper):
-        return _emit_value(ctx, stype.value_type, stype.value), False
-
-    if isinstance(stype, builder.SpecTypeGenericParameter):
-        return stype.name, False
-
-    assert isinstance(stype, builder.SpecTypeDefn)
-    if stype.is_base:  # assume correct namespace
-        if stype.name == builder.BaseTypeName.s_list:
-            return "any[]", False  # TODO: generic type
-        return base_name_map[builder.BaseTypeName(stype.name)], False
-
-    if stype.namespace == ctx.namespace:
-        return stype.name, False
-
-    ctx.namespaces.add(stype.namespace)
-    return f"{resolve_namespace_ref(stype.namespace)}.{stype.name}", False
-
-
 def _emit_id_source(builder: builder.SpecBuilder, config: TypeScriptConfig) -> None:
     id_source_output = config.id_source_output
     if id_source_output is None: