scim2-cli 0.4.1__tar.gz → 0.6.0__tar.gz

{scim2_cli-0.4.1 → scim2_cli-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: scim2-cli
-Version: 0.4.1
+Version: 0.6.0
 Summary: SCIM application development CLI
 Keywords: scim,scim2,provisioning,rfc7643,rfc7644
 Author: Yaal Coop
@@ -217,9 +217,9 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Environment :: Web Environment
 Classifier: Programming Language :: Python
 Classifier: Operating System :: OS Independent
-Requires-Dist: click>=8.1.7
-Requires-Dist: scim2-client[httpx2]>=0.11.2
-Requires-Dist: scim2-tester>=0.4.0
+Requires-Dist: click>=8.5.0
+Requires-Dist: scim2-client[httpx2]>=0.13.2
+Requires-Dist: scim2-tester>=0.5.1
 Requires-Dist: sphinx-click-rst-to-ansi-formatter>=0.2.0
 Requires-Dist: pydanclick>=0.5.0
 Requires-Dist: pygments>=2.18.0
@@ -243,8 +243,9 @@ It allows users and groups creations, modifications and deletions to be synchron
 
 ## Features
 
-- **CRUD Commands**: `create`, `query`, `replace` and `delete` resources from the command line
+- **CRUD Commands**: `create`, `query`, `replace`, `modify` and `delete` resources from the command line
 - **Search Command**: Query resources using SCIM filters, sorting and pagination
+- **Bulk Command**: Send bulk requests passed as JSON through stdin
 - **Compliance Testing**: Built-in `test` command using [scim2-tester](https://scim2-tester.readthedocs.io) to validate server RFC compliance
 - **Server Discovery**: Automatic retrieval of server schemas and resource types
 - **Dynamic CLI Options**: Command options generated from server schemas

{scim2_cli-0.4.1 → scim2_cli-0.6.0}/README.md

@@ -11,8 +11,9 @@ It allows users and groups creations, modifications and deletions to be synchron
 
 ## Features
 
-- **CRUD Commands**: `create`, `query`, `replace` and `delete` resources from the command line
+- **CRUD Commands**: `create`, `query`, `replace`, `modify` and `delete` resources from the command line
 - **Search Command**: Query resources using SCIM filters, sorting and pagination
+- **Bulk Command**: Send bulk requests passed as JSON through stdin
 - **Compliance Testing**: Built-in `test` command using [scim2-tester](https://scim2-tester.readthedocs.io) to validate server RFC compliance
 - **Server Discovery**: Automatic retrieval of server schemas and resource types
 - **Dynamic CLI Options**: Command options generated from server schemas

{scim2_cli-0.4.1 → scim2_cli-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "scim2-cli"
-version = "0.4.1"
+version = "0.6.0"
 description = "SCIM application development CLI"
 readme = "README.md"
 keywords = [
@@ -29,9 +29,9 @@ classifiers = [
 ]
 requires-python = ">= 3.11"
 dependencies = [
-    "click>=8.1.7",
-    "scim2-client[httpx2]>=0.11.2",
-    "scim2-tester>=0.4.0",
+    "click>=8.5.0",
+    "scim2-client[httpx2]>=0.13.2",
+    "scim2-tester>=0.5.1",
     "sphinx-click-rst-to-ansi-formatter>=0.2.0",
     "pydanclick>=0.5.0",
     "pygments>=2.18.0",

{scim2_cli-0.4.1 → scim2_cli-0.6.0}/pyproject.toml.orig

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "scim2-cli"
-version = "0.4.1"
+version = "0.6.0"
 description = "SCIM application development CLI"
 authors = [{name="Yaal Coop", email="contact@yaal.coop"}]
 license = {file = "LICENSE.md"}
@@ -26,9 +26,9 @@ classifiers = [
 
 requires-python = ">= 3.11"
 dependencies = [
-    "click>=8.1.7",
-    "scim2-client[httpx2]>=0.11.2",
-    "scim2-tester>=0.4.0",
+    "click>=8.5.0",
+    "scim2-client[httpx2]>=0.13.2",
+    "scim2-tester>=0.5.1",
     "sphinx-click-rst-to-ansi-formatter>=0.2.0",
     "pydanclick>=0.5.0",
     "pygments>=2.18.0",

scim2_cli-0.6.0/scim2_cli/__init__.py

@@ -0,0 +1,88 @@
+from typing import IO
+
+import click
+from sphinx_click.rst_to_ansi_formatter import make_rst_to_ansi_formatter
+
+from scim2_cli.bulk import bulk_cli
+from scim2_cli.create import create_cli
+from scim2_cli.delete import delete_cli
+from scim2_cli.modify import modify_cli
+from scim2_cli.query import query_cli
+from scim2_cli.replace import replace_cli
+from scim2_cli.search import search_cli
+from scim2_cli.session import Session
+from scim2_cli.test import test_cli
+from scim2_cli.utils import DOC_URL
+from scim2_cli.utils import HeaderType
+from scim2_cli.utils import split_headers
+
+
+@click.group(cls=make_rst_to_ansi_formatter(DOC_URL, group=True))
+@click.option("-u", "--url", help="The SCIM server endpoint.", envvar="SCIM_CLI_URL")
+@click.option(
+    "-h",
+    "--header",
+    multiple=True,
+    type=HeaderType(),
+    help="Headers to pass in the HTTP requests. Can be passed multiple times. Other users of the machine can see the command line arguments, so pass the secrets with the SCIM_CLI_HEADERS environment variable.",
+    envvar="SCIM_CLI_HEADERS",
+)
+@click.option(
+    "--no-verify",
+    is_flag=True,
+    default=False,
+    help="Don't perform https certificate verifications.",
+)
+@click.option(
+    "-s",
+    "--schemas",
+    type=click.File(),
+    help="Path to a JSON file containing a list of SCIM Schemas. Those schemas will be assumed to be available on the server. If unset, they will be downloaded.",
+    envvar="SCIM_CLI_SCHEMAS",
+)
+@click.option(
+    "-r",
+    "--resource-types",
+    type=click.File(),
+    help="Path to a JSON file containing a list of SCIM ResourceType. Those resource types will be assumed to be available on the server. If unset, they will be downloaded.",
+    envvar="SCIM_CLI_RESOURCE_TYPES",
+)
+@click.option(
+    "-c",
+    "--service-provider-config",
+    type=click.File(),
+    help="Path to a JSON file containing the ServiceProviderConfig content of the server. Will be downloaded otherwise.",
+    envvar="SCIM_CLI_SERVICE_PROVIDER_CONFIG",
+)
+@click.pass_context
+def cli(
+    ctx: click.Context,
+    url: str | None,
+    header: list[str],
+    no_verify: bool,
+    schemas: IO[str] | None,
+    resource_types: IO[str] | None,
+    service_provider_config: IO[str] | None,
+) -> None:
+    """SCIM application development CLI."""
+    ctx.obj = Session(
+        url=url,
+        headers=split_headers(header),
+        verify=not no_verify,
+        schemas=schemas,
+        resource_types=resource_types,
+        service_provider_config=service_provider_config,
+    )
+
+
+cli.add_command(create_cli)
+cli.add_command(query_cli)
+cli.add_command(replace_cli)
+cli.add_command(modify_cli)
+cli.add_command(delete_cli)
+cli.add_command(search_cli)
+cli.add_command(bulk_cli)
+cli.add_command(test_cli)
+
+if __name__ == "__main__":  # pragma: no cover
+    cli()

scim2_cli-0.6.0/scim2_cli/bulk.py

@@ -0,0 +1,36 @@
+import click
+from sphinx_click.rst_to_ansi_formatter import make_rst_to_ansi_formatter
+
+from scim2_cli.utils import DOC_URL
+from scim2_cli.utils import SCIM_EXCEPTIONS
+from scim2_cli.utils import echo_response
+from scim2_cli.utils import exception_to_click_error
+from scim2_cli.utils import indent_option
+
+
+@click.command(cls=make_rst_to_ansi_formatter(DOC_URL), name="bulk")
+@indent_option()
+@click.pass_context
+def bulk_cli(ctx: click.Context, indent: bool) -> None:
+    """Perform a `SCIM bulk <https://www.rfc-editor.org/rfc/rfc7644#section-3.7>`_ request.
+
+    The bulk request is passed through stdin in JSON format:
+
+    .. code-block:: bash
+
+        echo '{"schemas": ["urn:ietf:params:scim:api:messages:2.0:BulkRequest"], "Operations": [{"method": "POST", "path": "/Users", "bulkId": "qwerty", "data": {"schemas": ["urn:ietf:params:scim:schemas:core:2.0:User"], "userName": "bjensen@example.com"}}]}' |  bulk
+
+    The request is checked against the bulk capabilities of the server before being sent.
+    """
+    payload = ctx.obj.stdin
+    if not payload:
+        click.echo(ctx.get_help())
+        ctx.exit(1)
+
+    try:
+        response = ctx.obj.client.bulk(payload, raise_scim_errors=False)
+
+    except SCIM_EXCEPTIONS as scim_exc:
+        raise exception_to_click_error(scim_exc) from scim_exc
+
+    echo_response(response, indent)

{scim2_cli-0.4.1 → scim2_cli-0.6.0}/scim2_cli/create.py

@@ -2,59 +2,68 @@ from typing import Any
 from typing import cast
 
 import click
-from click import ClickException
 from pydanclick import from_pydantic
+from scim2_client import Me
 from scim2_client.engines.httpx2 import SyncSCIMClient
 from scim2_models import Context
 from scim2_models import Error
 from scim2_models import Resource
+from scim2_models import ResourceType
 from sphinx_click.rst_to_ansi_formatter import make_rst_to_ansi_formatter
 
 from scim2_cli.utils import DOC_URL
 from scim2_cli.utils import SCIM_EXCEPTIONS
 from scim2_cli.utils import ModelCommand
+from scim2_cli.utils import command_name
+from scim2_cli.utils import echo_response
 from scim2_cli.utils import escape_options_help
 from scim2_cli.utils import exception_to_click_error
-from scim2_cli.utils import formatted_payload
+from scim2_cli.utils import indent_option
+from scim2_cli.utils import inherited
+from scim2_cli.utils import me_option
+from scim2_cli.utils import renamed_fields
 from scim2_cli.utils import unacceptable_fields
 
 
 def create_payload(
-    client: SyncSCIMClient, payload: Resource[Any] | dict[str, Any], indent: bool
+    client: SyncSCIMClient,
+    resource_type: ResourceType | None,
+    payload: Resource[Any] | dict[str, Any],
+    indent: bool,
+    me: bool,
 ) -> None:
     try:
         # Response payloads are always checked, so the client never returns a dict.
         response = cast(
-            "Resource[Any] | Error", client.create(payload, raise_scim_errors=False)
+            "Resource[Any] | Error",
+            client.create(
+                Me if me else resource_type, payload, raise_scim_errors=False
+            ),
         )
 
     except SCIM_EXCEPTIONS as scim_exc:
         raise exception_to_click_error(scim_exc) from scim_exc
 
-    click.echo(formatted_payload(response.model_dump(), indent))
+    echo_response(response, indent)
 
 
-def create_factory(model: type[Resource[Any]] | None) -> click.Command:
-    if not model:
-        raise ClickException("Invalid model")
-
+def create_factory(
+    resource_type: ResourceType, model: type[Resource[Any]]
+) -> click.Command:
     exclude = unacceptable_fields(Context.RESOURCE_CREATION_REQUEST, model)
 
     @click.command(
         cls=make_rst_to_ansi_formatter(DOC_URL),
-        name=model.__name__.lower(),
-    )
-    @click.option(
-        "--indent/--no-indent",
-        is_flag=True,
-        default=True,
-        help="Indent JSON response payloads.",
+        name=command_name(resource_type),
     )
-    @from_pydantic("obj", model, exclude=exclude)
+    @indent_option("cli_indent")
+    @me_option("cli_me")
+    @from_pydantic("obj", model, exclude=exclude, rename=renamed_fields(model, exclude))
     @click.pass_context
     def create_command(
         ctx: click.Context,
-        indent: bool,
+        cli_indent: bool,
+        cli_me: bool,
         obj: Resource[Any] | None,
         *args: Any,
         **kwargs: Any,
@@ -71,8 +80,8 @@ def create_factory(model: type[Resource[Any]] | None) -> click.Command:
 
         .. code-block:: bash
 
-            scim create user \\
-                --user-name "foo" \\
+            scim create user \
+                --user-name "foo" \
                 --emails '[{"value":"foo@bar.example", "primary": true}, {"value": "foo@baz.example"}]'
 
         Input can also be passed through stdin in JSON format:
@@ -81,16 +90,29 @@ def create_factory(model: type[Resource[Any]] | None) -> click.Command:
 
             echo '{"userName": "bjensen@example.com", "schemas": ["urn:ietf:params:scim:schemas:core:2.0:User"]}' |  create user
 
+        With :code:`--me`, the request is made on the :code:`/Me` endpoint,
+        and the server chooses the resource type:
+
+        .. code-block:: bash
+
+            scim create user --me --user-name "foo"
+
         """
         if obj == model():
             obj = None
 
-        payload = ctx.obj.get("stdin") or obj
+        payload = ctx.obj.stdin or obj
         if not payload:
             click.echo(ctx.get_help())
             ctx.exit(1)
 
-        create_payload(ctx.obj["client"], payload, indent)
+        create_payload(
+            ctx.obj.client,
+            resource_type,
+            payload,
+            inherited(ctx, "cli_indent", cli_indent),
+            inherited(ctx, "cli_me", cli_me),
+        )
 
     return escape_options_help(create_command)
 
@@ -102,16 +124,12 @@ def create_factory(model: type[Resource[Any]] | None) -> click.Command:
     invoke_without_command=True,
 )
 @click.pass_context
-@click.option(
-    "--indent/--no-indent",
-    is_flag=True,
-    default=True,
-    help="Indent JSON response payloads.",
-)
-def create_cli(ctx: click.Context, indent: bool) -> None:
+@indent_option("cli_indent")
+@me_option("cli_me")
+def create_cli(ctx: click.Context, cli_indent: bool, cli_me: bool) -> None:
     """Perform a `SCIM POST <https://www.rfc-editor.org/rfc/rfc7644#section-3.3>`_ request on resources endpoint.
 
-    There are subcommands for all the available models, with dynamic attributes.
+    There are subcommands for all the resource types of the server, with dynamic attributes.
     See the attributes for :code:`user` with:
 
     .. code-block:: bash
@@ -124,13 +142,16 @@ def create_cli(ctx: click.Context, indent: bool) -> None:
 
         echo '{"userName": "bjensen@example.com", "schemas": ["urn:ietf:params:scim:schemas:core:2.0:User"]}' |  create
 
+    With :code:`--me`, the request is made on the :code:`/Me` endpoint,
+    and the server chooses the resource type.
+
     """
     if ctx.invoked_subcommand is not None:
         return
 
-    payload = ctx.obj.get("stdin")
+    payload = ctx.obj.stdin
     if not payload:
         click.echo(ctx.get_help())
         ctx.exit(1)
 
-    create_payload(ctx.obj["client"], payload, indent)
+    create_payload(ctx.obj.client, None, payload, cli_indent, cli_me)

scim2_cli-0.6.0/scim2_cli/delete.py

@@ -0,0 +1,59 @@
+import click
+from click import ClickException
+from scim2_client import Me
+from sphinx_click.rst_to_ansi_formatter import make_rst_to_ansi_formatter
+
+from scim2_cli.utils import exception_to_click_error
+from scim2_cli.utils import find_target
+from scim2_cli.utils import me_option
+
+from .utils import DOC_URL
+from .utils import SCIM_EXCEPTIONS
+from .utils import echo_response
+
+
+@click.command(cls=make_rst_to_ansi_formatter(DOC_URL), name="delete")
+@click.argument("resource-type", required=False)
+@click.argument("id", required=False)
+@me_option()
+@click.option(
+    "--indent/--no-indent",
+    is_flag=True,
+    default=True,
+    help="Indent JSON response payloads.",
+)
+@click.pass_context
+def delete_cli(
+    ctx: click.Context,
+    resource_type: str | None,
+    id: str | None,
+    me: bool,
+    indent: bool,
+) -> None:
+    """Perform a `SCIM DELETE query <https://www.rfc-editor.org/rfc/rfc7644#section-3.6>`_ request.
+
+    .. code-block:: bash
+
+         delete user 1234
+
+    With :code:`--me`, the request is made on the :code:`/Me` endpoint:
+
+    .. code-block:: bash
+
+         delete --me
+    """
+    if me and (resource_type or id):
+        raise ClickException("--me cannot be used with a resource type or an id.")
+
+    if not me and not (resource_type and id):
+        raise ClickException("Pass a resource type and an id, or --me.")
+
+    target = find_target(ctx.obj.resource_types, resource_type) if resource_type else Me
+
+    try:
+        response = ctx.obj.client.delete(target, id, raise_scim_errors=False)
+
+    except SCIM_EXCEPTIONS as scim_exc:
+        raise exception_to_click_error(scim_exc) from scim_exc
+
+    echo_response(response, indent)

scim2_cli-0.6.0/scim2_cli/modify.py

@@ -0,0 +1,209 @@
+import json
+from decimal import Decimal
+from typing import Any
+
+import click
+from click import ClickException
+from pydantic import ValidationError
+from scim2_client import Me
+from scim2_models import BaseModel
+from scim2_models import Context
+from scim2_models import Error
+from scim2_models import InvalidPathException
+from scim2_models import PatchOp
+from scim2_models import Path
+from scim2_models import Resource
+from scim2_models import SCIMException
+from sphinx_click.rst_to_ansi_formatter import make_rst_to_ansi_formatter
+
+from scim2_cli.utils import DOC_URL
+from scim2_cli.utils import SCIM_EXCEPTIONS
+from scim2_cli.utils import echo_response
+from scim2_cli.utils import escape_control_characters
+from scim2_cli.utils import exception_to_click_error
+from scim2_cli.utils import find_target
+from scim2_cli.utils import indent_option
+from scim2_cli.utils import me_option
+
+OPERATIONS = {"add": 2, "replace": 2, "remove": 1}
+JSON_TYPES = (bool, int, float, Decimal, BaseModel)
+
+
+def parse_operations(tokens: tuple[str, ...]) -> list[tuple[str, str, str | None]]:
+    """Split the arguments into operations, each one followed by its path and its value."""
+    operations: list[tuple[str, str, str | None]] = []
+    index = 0
+    while index < len(tokens):
+        op = tokens[index].lower()
+        if op not in OPERATIONS:
+            raise ClickException(
+                f"Unknown operation '{escape_control_characters(tokens[index])}'. "
+                f"Available values are: {', '.join(OPERATIONS)}"
+            )
+
+        nargs = OPERATIONS[op]
+        arguments = tokens[index + 1 : index + 1 + nargs]
+        if len(arguments) < nargs or (op == "remove" and not arguments[0]):
+            expected = "a path and a value" if nargs == 2 else "a path"
+            raise ClickException(f"The '{op}' operation takes {expected}.")
+
+        path, *value = arguments
+        operations.append((op, path, value[0] if value else None))
+        index += 1 + nargs
+
+    return operations
+
+
+def serves(model: type[Resource[Any]], path: str) -> bool:
+    """Tell whether a path designates an attribute or an extension of a model."""
+    bound = Path[model](path)  # type: ignore[valid-type]
+    return bound.resolve() is not None or bound.model is not None
+
+
+def is_json(model: type[Resource[Any]], path: str) -> bool:
+    """Tell whether the value of an attribute is written in JSON rather than as a plain string."""
+    bound = Path[model](path)  # type: ignore[valid-type]
+    binding = bound.resolve()
+    if binding is None:
+        return True
+
+    if binding.is_multivalued and not binding.sub_field_name and not bound.value_filter:
+        return True
+
+    target = binding.target_type
+    return isinstance(target, type) and issubclass(target, JSON_TYPES)
+
+
+def read_value(model: type[Resource[Any]], path: str, value: str) -> Any:
+    """Read a value with the type of the attribute it is meant for."""
+    if not is_json(model, path):
+        return value
+
+    try:
+        return json.loads(value)
+    except json.JSONDecodeError as exc:
+        raise ClickException(
+            f"Invalid JSON value for '{escape_control_characters(path)}': {exc}"
+        ) from exc
+
+
+def build_patch(
+    models: list[type[Resource[Any]]], operations: list[tuple[str, str, str | None]]
+) -> PatchOp[Resource[Any]]:
+    """Build the patch operation of the first model that has all the attributes."""
+    paths = [path for _, path, _ in operations]
+    for path in paths:
+        try:
+            Path(path)
+        except InvalidPathException as exc:
+            raise ClickException(
+                f"Invalid path '{escape_control_characters(path)}': {exc}"
+            ) from exc
+
+    model = next(
+        (model for model in models if all(serves(model, path) for path in paths)),
+        None,
+    )
+    if model is None:
+        unknown = [
+            path for path in paths if not any(serves(model, path) for model in models)
+        ]
+        message = (
+            "Unknown attributes: "
+            if unknown
+            else "No resource type has all the attributes: "
+        )
+        raise ClickException(
+            message
+            + ", ".join(escape_control_characters(path) for path in unknown or paths)
+        )
+
+    patch_operations = []
+    for op, path, value in operations:
+        operation = {"op": op}
+        if path:
+            operation["path"] = path
+        if value is not None:
+            operation["value"] = read_value(model, path, value)
+        patch_operations.append(operation)
+
+    try:
+        return PatchOp[model].model_validate({"Operations": patch_operations})  # type: ignore[valid-type]
+    except ValidationError as exc:
+        error = Error.from_validation_errors(exc)[0]
+        raise exception_to_click_error(
+            SCIMException.from_error(error, scim_ctx=Context.RESOURCE_PATCH_REQUEST)
+        ) from exc
+
+
+@click.command(cls=make_rst_to_ansi_formatter(DOC_URL), name="modify")
+@click.argument("arguments", nargs=-1, metavar="[RESOURCE_TYPE ID] OPERATION...")
+@me_option()
+@indent_option()
+@click.pass_context
+def modify_cli(
+    ctx: click.Context, arguments: tuple[str, ...], me: bool, indent: bool
+) -> None:
+    r"""Perform a `SCIM PATCH <https://www.rfc-editor.org/rfc/rfc7644#section-3.5.2>`_ request.
+
+    The operations follow the resource type and the id. They are applied in order:
+
+    - :code:`add PATH VALUE` adds a value,
+    - :code:`replace PATH VALUE` replaces a value,
+    - :code:`remove PATH` removes a value.
+
+    .. code-block:: bash
+
+        modify user 1234 replace displayName "Barbara Jensen" \
+            remove 'emails[type eq "work"]' \
+            add emails '[{"value": "bjensen@example.com", "type": "work"}]'
+
+    Values of string attributes are passed as is, the other values are passed in JSON.
+    An empty path applies a JSON object of attributes to the resource.
+    Pass :code:`--` before the operations if a value starts with :code:`-`.
+
+    With :code:`--me`, the request is made on the :code:`/Me` endpoint:
+
+    .. code-block:: bash
+
+        modify --me replace displayName "Barbara Jensen"
+
+    A patch operation can also be passed through stdin in JSON format:
+
+    .. code-block:: bash
+
+        echo '{"schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"], "Operations": [{"op": "replace", "value": {"displayName": "Barbara Jensen"}}]}' |  modify user 1234
+
+    """
+    resource_types = ctx.obj.resource_types
+    provider = ctx.obj.client.provider
+    if me and arguments and arguments[0].lower() in resource_types:
+        raise ClickException("--me cannot be used with a resource type or an id.")
+
+    if me:
+        target, id, tokens = Me, None, arguments
+        models = list(
+            dict.fromkeys(provider.model_for(rt) for rt in resource_types.values())
+        )
+    elif len(arguments) < 2:
+        raise ClickException("Pass a resource type and an id, or --me.")
+    else:
+        target = find_target(resource_types, arguments[0])
+        id, tokens = arguments[1], arguments[2:]
+        models = [provider.model_for(target)]
+
+    stdin = ctx.obj.stdin
+    if stdin and tokens:
+        raise ClickException("Pass the operations either as arguments or to stdin.")
+
+    if not stdin and not tokens:
+        raise ClickException("Missing operation.")
+
+    payload = stdin or build_patch(models, parse_operations(tokens))
+    try:
+        response = ctx.obj.client.modify(target, id, payload, raise_scim_errors=False)
+
+    except SCIM_EXCEPTIONS as scim_exc:
+        raise exception_to_click_error(scim_exc) from scim_exc
+
+    echo_response(response, indent)