graphql-codegen 0.1.0__py3-none-any.whl

graphql_codegen/__init__.py

@@ -0,0 +1,7 @@
+from graphql_codegen.config import Config as Config
+from graphql_codegen.document_sibling_module import (
+    DocumentSiblingModule as DocumentSiblingModule,
+)
+from graphql_codegen.generate import generate as generate
+from graphql_codegen.package_location import PackageLocation as PackageLocation
+from graphql_codegen.scalar import Codec as Codec, Scalar as Scalar

graphql_codegen/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from graphql_codegen._cli import main
+
+sys.exit(main())

graphql_codegen/_cli/__init__.py

@@ -0,0 +1,41 @@
+import sys
+from argparse import ArgumentParser, Namespace
+from collections.abc import Sequence
+from pathlib import Path
+from typing import final
+
+from graphql_codegen._cli._graphql_config import read_graphql_config
+from graphql_codegen._cli._write import write
+from graphql_codegen._metadata import DISTRIBUTION_NAME
+from graphql_codegen.generate import generate
+
+
+@final
+class _Args(Namespace):
+    config_path: Path
+
+
+def _parse_args(argv: Sequence[str] | None, /) -> _Args:
+    parser = ArgumentParser(
+        prog=DISTRIBUTION_NAME,
+        description="Generate the package of every project of a graphql-config file.",
+    )
+    parser.add_argument(
+        "config_path",
+        metavar="config",
+        type=Path,
+        help="the path to the graphql-config file, in YAML, JSON, or TOML",
+    )
+    return parser.parse_args(argv, namespace=_Args())
+
+
+def main(argv: Sequence[str] | None = None, /) -> None:
+    cli_args = _parse_args(argv)
+    generate_args_by_directory = read_graphql_config(cli_args.config_path)
+    packages = {
+        directory: generate(**args)
+        for directory, args in generate_args_by_directory.items()
+    }
+    for directory, files in packages.items():
+        write(directory, files)
+        print(f"Wrote {len(files)} files to `{directory}`.", file=sys.stderr)

graphql_codegen/_cli/_graphql_config.py

@@ -0,0 +1,291 @@
+import json
+import os
+import posixpath
+import re
+import tomllib
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass
+from functools import cache
+from pathlib import Path, PurePosixPath
+from typing import Final, final
+
+from graphql import (
+    DocumentNode,
+    GraphQLError,
+    Source,
+    build_ast_schema,
+    parse,
+)
+
+from graphql_codegen._cli._parsing import (
+    check_all_read,
+    optional,
+    parse_at,
+    parse_dict,
+    parse_string,
+    parse_strings,
+    required,
+)
+from graphql_codegen._cli._schema_pointer import SchemaPointer, parse_schema_pointer
+from graphql_codegen._cli._source import read_schema, read_sources
+from graphql_codegen._metadata import DISTRIBUTION_NAME, METADATA
+from graphql_codegen._note import error_note
+from graphql_codegen.config import Config
+from graphql_codegen.document_sibling_module import DocumentSiblingModule
+from graphql_codegen.generate import _Params
+from graphql_codegen.package_location import PackageLocation
+from graphql_codegen.scalar import Codec, Scalar
+
+_EXTENSION_NAME: Final = "pythonCodegen"
+
+# As https://github.com/kamilkisiela/string-env-interpolation/blob/94c441088f2ba62c5f0a2a31b8b9728242184360/src/index.ts#L16, which graphql-config calls at https://github.com/graphql-hive/graphql-config/blob/3091fcc7259c2feeb9866994a6c3ca4fc6ddb7a0/src/helpers/cosmiconfig.ts#L24.
+_ENVIRONMENT_VARIABLE: Final = re.compile(
+    r"\$\{(?P<name>[A-Z0-9_]+)(?::(?P<default>[^}]+))?\}", re.IGNORECASE
+)
+_QUOTED: Final = re.compile(r"\"([^\"]+)\"|'([^']+)'")
+
+
+def read_graphql_config(path: Path, /) -> dict[Path, _Params]:
+    """Return the generation arguments for each project of the graphql-config file at *path* by the directory its package goes to."""
+    load = _get_loader(path)
+    text = path.read_text(encoding="utf-8")
+    config = load(_interpolate(text, environment=os.environ))
+
+    return {
+        directory: _read_project(project, directory=path.parent)
+        for directory, project in _parse_graphql_config(
+            config, directory=PurePosixPath(path.parent.as_posix())
+        ).items()
+    }
+
+
+def _interpolate(text: str, /, *, environment: Mapping[str, str]) -> str:
+    def replacement(match: re.Match[str], /) -> str:
+        name = match["name"]
+
+        # An empty value falls back to the default too.
+        if value := environment.get(name):
+            return value
+
+        if isinstance(default := match["default"], str):
+            stripped = default.strip()
+            quoted = _QUOTED.fullmatch(stripped)
+            # One holding a colon may be quoted, in single or double quotes.
+            return (
+                stripped
+                if quoted is None
+                else next(group for group in quoted.groups() if isinstance(group, str))
+            )
+
+        raise ValueError(
+            f"Expected the environment variable `{name}` to have a value, since `{match[0]}` has no default."
+        )
+
+    return _ENVIRONMENT_VARIABLE.sub(replacement, text)
+
+
+def _get_loader(config_path: Path, /) -> Callable[[str], object]:
+    match config_path.suffix:
+        case ".json":
+            return json.loads
+        case ".toml":
+            return tomllib.loads
+        case ".yaml" | ".yml" | "":
+            # `.graphqlrc` may be YAML or JSON, which YAML reads too.
+            try:
+                import yaml  # noqa: PLC0415
+            except ImportError as error:
+                raise ImportError(
+                    f"`{config_path}` is YAML: install `{DISTRIBUTION_NAME}[{_yaml_extra_name()}]` to read it."
+                ) from error
+
+            return yaml.safe_load
+        case ".js" | ".cjs" | ".mjs" | ".ts" | ".cts" | ".mts":
+            raise ValueError(
+                f"`{config_path}` is JavaScript or TypeScript, which only JavaScript can evaluate: write it in YAML, JSON, or TOML."
+            )
+        case suffix:
+            raise ValueError(
+                f"Cannot tell the format of `{config_path}` from `{suffix}`: expected YAML, JSON, or TOML."
+            )
+
+
+@cache
+def _yaml_extra_name() -> str:
+    name = "yaml"
+    assert name in METADATA.get_all("Provides-Extra", ()), (
+        f"Expected `pyproject.toml` to declare the `{name}` extra."
+    )
+    return name
+
+
+@final
+@dataclass(frozen=True, kw_only=True)
+class _Project:
+    name: str
+    schema: SchemaPointer
+    documents: Sequence[str]
+    package_location: PackageLocation
+    config: Config
+
+
+def _read_project(project: _Project, /, *, directory: Path) -> _Params:
+    with error_note(f"In project `{project.name}`."):
+        return _parse_project(
+            project,
+            schema=read_schema(project.schema, directory=directory),
+            documents=read_sources(project.documents, directory=directory),
+        )
+
+
+def _parse_project(
+    project: _Project,
+    /,
+    *,
+    schema: Sequence[Source],
+    documents: Sequence[Source],
+) -> _Params:
+    try:
+        built_schema = build_ast_schema(_parse_sources(schema))
+    except (GraphQLError, TypeError) as error:
+        # `build_ast_schema()` raises a `TypeError` for an invalid schema.
+        raise ValueError(f"Cannot build the schema: {error}") from error
+
+    return _Params(
+        document=_parse_sources(documents),
+        schema=built_schema,
+        config=project.config,
+    )
+
+
+def _parse_sources(sources: Sequence[Source], /) -> DocumentNode:
+    """Parse *sources* into one document, since a fragment defined in one file may be spread in another, and a schema's types spread over several files."""
+    return DocumentNode(
+        definitions=tuple(
+            definition for source in sources for definition in parse(source).definitions
+        )
+    )
+
+
+def _parse_graphql_config(
+    config: object, /, *, directory: PurePosixPath
+) -> dict[Path, _Project]:
+    """The projects of *config*, the graphql-config file in *directory*, by the directory each package goes to."""
+    root = parse_dict(config)
+    entries = (
+        required(root, "projects", parse_dict)
+        if "projects" in root
+        else {"default": root}
+    )
+    projects: dict[Path, _Project] = {}
+
+    for name, entry in entries.items():
+        with error_note(f"In project `{name}`."):
+            project = _project(entry, name=name, directory=directory)
+
+        if project is None:
+            continue
+
+        # Derived from both, which needs no IO, unlike finding where packages start from a directory.
+
+        package_directory = Path(project.package_location._package_directory)
+
+        if (other := projects.get(package_directory)) is not None:
+            raise ValueError(
+                f"Expected `{other.name}` and `{name}` to generate into directories of their own, but both generate into `{package_directory}`."
+            )
+
+        projects[package_directory] = project
+
+    if not projects:
+        raise ValueError(f"Expected a project with a `{_EXTENSION_NAME}` extension.")
+
+    return projects
+
+
+def _project(
+    value: object, /, *, name: str, directory: PurePosixPath
+) -> _Project | None:
+    entry = parse_dict(value)
+    extensions = optional(entry, "extensions", parse_dict, default={})
+
+    if (extension := extensions.get(_EXTENSION_NAME)) is None:
+        return None
+
+    schema = required(entry, "schema", parse_schema_pointer)
+    documents = required(entry, "documents", parse_strings)
+    package_location, config = parse_at(
+        extension,
+        key=f"extensions.{_EXTENSION_NAME}",
+        parse=lambda value: _extension(value, directory=directory),
+    )
+    return _Project(
+        name=name,
+        schema=schema,
+        documents=documents,
+        package_location=package_location,
+        config=config,
+    )
+
+
+def _extension(
+    value: object, /, *, directory: PurePosixPath
+) -> tuple[PackageLocation, Config]:
+    unread = parse_dict(value)
+
+    module_root = required(unread, "moduleRoot", parse_string)
+    package_location = PackageLocation(
+        module_root=PurePosixPath(posixpath.normpath(directory / module_root)),
+        package=required(unread, "package", parse_string),
+    )
+    document_sibling_module = optional(
+        unread,
+        "documentSiblingModule",
+        lambda value: DocumentSiblingModule(
+            name=parse_string(value), package_location=package_location
+        ),
+        default=None,
+    )
+    injector_names = optional(
+        unread, "injectorNames", parse_strings, default=frozenset()
+    )
+    non_null_directive_name = optional(
+        unread, "nonNullDirectiveName", parse_string, default=None
+    )
+    scalars = optional(unread, "scalars", _scalars, default={})
+    struct_interface_name = optional(
+        unread, "structInterfaceName", parse_string, default=None
+    )
+
+    check_all_read(unread)
+    return package_location, Config(
+        document_sibling_module=document_sibling_module,
+        injector_names=injector_names,
+        non_null_directive_name=non_null_directive_name,
+        scalars=scalars,
+        struct_interface_name=struct_interface_name,
+    )
+
+
+def _scalars(value: object, /) -> dict[str, Scalar]:
+    scalars = parse_dict(value)
+    return {
+        scalar_name: required(scalars, scalar_name, _scalar)
+        for scalar_name in list(scalars)
+    }
+
+
+def _scalar(value: object, /) -> Scalar:
+    unread = parse_dict(value)
+    type_ = required(unread, "type", parse_string)
+    codec = optional(unread, "codec", _codec, default=None)
+    check_all_read(unread)
+    return Scalar(type=type_, codec=codec)
+
+
+def _codec(value: object, /) -> Codec:
+    unread = parse_dict(value)
+    decode = required(unread, "decode", parse_string)
+    encode = required(unread, "encode", parse_string)
+    check_all_read(unread)
+    return Codec(decode=decode, encode=encode)

graphql_codegen/_cli/_introspection.py

@@ -0,0 +1,87 @@
+from collections.abc import Callable, Mapping
+from http.client import HTTPResponse
+from mimetypes import types_map
+from typing import Final, Literal, TypeAlias
+from urllib.request import Request, urlopen
+
+from graphql import (
+    IntrospectionQuery,
+    build_client_schema,
+    get_introspection_query,
+    print_schema,
+)
+
+from graphql_codegen._cli._introspection_graphql import (
+    FieldNames,
+    IntrospectionProbe,
+    IntrospectionProbeData,
+)
+from graphql_codegen._metadata import DISTRIBUTION_NAME, METADATA
+from graphql_codegen.runtime import Client, Operation
+
+_JSON: Final = types_map[".json"]
+_GRAPHQL_RESPONSE: Final = "application/graphql-response+json"
+
+_TIMEOUT: Final = 30.0  # graphql-config has no option for it.
+"""Seconds to wait for each response."""
+
+
+def _field_names(type_: FieldNames, /) -> frozenset[str]:
+    return frozenset(field["name"] for field in type_["fields"])
+
+
+# Not a `type` statement, which could not be called to build the operation.
+_IntrospectionOperation: TypeAlias = Operation[  # noqa: UP040
+    Literal["query"], dict[str, object], IntrospectionQuery
+]
+
+
+def _introspection_operation(
+    probe: IntrospectionProbeData, /
+) -> _IntrospectionOperation:
+    type_fields = _field_names(probe["type"])
+    return _IntrospectionOperation(
+        operation_type="query",
+        name="IntrospectionQuery",
+        document=get_introspection_query(
+            specified_by_url="specifiedByURL" in type_fields,
+            directive_is_repeatable="isRepeatable" in _field_names(probe["directive"]),
+            schema_description="description" in _field_names(probe["schema"]),
+            input_value_deprecation="isDeprecated" in _field_names(probe["inputValue"]),
+            one_of="isOneOf" in type_fields,
+        ),
+        variables_type=dict[str, object],
+        # graphql-core's `IntrospectionQuery` uses `DirectiveLocation`, which it imports only `if TYPE_CHECKING:`.
+        data_type=dict[str, object],  # ty: ignore[invalid-argument-type]
+    )
+
+
+def fetch_sdl(url: str, /, *, headers: Mapping[str, str]) -> str:
+    client = Client(_transport(url, headers=headers))
+    probe = client(IntrospectionProbe({}))
+    introspection_operation = _introspection_operation(probe)
+    introspection_data = client(introspection_operation({}))
+    return print_schema(build_client_schema(introspection=introspection_data))
+
+
+def _transport(url: str, /, *, headers: Mapping[str, str]) -> Callable[[bytes], bytes]:
+    def transport(body: bytes, /) -> bytes:
+        request = Request(  # noqa: S310
+            url,
+            data=body,
+            headers={
+                "Accept": f"{_GRAPHQL_RESPONSE}, {_JSON}",
+                "Content-Type": _JSON,
+                "User-Agent": f"{DISTRIBUTION_NAME}/{METADATA['Version']}",
+                **headers,
+            },
+        )
+
+        response = urlopen(request, timeout=_TIMEOUT)  # noqa: S310
+        # The only response an `http:` or `https:` URL gives.
+        assert isinstance(response, HTTPResponse)
+
+        with response:
+            return response.read()
+
+    return transport

graphql_codegen/_cli/_introspection_graphql.py

@@ -0,0 +1,53 @@
+# Code generated by graphql-codegen from `_introspection.graphql`. DO NOT EDIT.
+
+import builtins as _builtins
+import typing as _typing
+from graphql_codegen.runtime import _compat
+from graphql_codegen.runtime import _reflection
+from graphql_codegen import runtime as _runtime
+
+class _FieldNames_fields(_compat.TypedDict, closed=True):
+    """Object and Interface types are described by a list of Fields, each of which has a name, potentially a list of arguments, and a return type."""
+    name: _builtins.str
+
+class FieldNames(_compat.TypedDict):
+    """The fundamental unit of any GraphQL Schema is the type. There are many kinds of types in GraphQL as represented by the `__TypeKind` enum.
+
+    Depending on the kind of a type, certain fields describe information about that type. Scalar types provide no information beyond a name, description and optional `specifiedByURL`, while Enum types provide their values. Object and Interface types provide the fields they describe. Abstract types, Union and Interface, provide the Object types possible at runtime. List and NonNull types compose other types."""
+    fields: _typing.Annotated[_builtins.list[_FieldNames_fields], _reflection.NON_NULL]
+
+class IntrospectionProbeVariables(_compat.TypedDict, closed=True):
+    ...
+
+class IntrospectionProbeData(_compat.TypedDict, closed=True):
+    schema: _typing.Annotated[FieldNames, _reflection.NON_NULL]
+    """Request the type information of a single type."""
+    type: _typing.Annotated[FieldNames, _reflection.NON_NULL]
+    """Request the type information of a single type."""
+    inputValue: _typing.Annotated[FieldNames, _reflection.NON_NULL]
+    """Request the type information of a single type."""
+    directive: _typing.Annotated[FieldNames, _reflection.NON_NULL]
+    """Request the type information of a single type."""
+
+IntrospectionProbe: _runtime.Operation[_typing.Literal['query'], IntrospectionProbeVariables, IntrospectionProbeData] = _runtime.Operation(operation_type='query', name='IntrospectionProbe', document="""query IntrospectionProbe {
+  schema§: __type(name: "__Schema") {
+    ...FieldNames
+  }
+  type§: __type(name: "__Type") {
+    ...FieldNames
+  }
+  inputValue§: __type(name: "__InputValue") {
+    ...FieldNames
+  }
+  directive§: __type(name: "__Directive") {
+    ...FieldNames
+  }
+}
+
+fragment FieldNames on __Type {
+  fields {
+    name
+  }
+}""", variables_type=IntrospectionProbeVariables, data_type=IntrospectionProbeData)
+"""Which fields the server's introspection types have.
+The full introspection query then asks only for those, since an older server rejects a field it does not know."""

graphql_codegen/_cli/_parsing.py

@@ -0,0 +1,67 @@
+"""Parse the values of a config file, noting where each error is."""
+
+from collections.abc import Callable, Mapping
+from typing import cast
+
+from graphql_codegen._note import error_note
+
+
+def check_all_read(unread: dict[str, object], /) -> None:
+    if unread:
+        raise ValueError(
+            f"Expected no other key, but got {', '.join(f'`{key}`' for key in sorted(unread))}."
+        )
+
+
+def parse_dict(value: object, /) -> dict[str, object]:
+    """Return a shallow-copy of *value*."""
+    if not isinstance(value, Mapping) or not all(isinstance(key, str) for key in value):
+        raise TypeError(f"Expected a mapping with string keys, but got `{value!r}`.")
+
+    return dict(cast(Mapping[str, object], value))
+
+
+def required[T](
+    unread: dict[str, object], key: str, parse: Callable[[object], T], /
+) -> T:
+    value = optional(unread, key, parse, default=None)
+
+    if value is None:
+        raise ValueError(f"Expected `{key}` to be set.")
+
+    return value
+
+
+def optional[T](
+    unread: dict[str, object], key: str, parse: Callable[[object], T], /, *, default: T
+) -> T:
+    value = unread.pop(key, None)
+    return default if value is None else parse_at(value, key=key, parse=parse)
+
+
+def parse_at[T](value: object, /, *, key: str, parse: Callable[[object], T]) -> T:
+    with error_note(f"In `{key}`."):
+        return parse(value)
+
+
+def parse_strings(value: object, /) -> list[str]:
+    if isinstance(value, str):
+        return [value]
+
+    if not isinstance(value, list):
+        raise TypeError(f"Expected a string or a list of strings, but got `{value!r}`.")
+
+    strings: list[str] = []
+
+    for index, item in enumerate(value):
+        with error_note(f"At index {index}."):
+            strings.append(parse_string(item))
+
+    return strings
+
+
+def parse_string(value: object, /) -> str:
+    if not isinstance(value, str):
+        raise TypeError(f"Expected a string, but got `{value!r}`.")
+
+    return value

graphql_codegen/_cli/_schema_pointer.py

@@ -0,0 +1,108 @@
+from collections.abc import Mapping
+from dataclasses import dataclass
+from pathlib import PurePosixPath
+from typing import cast, final
+from urllib.parse import urlsplit
+
+from graphql_codegen._cli._parsing import (
+    check_all_read,
+    optional,
+    parse_at,
+    parse_dict,
+    parse_string,
+    required,
+)
+from graphql_codegen._note import error_note
+
+
+@final
+@dataclass(frozen=True, kw_only=True)
+class Globs:
+    patterns: tuple[str, ...]
+
+
+@final
+@dataclass(frozen=True, kw_only=True)
+class IntrospectionResult:
+    path: PurePosixPath
+
+
+@final
+@dataclass(frozen=True, kw_only=True)
+class Endpoint:
+    url: str
+    headers: Mapping[str, str]
+
+
+type SchemaPointer = Globs | IntrospectionResult | Endpoint
+"""Where a project's schema comes from, in one of the forms https://the-guild.dev/graphql/config/docs/user/schema lists."""
+
+
+def parse_schema_pointer(value: object, /) -> SchemaPointer:
+    match value:
+        case [item]:
+            with error_note("At index 0."):
+                return _parse_single_pointer(item)
+        case list():
+            patterns: list[str] = []
+
+            for index, item in enumerate(value):
+                with error_note(f"At index {index}."):
+                    pointer = _parse_single_pointer(item)
+
+                    if not isinstance(pointer, Globs):
+                        raise TypeError(
+                            f"Expected a glob of SDL files, since the list holds more than one item, but got `{item}`."
+                        )
+
+                # A single item is one glob.
+                (pattern,) = pointer.patterns
+                patterns.append(pattern)
+
+            return Globs(patterns=tuple(patterns))
+        case _:
+            return _parse_single_pointer(value)
+
+
+def _parse_single_pointer(value: object, /) -> SchemaPointer:
+    if isinstance(value, str):
+        if (url := _parse_url(value)) is not None:
+            return Endpoint(url=url, headers={})
+
+        if (path := PurePosixPath(value)).suffix == ".json":
+            return IntrospectionResult(path=path)
+
+        return Globs(patterns=(value,))
+
+    if isinstance(value, Mapping) and len(value) == 1:
+        ((key, options),) = cast(Mapping[object, object], value).items()
+
+        if isinstance(key, str) and (url := _parse_url(key)) is not None:
+            return Endpoint(
+                url=url,
+                headers={}
+                if options is None
+                else parse_at(options, key=key, parse=_parse_endpoint_headers),
+            )
+
+    raise TypeError(
+        f"Expected a glob, a `.json` path, or a URL (possibly mapped to its options), but got `{value!r}`."
+    )
+
+
+def _parse_url(value: str, /) -> str | None:
+    split_result = urlsplit(value)
+
+    return (
+        split_result.geturl()
+        # `urlsplit()` lowercases the scheme, which `geturl()` keeps.
+        if split_result.scheme in {"http", "https"}
+        else None
+    )
+
+
+def _parse_endpoint_headers(value: object, /) -> dict[str, str]:
+    unread = parse_dict(value)
+    headers = optional(unread, "headers", parse_dict, default={})
+    check_all_read(unread)
+    return {name: required(headers, name, parse_string) for name in list(headers)}