exdrf-ts 0.1.17__tar.gz

exdrf_ts-0.1.17/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: exdrf-ts
+Version: 0.1.17
+Summary: Map exdrf field and Python types to TypeScript for codegen.
+Author-email: Nicu Tofan <nicu.tofan@gmail.com>
+License-Expression: MIT
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Development Status :: 3 - Alpha
+Classifier: Typing :: Typed
+Requires-Python: >=3.12.2
+Description-Content-Type: text/markdown
+Requires-Dist: exdrf>=0.1.17
+Requires-Dist: exdrf-pd>=0.1.18
+Provides-Extra: dev
+Requires-Dist: autoflake; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: pyproject-flake8; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-mock; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: wheel; extra == "dev"
+
+# exdrf-ts
+
+**exdrf-ts** maps **exdrf** field-type constants and Python typing objects to
+**TypeScript** strings and DARE field class names. Code generators
+(**exdrf-gen-pd2dare**, **exdrf-gen-openapi2rtk**, app-specific pipelines)
+import it when emitting TS from Pydantic-backed or OpenAPI-backed resources.
+
+The PyPI distribution name is **`exdrf-ts`**. The import package is
+**`exdrf_ts`**.
+
+Python **3.12.2+** is required. Runtime dependencies: **exdrf** and
+**exdrf-pd**.
+
+## Installation
+
+```text
+pip install exdrf-ts
+```
+
+Editable install from the exdrf monorepo root (with other packages present as
+needed):
+
+```text
+pip install -e ./exdrf-ts
+```
+
+## API
+
+- **`py_type_to_ts`**: Python annotation or runtime type to TS type string.
+- **`type_to_field_class`**: Maps **exdrf** `FIELD_TYPE_*` values to DARE
+  field class names (for example `StringField`).
+- **`model_rel_import`**: Relative import path between two models (via
+  **`exdrf_pd.visitor.ExModelVisitor`**).
+
+## Role in the stack
+
+- **`exdrf`**: core dataset / field model.
+- **`exdrf-pd`**: Pydantic **`ExModel`** and visitors.
+- **`exdrf-ts`**: TypeScript-oriented views of those types.

exdrf_ts-0.1.17/README.md

@@ -0,0 +1,39 @@
+# exdrf-ts
+
+**exdrf-ts** maps **exdrf** field-type constants and Python typing objects to
+**TypeScript** strings and DARE field class names. Code generators
+(**exdrf-gen-pd2dare**, **exdrf-gen-openapi2rtk**, app-specific pipelines)
+import it when emitting TS from Pydantic-backed or OpenAPI-backed resources.
+
+The PyPI distribution name is **`exdrf-ts`**. The import package is
+**`exdrf_ts`**.
+
+Python **3.12.2+** is required. Runtime dependencies: **exdrf** and
+**exdrf-pd**.
+
+## Installation
+
+```text
+pip install exdrf-ts
+```
+
+Editable install from the exdrf monorepo root (with other packages present as
+needed):
+
+```text
+pip install -e ./exdrf-ts
+```
+
+## API
+
+- **`py_type_to_ts`**: Python annotation or runtime type to TS type string.
+- **`type_to_field_class`**: Maps **exdrf** `FIELD_TYPE_*` values to DARE
+  field class names (for example `StringField`).
+- **`model_rel_import`**: Relative import path between two models (via
+  **`exdrf_pd.visitor.ExModelVisitor`**).
+
+## Role in the stack
+
+- **`exdrf`**: core dataset / field model.
+- **`exdrf-pd`**: Pydantic **`ExModel`** and visitors.
+- **`exdrf-ts`**: TypeScript-oriented views of those types.

exdrf_ts-0.1.17/exdrf_ts/__init__.py

@@ -0,0 +1,17 @@
+"""TypeScript-oriented type mapping for exdrf-backed codegen."""
+
+from exdrf_ts.json_schema_ts import json_schema_to_ts
+from exdrf_ts.mapping import (
+    model_rel_import,
+    py_type_to_ts,
+    py_type_to_ts_map,
+    type_to_field_class,
+)
+
+__all__ = [
+    "json_schema_to_ts",
+    "model_rel_import",
+    "py_type_to_ts",
+    "py_type_to_ts_map",
+    "type_to_field_class",
+]

exdrf_ts-0.1.17/exdrf_ts/__version__.py

@@ -0,0 +1,24 @@
+"""Package version from PEP 621 or installed metadata."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from exdrf.pep621_version import distribution_version, version_tuple_from_string
+
+_PYPROJECT = Path(__file__).resolve().parents[1] / "pyproject.toml"
+_DIST_NAME = "exdrf-ts"
+
+__version__ = version = distribution_version(_DIST_NAME, _PYPROJECT)
+__version_tuple__ = version_tuple = version_tuple_from_string(__version__)
+
+__commit_id__ = commit_id = None
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]

exdrf_ts-0.1.17/exdrf_ts/json_schema_ts.py

@@ -0,0 +1,238 @@
+"""Map OpenAPI / JSON Schema fragments to TypeScript type strings."""
+
+from __future__ import annotations
+
+import json
+import re
+from typing import Any, Mapping
+
+_REF_RE = re.compile(r"^#/components/schemas/([A-Za-z0-9_.-]+)$")
+
+
+def _json_pointer_get(doc: Mapping[str, Any], pointer: str) -> Any:
+    """Resolve a JSON Pointer (RFC 6901) against ``doc``.
+
+    Only supports absolute pointers starting with ``/`` (no URI fragment).
+
+    Args:
+        doc: JSON object to traverse.
+        pointer: Pointer such as ``/components/schemas/Foo``.
+
+    Returns:
+        The value at ``pointer``, or ``None`` if a segment is missing.
+    """
+
+    if not pointer.startswith("/"):
+        return None
+    cur: Any = doc
+    for raw in pointer.strip("/").split("/"):
+        key = raw.replace("~1", "/").replace("~0", "~")
+        if not isinstance(cur, Mapping) or key not in cur:
+            return None
+        cur = cur[key]
+    return cur
+
+
+def _resolve_ref(
+    ref: str,
+    resolve_root: Mapping[str, Any],
+    seen_refs: frozenset[str],
+) -> tuple[Any, frozenset[str]] | None:
+    """Follow an OpenAPI ``#/components/schemas/...`` reference.
+
+    Args:
+        ref: Reference string from ``"$ref"``.
+        resolve_root: Full OpenAPI document (or object containing
+            ``components``).
+        seen_refs: References already followed (cycle guard).
+
+    Returns:
+        ``(target_schema, seen_refs_with_ref)`` or ``None`` if unsupported.
+    """
+
+    m = _REF_RE.match(ref)
+    if not m:
+        return None
+    name = m.group(1)
+    if ref in seen_refs:
+        return None
+    pointer = f"/components/schemas/{name}"
+    target = _json_pointer_get(resolve_root, pointer)
+    if target is None:
+        return None
+    return target, frozenset((*seen_refs, ref))
+
+
+def json_schema_to_ts(
+    schema: Any,
+    resolve_root: Mapping[str, Any] | None = None,
+    *,
+    seen_refs: frozenset[str] | None = None,
+) -> str:
+    """Convert a JSON Schema fragment to a TypeScript type string.
+
+    Intended for OpenAPI 3.x ``components.schemas`` and inline parameter /
+    response bodies. Unsupported or cyclic constructs fall back to
+    ``unknown``.
+
+    Args:
+        schema: Schema object (``dict``), ``True`` (accept-all schema in JSON
+            Schema drafts), or ``False`` (reject-all; emitted as ``never``).
+        resolve_root: Document used to resolve ``#/components/schemas/...``
+            ``"$ref"`` values. When ``None``, ``"$ref"`` resolves to
+            ``unknown``.
+        seen_refs: Internal recursion guard; do not pass from callers.
+
+    Returns:
+        TypeScript type text.
+    """
+
+    stack = frozenset() if seen_refs is None else seen_refs
+
+    if schema is True:
+        return "unknown"
+    if schema is False:
+        return "never"
+    if not isinstance(schema, Mapping):
+        return "unknown"
+
+    ref = schema.get("$ref")
+    if isinstance(ref, str) and resolve_root is not None:
+        resolved = _resolve_ref(ref, resolve_root, stack)
+        if resolved is not None:
+            sub, new_stack = resolved
+            return json_schema_to_ts(sub, resolve_root, seen_refs=new_stack)
+        m = _REF_RE.match(ref)
+        if m:
+            return m.group(1)
+        return "unknown"
+
+    if "enum" in schema and isinstance(schema["enum"], list):
+        literals: list[str] = []
+        for v in schema["enum"]:
+            if isinstance(v, str):
+                literals.append(json.dumps(v))
+            elif isinstance(v, bool):
+                literals.append("true" if v else "false")
+            elif v is None:
+                literals.append("null")
+            elif isinstance(v, (int, float)):
+                literals.append(json.dumps(v))
+        if not literals:
+            return "unknown"
+        return " | ".join(literals)
+
+    if "oneOf" in schema and isinstance(schema["oneOf"], list):
+        parts = [
+            json_schema_to_ts(s, resolve_root, seen_refs=stack) for s in schema["oneOf"]
+        ]
+        parts_u = [p for p in parts if p != "unknown"]
+        if not parts_u:
+            return "unknown"
+        return " | ".join(dict.fromkeys(parts_u))
+
+    if "anyOf" in schema and isinstance(schema["anyOf"], list):
+        parts = [
+            json_schema_to_ts(s, resolve_root, seen_refs=stack) for s in schema["anyOf"]
+        ]
+        parts_u = [p for p in parts if p != "unknown"]
+        if not parts_u:
+            return "unknown"
+        return " | ".join(dict.fromkeys(parts_u))
+
+    if "allOf" in schema and isinstance(schema["allOf"], list):
+        parts = [
+            json_schema_to_ts(s, resolve_root, seen_refs=stack) for s in schema["allOf"]
+        ]
+        if all(p == "unknown" for p in parts):
+            return "unknown"
+
+        def _part(p: str) -> str:
+            if " | " in p or " & " in p:
+                return f"({p})"
+            return p
+
+        return " & ".join(_part(p) for p in parts)
+
+    type_val = schema.get("type")
+    types: list[str] = []
+    if isinstance(type_val, list):
+        types = [t for t in type_val if isinstance(t, str)]
+    elif isinstance(type_val, str):
+        types = [type_val]
+
+    nullable = schema.get("nullable") is True
+
+    def _wrap_null(t: str) -> str:
+        if nullable:
+            return f"{t} | null"
+        return t
+
+    if not types:
+        if "properties" in schema or "additionalProperties" in schema:
+            return _wrap_null(_object_to_ts(schema, resolve_root, stack))
+        return "unknown"
+
+    out_parts: list[str] = []
+    for t in types:
+        if t == "string":
+            out_parts.append("string")
+        elif t == "integer":
+            out_parts.append("number")
+        elif t == "number":
+            out_parts.append("number")
+        elif t == "boolean":
+            out_parts.append("boolean")
+        elif t == "null":
+            out_parts.append("null")
+        elif t == "array":
+            items = schema.get("items", {})
+            inner = json_schema_to_ts(items, resolve_root, seen_refs=stack)
+            out_parts.append(f"{inner}[]")
+        elif t == "object":
+            out_parts.append(_object_to_ts(schema, resolve_root, stack))
+        else:
+            out_parts.append("unknown")
+
+    merged = " | ".join(dict.fromkeys(out_parts)) if out_parts else "unknown"
+    return _wrap_null(merged)
+
+
+def _object_to_ts(
+    schema: Mapping[str, Any],
+    resolve_root: Mapping[str, Any] | None,
+    stack: frozenset[str],
+) -> str:
+    """Build an inline object type from schema ``properties`` / ``additional``.
+
+    Args:
+        schema: JSON Schema with ``type`` ``object`` (or implied).
+        resolve_root: Document for ``$ref`` inside nested schemas.
+        stack: Active ``$ref`` stack.
+
+    Returns:
+        Inline TypeScript object type or ``Record<...>``.
+    """
+
+    props = schema.get("properties")
+    required = set(schema.get("required", []) or [])
+    if isinstance(props, Mapping) and props:
+        lines: list[str] = []
+        for key, sub in props.items():
+            opt = "" if key in required else "?"
+            ts = json_schema_to_ts(sub, resolve_root, seen_refs=stack)
+            safe_key = (
+                key
+                if re.match(r"^[A-Za-z_][A-Za-z0-9_]*$", str(key))
+                else json.dumps(str(key))
+            )
+            lines.append(f"  {safe_key}{opt}: {ts};")
+        return "{\n" + "\n".join(lines) + "\n}"
+
+    addl = schema.get("additionalProperties")
+    if addl is True:
+        return "{ [key: string]: unknown }"
+    if isinstance(addl, Mapping):
+        inner = json_schema_to_ts(addl, resolve_root, seen_refs=stack)
+        return f"{{ [key: string]: {inner} }}"
+    return "{ [key: string]: unknown }"

exdrf_ts-0.1.17/exdrf_ts/mapping.py

@@ -0,0 +1,159 @@
+"""Map exdrf types and Python annotations to TypeScript."""
+
+from __future__ import annotations
+
+import types
+from typing import Any, Union, get_args, get_origin
+
+from exdrf.constants import (
+    FIELD_TYPE_BLOB,
+    FIELD_TYPE_BOOL,
+    FIELD_TYPE_DATE,
+    FIELD_TYPE_DT,
+    FIELD_TYPE_DURATION,
+    FIELD_TYPE_ENUM,
+    FIELD_TYPE_FILTER,
+    FIELD_TYPE_FLOAT,
+    FIELD_TYPE_FLOAT_LIST,
+    FIELD_TYPE_FORMATTED,
+    FIELD_TYPE_INT_LIST,
+    FIELD_TYPE_INTEGER,
+    FIELD_TYPE_REF_MANY_TO_MANY,
+    FIELD_TYPE_REF_MANY_TO_ONE,
+    FIELD_TYPE_REF_ONE_TO_MANY,
+    FIELD_TYPE_REF_ONE_TO_ONE,
+    FIELD_TYPE_SORT,
+    FIELD_TYPE_STRING,
+    FIELD_TYPE_STRING_LIST,
+)
+from exdrf_pd.visitor import ExModelVisitor
+
+py_type_to_ts_map = {
+    "str": "string",
+    "int": "number",
+    "float": "number",
+    "bool": "boolean",
+}
+
+type_to_field_class = {
+    FIELD_TYPE_BLOB: "BlobField",
+    FIELD_TYPE_BOOL: "BooleanField",
+    FIELD_TYPE_DATE: "DateField",
+    FIELD_TYPE_DT: "DateTimeField",
+    FIELD_TYPE_DURATION: "DurationField",
+    FIELD_TYPE_ENUM: "EnumField",
+    FIELD_TYPE_FLOAT: "FloatField",
+    FIELD_TYPE_INTEGER: "IntegerField",
+    FIELD_TYPE_STRING: "StringField",
+    FIELD_TYPE_FORMATTED: "FormattedField",
+    FIELD_TYPE_REF_ONE_TO_MANY: "RefOneToManyField",
+    FIELD_TYPE_REF_MANY_TO_ONE: "RefManyToOneField",
+    FIELD_TYPE_REF_ONE_TO_ONE: "RefOneToOneField",
+    FIELD_TYPE_REF_MANY_TO_MANY: "RefManyToManyField",
+    FIELD_TYPE_STRING_LIST: "StringListField",
+    FIELD_TYPE_INT_LIST: "IntListField",
+    FIELD_TYPE_FLOAT_LIST: "FloatListField",
+    FIELD_TYPE_FILTER: "FilterField",
+    FIELD_TYPE_SORT: "SortField",
+}
+
+
+def _py_type_to_ts_string(name: str) -> str:
+    """Convert a stringified annotation to a TypeScript type.
+
+    Args:
+        name: Annotation text (for example ``List[str]``).
+
+    Returns:
+        Equivalent TypeScript type string.
+    """
+
+    if name == "Any":
+        return "unknown"
+
+    if name.startswith("List[") and name.endswith("]"):
+        return f"{py_type_to_ts(name[5:-1])}[]"
+
+    if name.startswith("Dict[") and name.endswith("]"):
+        key, value = name[5:-1].split(", ")
+        if py_type_to_ts(key) == "str":
+            return f"{{ {key}: {py_type_to_ts(value)} }}"
+        return f"{{ [key: {py_type_to_ts(key)}]: {py_type_to_ts(value)} }}"
+
+    if name.startswith("Optional[") and name.endswith("]"):
+        return f"{py_type_to_ts(name[9:-1])} | undefined"
+
+    return py_type_to_ts_map.get(name, name)
+
+
+def py_type_to_ts(name: Union[str, type, types.UnionType, Any]) -> str:
+    """Convert a Python type or annotation string to a TypeScript type.
+
+    Args:
+        name: A type object, string annotation, or typing construct.
+
+    Returns:
+        TypeScript type text suitable for emitted source.
+    """
+
+    if isinstance(name, str):
+        return _py_type_to_ts_string(name)
+
+    args = get_args(name)
+    if args and type(None) in args:
+        non_none = [a for a in args if a is not type(None)]
+        if len(non_none) == 1:
+            return f"{py_type_to_ts(non_none[0])} | undefined"
+
+    origin = get_origin(name)
+    if origin is list:
+        if len(args) == 1:
+            return f"{py_type_to_ts(args[0])}[]"
+
+    if origin is dict:
+        if len(args) == 2:
+            key_t, val_t = args
+            if py_type_to_ts(key_t) == "string":
+                return f"{{ [key: string]: {py_type_to_ts(val_t)} }}"
+            return f"{{ [key: {py_type_to_ts(key_t)}]: {py_type_to_ts(val_t)} }}"
+
+    if hasattr(name, "__name__") and origin is None:
+        py_name = name.__name__
+        if py_name == "Any":
+            return "unknown"
+        mapped = py_type_to_ts_map.get(py_name)
+        if mapped is not None:
+            return mapped
+        return py_name
+
+    return "unknown"
+
+
+def model_rel_import(model: Any, ref_model: Any) -> str:
+    """Compute a model import path relative to another model.
+
+    Args:
+        model: The resource or model to import.
+        ref_model: The reference model (import origin).
+
+    Returns:
+        Relative path using ``/`` segments (for TS-style paths).
+    """
+
+    categories = ExModelVisitor.category(model)
+    ref_categories = ExModelVisitor.category(ref_model)
+
+    # Find the common prefix between category chains.
+    i = 0
+    while (
+        i < len(categories)
+        and i < len(ref_categories)
+        and categories[i] == ref_categories[i]
+    ):
+        i += 1
+
+    # Walk up from the reference, then down through the remainder.
+    path = [".."] * (len(ref_categories) - i)
+    path.extend(categories[i:])
+
+    return "/".join(path)

exdrf_ts-0.1.17/exdrf_ts.egg-info/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: exdrf-ts
+Version: 0.1.17
+Summary: Map exdrf field and Python types to TypeScript for codegen.
+Author-email: Nicu Tofan <nicu.tofan@gmail.com>
+License-Expression: MIT
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Development Status :: 3 - Alpha
+Classifier: Typing :: Typed
+Requires-Python: >=3.12.2
+Description-Content-Type: text/markdown
+Requires-Dist: exdrf>=0.1.17
+Requires-Dist: exdrf-pd>=0.1.18
+Provides-Extra: dev
+Requires-Dist: autoflake; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: pyproject-flake8; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-mock; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: wheel; extra == "dev"
+
+# exdrf-ts
+
+**exdrf-ts** maps **exdrf** field-type constants and Python typing objects to
+**TypeScript** strings and DARE field class names. Code generators
+(**exdrf-gen-pd2dare**, **exdrf-gen-openapi2rtk**, app-specific pipelines)
+import it when emitting TS from Pydantic-backed or OpenAPI-backed resources.
+
+The PyPI distribution name is **`exdrf-ts`**. The import package is
+**`exdrf_ts`**.
+
+Python **3.12.2+** is required. Runtime dependencies: **exdrf** and
+**exdrf-pd**.
+
+## Installation
+
+```text
+pip install exdrf-ts
+```
+
+Editable install from the exdrf monorepo root (with other packages present as
+needed):
+
+```text
+pip install -e ./exdrf-ts
+```
+
+## API
+
+- **`py_type_to_ts`**: Python annotation or runtime type to TS type string.
+- **`type_to_field_class`**: Maps **exdrf** `FIELD_TYPE_*` values to DARE
+  field class names (for example `StringField`).
+- **`model_rel_import`**: Relative import path between two models (via
+  **`exdrf_pd.visitor.ExModelVisitor`**).
+
+## Role in the stack
+
+- **`exdrf`**: core dataset / field model.
+- **`exdrf-pd`**: Pydantic **`ExModel`** and visitors.
+- **`exdrf-ts`**: TypeScript-oriented views of those types.

exdrf_ts-0.1.17/exdrf_ts.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+exdrf_ts/__init__.py
+exdrf_ts/__version__.py
+exdrf_ts/json_schema_ts.py
+exdrf_ts/mapping.py
+exdrf_ts/py.typed
+exdrf_ts.egg-info/PKG-INFO
+exdrf_ts.egg-info/SOURCES.txt
+exdrf_ts.egg-info/dependency_links.txt
+exdrf_ts.egg-info/requires.txt
+exdrf_ts.egg-info/top_level.txt
+tests/json_schema_ts_test.py
+tests/mapping_test.py

exdrf_ts-0.1.17/exdrf_ts.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

exdrf_ts-0.1.17/exdrf_ts.egg-info/requires.txt

@@ -0,0 +1,17 @@
+exdrf>=0.1.17
+exdrf-pd>=0.1.18
+
+[dev]
+autoflake
+black
+build
+flake8
+isort
+mypy
+pre-commit
+pyproject-flake8
+pytest-cov
+pytest-mock
+pytest
+twine
+wheel

exdrf_ts-0.1.17/exdrf_ts.egg-info/top_level.txt

@@ -0,0 +1,3 @@
+dist
+exdrf_ts
+tests

exdrf_ts-0.1.17/pyproject.toml

@@ -0,0 +1,63 @@
+[project]
+authors = [
+    { name = "Nicu Tofan", email = "nicu.tofan@gmail.com" },
+]
+license = "MIT"
+classifiers = [
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3 :: Only",
+  "Development Status :: 3 - Alpha",
+  "Typing :: Typed",
+]
+dependencies = [
+  "exdrf>=0.1.17",
+  "exdrf-pd>=0.1.18",
+]
+description = "Map exdrf field and Python types to TypeScript for codegen."
+version = "0.1.17"
+name = "exdrf-ts"
+readme = "README.md"
+requires-python = ">=3.12.2"
+
+[project.optional-dependencies]
+dev = [
+  "autoflake",
+  "black",
+  "build",
+  "flake8",
+  "isort",
+  "mypy",
+  "pre-commit",
+  "pyproject-flake8",
+  "pytest-cov",
+  "pytest-mock",
+  "pytest",
+  "twine",
+  "wheel",
+]
+
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools>=67.0"]
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.package-data]
+exdrf_ts = ["py.typed"]
+
+[tool.setuptools.packages.find]
+exclude = ["venv*", "playground*"]
+
+
+[tool.isort]
+profile = "black"
+
+[tool.black]
+line-length = 80
+target-version = ['py312']
+
+[tool.flake8]
+docstring-convention = "google"
+max-line-length = 80
+extend-ignore = ["E203", "E501", "W503"]

exdrf_ts-0.1.17/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

exdrf_ts-0.1.17/tests/json_schema_ts_test.py

@@ -0,0 +1,100 @@
+"""Tests for :mod:`exdrf_ts.json_schema_ts`."""
+
+from __future__ import annotations
+
+from exdrf_ts.json_schema_ts import json_schema_to_ts
+
+
+class TestJsonSchemaToTsPrimitives:
+    """Primitive and array JSON Schema types."""
+
+    def test_string(self) -> None:
+        """``type: string`` maps to TypeScript ``string``."""
+
+        assert json_schema_to_ts({"type": "string"}) == "string"
+
+    def test_integer_and_number(self) -> None:
+        """Numeric JSON Schema types map to ``number``."""
+
+        assert json_schema_to_ts({"type": "integer"}) == "number"
+        assert json_schema_to_ts({"type": "number"}) == "number"
+
+    def test_boolean(self) -> None:
+        """``type: boolean`` maps to ``boolean``."""
+
+        assert json_schema_to_ts({"type": "boolean"}) == "boolean"
+
+    def test_array_of_string(self) -> None:
+        """``type: array`` with ``items`` maps to element type plus ``[]``."""
+
+        out = json_schema_to_ts(
+            {"type": "array", "items": {"type": "string"}},
+        )
+        assert out == "string[]"
+
+    def test_nullable_string(self) -> None:
+        """OpenAPI 3 ``nullable: true`` adds ``| null``."""
+
+        assert (
+            json_schema_to_ts({"type": "string", "nullable": True}) == "string | null"
+        )
+
+
+class TestJsonSchemaToTsRef:
+    """``$ref`` resolution against a synthetic OpenAPI document."""
+
+    def test_components_schema_ref(self) -> None:
+        """``#/components/schemas/Name`` emits the schema name."""
+
+        root = {
+            "components": {
+                "schemas": {
+                    "Foo": {
+                        "type": "object",
+                        "properties": {"a": {"type": "integer"}},
+                    }
+                }
+            }
+        }
+        out = json_schema_to_ts({"$ref": "#/components/schemas/Foo"}, root)
+        assert "a" in out
+        assert "number" in out
+
+
+class TestJsonSchemaToTsEnum:
+    """Enum keyword."""
+
+    def test_string_enum(self) -> None:
+        """String ``enum`` becomes a union of string literals."""
+
+        out = json_schema_to_ts({"type": "string", "enum": ["a", "b"]})
+        assert '"a"' in out
+        assert '"b"' in out
+        assert " | " in out
+
+
+class TestJsonSchemaToTsLogical:
+    """``oneOf`` / ``anyOf`` / ``allOf``."""
+
+    def test_one_of_primitives(self) -> None:
+        """``oneOf`` joins alternatives with ``|``."""
+
+        out = json_schema_to_ts(
+            {"oneOf": [{"type": "string"}, {"type": "integer"}]},
+        )
+        assert "string" in out
+        assert "number" in out
+
+
+class TestJsonSchemaToTsSpecial:
+    """Boolean schema and empty shapes."""
+
+    def test_true_schema(self) -> None:
+        """JSON Schema ``true`` accepts anything → ``unknown``."""
+
+        assert json_schema_to_ts(True) == "unknown"
+
+    def test_false_schema(self) -> None:
+        """JSON Schema ``false`` is unsatisfiable → ``never``."""
+
+        assert json_schema_to_ts(False) == "never"

exdrf_ts-0.1.17/tests/mapping_test.py

@@ -0,0 +1,58 @@
+"""Tests for ``exdrf_ts.mapping``."""
+
+from __future__ import annotations
+
+from exdrf_ts.mapping import model_rel_import, py_type_to_ts
+
+
+def test_py_type_to_ts_primitives() -> None:
+    """Primitive names map to TS keywords."""
+
+    assert py_type_to_ts("str") == "string"
+    assert py_type_to_ts("int") == "number"
+    assert py_type_to_ts("float") == "number"
+    assert py_type_to_ts("bool") == "boolean"
+
+
+def test_py_type_to_ts_containers_and_optional() -> None:
+    """List, optional, and dict string forms map as expected."""
+
+    assert py_type_to_ts("List[str]") == "string[]"
+    assert py_type_to_ts("List[int]") == "number[]"
+    assert py_type_to_ts("Optional[str]") == "string | undefined"
+    assert py_type_to_ts("Optional[List[int]]") == "number[] | undefined"
+    assert py_type_to_ts("Dict[str, int]") == "{ [key: string]: number }"
+    assert py_type_to_ts("Dict[int, float]") == "{ [key: number]: number }"
+
+
+def test_py_type_to_ts_runtime_pep604_and_generics() -> None:
+    """Runtime ``type`` / union objects map like annotations."""
+
+    assert py_type_to_ts(str | None) == "string | undefined"
+    assert py_type_to_ts(list[int]) == "number[]"
+    assert py_type_to_ts(dict[str, int]) == "{ [key: string]: number }"
+
+
+def test_model_rel_import_relative_paths() -> None:
+    """Category segments from ``__module__`` yield stable relative paths."""
+
+    def _model_with_category_segments(segments: list[str]) -> type:
+        """Build a type whose ``ExModelVisitor.category`` is ``segments``."""
+
+        class M:
+            pass
+
+        M.__module__ = "pkg." + ".".join(segments) + ".resource"
+        return M
+
+    model = _model_with_category_segments(["Api", "Users", "Profiles"])
+    ref = _model_with_category_segments(["Api"])
+    assert model_rel_import(model, ref) == "Users/Profiles"
+
+    model = _model_with_category_segments(["Api", "Users"])
+    ref = _model_with_category_segments(["Api", "Posts"])
+    assert model_rel_import(model, ref) == "../Users"
+
+    model = _model_with_category_segments(["Api", "Users"])
+    ref = _model_with_category_segments(["Api", "Users"])
+    assert model_rel_import(model, ref) == ""