pipefy-cli 0.3.0a1__py3-none-any.whl

pipefy_cli/commands/record.py

@@ -0,0 +1,219 @@
+"""Database table record subcommands."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import typer
+from pipefy_sdk import (
+    UPDATE_TABLE_RECORD_ALLOWED_FIELD_KEYS,
+    UPDATE_TABLE_RECORD_FIELDS_ERROR_MESSAGE,
+    PipefyClient,
+)
+
+from pipefy_cli.commands._common import (
+    ID_POSITIONAL_CONTEXT_SETTINGS,
+    confirm_destructive,
+    parse_json_object,
+    parse_json_value,
+    resource_id_argument,
+    run_cli_command,
+)
+
+record_app = typer.Typer(help="Table record operations.", no_args_is_help=True)
+
+_TABLE_RECORDS_FIRST_MAX = 200
+
+
+def _parse_fields_json(raw: str | None) -> dict[str, Any] | list[dict[str, Any]] | None:
+    if raw is None or raw.strip() == "":
+        return None
+    parsed = parse_json_value(raw, "--fields")
+    if isinstance(parsed, dict | list):
+        return parsed
+    raise typer.BadParameter("--fields must be a JSON object or array")
+
+
+@record_app.command("find")
+def record_find(
+    ctx: typer.Context,
+    table_id: str = typer.Option(..., "--table", help="Database table id."),
+    filter_json: str | None = typer.Option(
+        None,
+        "--filter",
+        help=(
+            'JSON object: either {"field_id":"...","field_value":"..."} for findRecords, '
+            "or omit field_id/field_value to page all records (get_table_records)."
+        ),
+    ),
+    first: int | None = typer.Option(
+        None,
+        "--first",
+        help="Page size (1-200 for listing; optional for field search).",
+    ),
+    after: str | None = typer.Option(None, "--after", help="Pagination cursor."),
+    json_out: bool = typer.Option(False, "--json", "-j"),
+) -> None:
+    """Find records: field match (``find_records``) or list page (``get_table_records``)."""
+
+    filt = parse_json_object(filter_json, "--filter") if filter_json else {}
+    has_field_id = "field_id" in filt
+    has_field_value = "field_value" in filt
+    if has_field_id != has_field_value:
+        raise typer.BadParameter(
+            "--filter must include both 'field_id' and 'field_value' as strings, or neither."
+        )
+    if has_field_id:
+        fid = filt["field_id"]
+        fval = filt["field_value"]
+        if not (isinstance(fid, str) and isinstance(fval, str)):
+            raise typer.BadParameter(
+                "filter.field_id and filter.field_value must be strings."
+            )
+        nfirst = first
+        if nfirst is not None and (nfirst < 1 or nfirst > _TABLE_RECORDS_FIRST_MAX):
+            raise typer.BadParameter(
+                f"--first must be between 1 and {_TABLE_RECORDS_FIRST_MAX}."
+            )
+
+        async def factory(client: PipefyClient):
+            return await client.find_records(
+                table_id,
+                fid.strip(),
+                fval,
+                first=nfirst,
+                after=after,
+            )
+
+        run_cli_command(ctx, json_out, factory)
+        return
+
+    nfirst = first if first is not None else 50
+    if nfirst < 1 or nfirst > _TABLE_RECORDS_FIRST_MAX:
+        raise typer.BadParameter(
+            f"--first must be between 1 and {_TABLE_RECORDS_FIRST_MAX} (default 50)."
+        )
+
+    async def factory(client: PipefyClient):
+        return await client.get_table_records(table_id, first=nfirst, after=after)
+
+    run_cli_command(ctx, json_out, factory)
+
+
+@record_app.command("get", context_settings=ID_POSITIONAL_CONTEXT_SETTINGS)
+def record_get(
+    ctx: typer.Context,
+    record_id: str = resource_id_argument(help="Table record id."),
+    json_out: bool = typer.Option(False, "--json", "-j"),
+) -> None:
+    """Load one table record by id."""
+
+    async def factory(client: PipefyClient):
+        return await client.get_table_record(record_id)
+
+    run_cli_command(ctx, json_out, factory)
+
+
+@record_app.command("create")
+def record_create(
+    ctx: typer.Context,
+    table_id: str = typer.Option(..., "--table", help="Database table id."),
+    fields_json: str | None = typer.Option(
+        None,
+        "--fields",
+        help="JSON object or array of field values for the new record.",
+    ),
+    title: str | None = typer.Option(None, "--title", "-t"),
+    extra_json: str | None = typer.Option(
+        None,
+        "--extra",
+        help="JSON object of extra CreateTableRecordInput keys.",
+    ),
+    json_out: bool = typer.Option(False, "--json", "-j"),
+) -> None:
+    """Create a table record."""
+
+    fields = _parse_fields_json(fields_json)
+    extra = parse_json_object(extra_json, "--extra") or {}
+    payload = fields if fields is not None else {}
+    merged: dict[str, Any] = {**extra}
+    if title is not None:
+        merged["title"] = title
+
+    async def factory(client: PipefyClient):
+        return await client.create_table_record(table_id, payload, **merged)
+
+    run_cli_command(ctx, json_out, factory, exit_code_2_on_value_error=True)
+
+
+@record_app.command("update", context_settings=ID_POSITIONAL_CONTEXT_SETTINGS)
+def record_update(
+    ctx: typer.Context,
+    record_id: str = resource_id_argument(help="Table record id."),
+    fields_json: str | None = typer.Option(
+        None,
+        "--fields",
+        help="JSON object: title, due_date, status_id or statusId (update_table_record).",
+    ),
+    field_id: str | None = typer.Option(
+        None,
+        "--field-id",
+        help="When set with --value, calls set_table_record_field_value instead.",
+    ),
+    value_json: str | None = typer.Option(
+        None,
+        "--value",
+        help="JSON value for --field-id (string, number, array, or object).",
+    ),
+    json_out: bool = typer.Option(False, "--json", "-j"),
+) -> None:
+    """Update record core fields or one custom field."""
+
+    if field_id is not None:
+        if not field_id.strip():
+            raise typer.BadParameter("--field-id must be non-empty when provided.")
+        if value_json is None:
+            raise typer.BadParameter("Provide --value JSON when using --field-id.")
+        parsed_val = parse_json_value(value_json, "--value")
+
+        async def factory_set(client: PipefyClient):
+            return await client.set_table_record_field_value(
+                record_id, field_id.strip(), parsed_val
+            )
+
+        run_cli_command(ctx, json_out, factory_set, exit_code_2_on_value_error=True)
+        return
+
+    fields = parse_json_object(fields_json, "--fields")
+    if not fields:
+        raise typer.BadParameter(
+            "Provide --fields for title/due_date/status or --field-id and --value."
+        )
+    if not any(
+        key in UPDATE_TABLE_RECORD_ALLOWED_FIELD_KEYS and value is not None
+        for key, value in fields.items()
+    ):
+        typer.echo(UPDATE_TABLE_RECORD_FIELDS_ERROR_MESSAGE, err=True)
+        raise typer.Exit(2)
+
+    async def factory(client: PipefyClient):
+        return await client.update_table_record(record_id, fields)
+
+    run_cli_command(ctx, json_out, factory, exit_code_2_on_value_error=True)
+
+
+@record_app.command("delete", context_settings=ID_POSITIONAL_CONTEXT_SETTINGS)
+def record_delete(
+    ctx: typer.Context,
+    record_id: str = resource_id_argument(help="Table record id."),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt."),
+    json_out: bool = typer.Option(False, "--json", "-j"),
+) -> None:
+    """Delete a table record permanently."""
+
+    confirm_destructive(yes=yes, description=f"table record {record_id}")
+
+    async def factory(client: PipefyClient):
+        return await client.delete_table_record(record_id)
+
+    run_cli_command(ctx, json_out, factory, exit_code_2_on_value_error=True)

pipefy_cli/commands/relation.py

@@ -0,0 +1,173 @@
+"""Pipe and card relation subcommands."""
+
+from __future__ import annotations
+
+import typer
+from pipefy_sdk import PipefyClient
+
+from pipefy_cli.commands._common import (
+    ID_POSITIONAL_CONTEXT_SETTINGS,
+    confirm_destructive,
+    parse_json_object,
+    resource_id_argument,
+    run_cli_command,
+)
+
+relation_app = typer.Typer(help="Pipe and card relations.", no_args_is_help=True)
+relation_pipe_app = typer.Typer(help="Pipe-to-pipe relations.", no_args_is_help=True)
+relation_card_app = typer.Typer(help="Card-to-card relations.", no_args_is_help=True)
+
+
+@relation_pipe_app.command("list", context_settings=ID_POSITIONAL_CONTEXT_SETTINGS)
+def relation_pipe_list(
+    ctx: typer.Context,
+    pipe_id: str = resource_id_argument(help="Pipe id."),
+    json_out: bool = typer.Option(False, "--json", "-j"),
+) -> None:
+    """List pipe relations for a pipe."""
+
+    async def factory(client: PipefyClient):
+        return await client.get_pipe_relations(pipe_id)
+
+    run_cli_command(ctx, json_out, factory)
+
+
+@relation_pipe_app.command("create")
+def relation_pipe_create(
+    ctx: typer.Context,
+    parent_id: str = typer.Option(..., "--parent", help="Parent pipe id."),
+    child_id: str = typer.Option(..., "--child", help="Child pipe id."),
+    name: str = typer.Option(..., "--name", "-n", help="Relation name."),
+    extra_json: str | None = typer.Option(
+        None,
+        "--extra",
+        help="JSON object merged into CreatePipeRelationInput.",
+    ),
+    json_out: bool = typer.Option(False, "--json", "-j"),
+) -> None:
+    """Create a pipe relation."""
+
+    nm = name.strip()
+    if not nm:
+        typer.echo("--name must be non-empty.", err=True)
+        raise typer.Exit(2)
+    extra = parse_json_object(extra_json, "--extra")
+
+    async def factory(client: PipefyClient):
+        return await client.create_pipe_relation(
+            parent_id, child_id, nm, extra_input=extra
+        )
+
+    run_cli_command(ctx, json_out, factory)
+
+
+@relation_pipe_app.command("update", context_settings=ID_POSITIONAL_CONTEXT_SETTINGS)
+def relation_pipe_update(
+    ctx: typer.Context,
+    relation_id: str = resource_id_argument(help="Pipe relation id."),
+    name: str = typer.Option(..., "--name", "-n", help="New relation name."),
+    extra_json: str | None = typer.Option(
+        None,
+        "--extra",
+        help="JSON object merged into UpdatePipeRelationInput.",
+    ),
+    json_out: bool = typer.Option(False, "--json", "-j"),
+) -> None:
+    """Update a pipe relation."""
+
+    nm = name.strip()
+    if not nm:
+        typer.echo("--name must be non-empty.", err=True)
+        raise typer.Exit(2)
+    extra = parse_json_object(extra_json, "--extra")
+
+    async def factory(client: PipefyClient):
+        return await client.update_pipe_relation(relation_id, nm, extra_input=extra)
+
+    run_cli_command(ctx, json_out, factory)
+
+
+@relation_pipe_app.command("delete", context_settings=ID_POSITIONAL_CONTEXT_SETTINGS)
+def relation_pipe_delete(
+    ctx: typer.Context,
+    relation_id: str = resource_id_argument(help="Pipe relation id."),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt."),
+    json_out: bool = typer.Option(False, "--json", "-j"),
+) -> None:
+    """Delete a pipe relation permanently."""
+
+    confirm_destructive(yes=yes, description=f"pipe relation {relation_id}")
+
+    async def factory(client: PipefyClient):
+        return await client.delete_pipe_relation(relation_id)
+
+    run_cli_command(ctx, json_out, factory)
+
+
+@relation_card_app.command("list", context_settings=ID_POSITIONAL_CONTEXT_SETTINGS)
+def relation_card_list(
+    ctx: typer.Context,
+    card_id: str = resource_id_argument(help="Card id."),
+    json_out: bool = typer.Option(False, "--json", "-j"),
+) -> None:
+    """List parent and child relations for a card (raw ``get_card_relations`` payload)."""
+
+    async def factory(client: PipefyClient):
+        return await client.get_card_relations(card_id)
+
+    run_cli_command(ctx, json_out, factory)
+
+
+@relation_card_app.command("create")
+def relation_card_create(
+    ctx: typer.Context,
+    parent_id: str = typer.Option(..., "--parent", help="Parent card id."),
+    child_id: str = typer.Option(..., "--child", help="Child card id."),
+    source_id: str = typer.Option(
+        ...,
+        "--source",
+        help="Pipe relation id from ``relation pipe list``.",
+    ),
+    extra_json: str | None = typer.Option(
+        None,
+        "--extra",
+        help="JSON object merged into CreateCardRelationInput.",
+    ),
+    json_out: bool = typer.Option(False, "--json", "-j"),
+) -> None:
+    """Link two cards via an existing pipe relation."""
+
+    extra = parse_json_object(extra_json, "--extra")
+
+    async def factory(client: PipefyClient):
+        return await client.create_card_relation(
+            parent_id, child_id, source_id, extra_input=extra
+        )
+
+    run_cli_command(ctx, json_out, factory)
+
+
+@relation_card_app.command("delete")
+def relation_card_delete(
+    ctx: typer.Context,
+    child_id: str = typer.Option(..., "--child", help="Child card id."),
+    parent_id: str = typer.Option(..., "--parent", help="Parent card id."),
+    source_id: str = typer.Option(..., "--source", help="Pipe relation id."),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt."),
+    json_out: bool = typer.Option(False, "--json", "-j"),
+) -> None:
+    """Remove a card relation (Internal API, requires OAuth)."""
+
+    confirm_destructive(
+        yes=yes,
+        description=f"card relation (child={child_id}, parent={parent_id}, source={source_id})",
+    )
+
+    async def factory(c: PipefyClient):
+        return await c.delete_card_relation(child_id, parent_id, source_id)
+
+    run_cli_command(ctx, json_out, factory)
+
+
+relation_app.add_typer(relation_pipe_app, name="pipe")
+relation_app.add_typer(relation_card_app, name="card")

pipefy_cli/commands/report_org.py

@@ -0,0 +1,241 @@
+"""Organization-level reports."""
+
+from __future__ import annotations
+
+import typer
+from pipefy_sdk import PipefyClient
+
+from pipefy_cli.commands._common import (
+    ID_POSITIONAL_CONTEXT_SETTINGS,
+    confirm_destructive,
+    parse_json_object,
+    parse_json_value,
+    prepare_report_cards_filter_cli,
+    resource_id_argument,
+    run_cli_command,
+    run_pipefy_client_coroutine,
+    write_export_csv_to_stdout,
+)
+
+report_org_app = typer.Typer(help="Organization reports.", no_args_is_help=True)
+
+
+@report_org_app.command("list")
+def report_org_list(
+    ctx: typer.Context,
+    organization: str = typer.Option(..., "--organization", "--org"),
+    first: int = typer.Option(30, "--first", help="Page size."),
+    after: str | None = typer.Option(None, "--after", help="Pagination cursor."),
+    json_out: bool = typer.Option(
+        False, "--json", "-j", help="Print machine-readable JSON to stdout."
+    ),
+) -> None:
+    """List organization reports (``get_organization_reports``)."""
+
+    async def factory(client: PipefyClient):
+        return await client.get_organization_reports(
+            organization, first=first, after=after
+        )
+
+    run_cli_command(ctx, json_out, factory)
+
+
+@report_org_app.command("get", context_settings=ID_POSITIONAL_CONTEXT_SETTINGS)
+def report_org_get(
+    ctx: typer.Context,
+    report_id: str = resource_id_argument(help="Organization report id."),
+    json_out: bool = typer.Option(
+        False, "--json", "-j", help="Print machine-readable JSON to stdout."
+    ),
+) -> None:
+    """Fetch one organization report (``get_organization_report``)."""
+
+    async def factory(client: PipefyClient):
+        return await client.get_organization_report(report_id)
+
+    run_cli_command(ctx, json_out, factory)
+
+
+@report_org_app.command("create")
+def report_org_create(
+    ctx: typer.Context,
+    organization: str = typer.Option(..., "--organization", "--org"),
+    name: str = typer.Option(..., "--name", "-n"),
+    pipe_ids: str = typer.Option(
+        ..., "--pipe-ids", help="JSON array of pipe id strings."
+    ),
+    fields: str | None = typer.Option(None, "--fields"),
+    filter_json: str | None = typer.Option(None, "--filter"),
+    json_out: bool = typer.Option(
+        False, "--json", "-j", help="Print machine-readable JSON to stdout."
+    ),
+) -> None:
+    """Create an organization report (``create_organization_report``)."""
+    pids = parse_json_value(pipe_ids, "--pipe-ids")
+    if not isinstance(pids, list) or not pids:
+        raise typer.BadParameter("--pipe-ids must be a non-empty JSON array")
+    pipe_list = [str(x) for x in pids]
+    fields_list = parse_json_value(fields, "--fields") if fields else None
+    if fields_list is not None and not isinstance(fields_list, list):
+        raise typer.BadParameter("--fields must be a JSON array")
+    filt = prepare_report_cards_filter_cli(parse_json_object(filter_json, "--filter"))
+
+    async def factory(client: PipefyClient):
+        return await client.create_organization_report(
+            organization,
+            name.strip(),
+            pipe_list,
+            fields=fields_list,
+            filter=filt,
+        )
+
+    run_cli_command(ctx, json_out, factory)
+
+
+@report_org_app.command("update", context_settings=ID_POSITIONAL_CONTEXT_SETTINGS)
+def report_org_update(
+    ctx: typer.Context,
+    report_id: str = resource_id_argument(help="Organization report id."),
+    name: str | None = typer.Option(None, "--name", "-n"),
+    color: str | None = typer.Option(None, "--color"),
+    fields: str | None = typer.Option(None, "--fields"),
+    filter_json: str | None = typer.Option(None, "--filter"),
+    pipe_ids: str | None = typer.Option(
+        None, "--pipe-ids", help="JSON array of pipe ids."
+    ),
+    json_out: bool = typer.Option(
+        False, "--json", "-j", help="Print machine-readable JSON to stdout."
+    ),
+) -> None:
+    """Update an organization report (``update_organization_report``)."""
+    fields_list = parse_json_value(fields, "--fields") if fields else None
+    if fields_list is not None and not isinstance(fields_list, list):
+        raise typer.BadParameter("--fields must be a JSON array")
+    filt = prepare_report_cards_filter_cli(parse_json_object(filter_json, "--filter"))
+    pids = parse_json_value(pipe_ids, "--pipe-ids") if pipe_ids else None
+    if pids is not None:
+        if not isinstance(pids, list):
+            raise typer.BadParameter("--pipe-ids must be a JSON array")
+        pids = [str(x) for x in pids]
+
+    async def factory(client: PipefyClient):
+        return await client.update_organization_report(
+            report_id,
+            name=name.strip() if name else None,
+            color=color,
+            fields=fields_list,
+            filter=filt,
+            pipe_ids=pids,
+        )
+
+    run_cli_command(ctx, json_out, factory)
+
+
+@report_org_app.command("delete", context_settings=ID_POSITIONAL_CONTEXT_SETTINGS)
+def report_org_delete(
+    ctx: typer.Context,
+    report_id: str = resource_id_argument(help="Organization report id."),
+    yes: bool = typer.Option(False, "--yes", "-y"),
+    json_out: bool = typer.Option(
+        False, "--json", "-j", help="Print machine-readable JSON to stdout."
+    ),
+) -> None:
+    """Delete an organization report (``delete_organization_report``)."""
+    confirm_destructive(
+        yes=yes, description=f"organization report {report_id}", verb="delete"
+    )
+
+    async def factory(client: PipefyClient):
+        return await client.delete_organization_report(report_id)
+
+    run_cli_command(ctx, json_out, factory)
+
+
+@report_org_app.command("export")
+def report_org_export(
+    ctx: typer.Context,
+    organization: str = typer.Option(..., "--organization", "--org"),
+    format_: str = typer.Option(
+        "json",
+        "--format",
+        help="json: return export mutation payload; csv: poll and stream download.",
+    ),
+    organization_report_id: str | None = typer.Option(
+        None, "--organization-report-id", help="Optional report id to export."
+    ),
+    pipe_ids: str | None = typer.Option(
+        None, "--pipe-ids", help="Optional JSON array of pipe ids."
+    ),
+    sort_by: str | None = typer.Option(None, "--sort-by"),
+    filter_json: str | None = typer.Option(None, "--filter"),
+    columns: str | None = typer.Option(None, "--columns"),
+    poll_timeout: float = typer.Option(
+        90.0,
+        "--poll-timeout",
+        help="Seconds to poll export status before failing (CSV only).",
+    ),
+    json_out: bool = typer.Option(
+        False, "--json", "-j", help="Print machine-readable JSON to stdout."
+    ),
+) -> None:
+    """Export an organization report (``export_organization_report``)."""
+    fmt = format_.strip().lower()
+    if fmt not in ("json", "csv"):
+        raise typer.BadParameter("--format must be json or csv")
+    if fmt == "csv" and json_out:
+        raise typer.BadParameter(
+            "--json is mutually exclusive with --format csv (CSV is written as raw bytes to stdout)."
+        )
+    sort_obj = parse_json_object(sort_by, "--sort-by")
+    filt = prepare_report_cards_filter_cli(parse_json_object(filter_json, "--filter"))
+    cols = parse_json_value(columns, "--columns") if columns else None
+    if cols is not None and not isinstance(cols, list):
+        raise typer.BadParameter("--columns must be a JSON array")
+    pids = parse_json_value(pipe_ids, "--pipe-ids") if pipe_ids else None
+    if pids is not None:
+        if not isinstance(pids, list):
+            raise typer.BadParameter("--pipe-ids must be a JSON array")
+        pids = [str(x) for x in pids]
+
+    if fmt == "json":
+
+        async def factory(client: PipefyClient):
+            return await client.export_organization_report(
+                organization,
+                organization_report_id=organization_report_id,
+                pipe_ids=pids,
+                sort_by=sort_obj,
+                filter=filt,
+                columns=cols,
+            )
+
+        run_cli_command(ctx, json_out, factory)
+        return
+
+    async def csv_factory(client: PipefyClient) -> None:
+        start = await client.export_organization_report(
+            organization,
+            organization_report_id=organization_report_id,
+            pipe_ids=pids,
+            sort_by=sort_obj,
+            filter=filt,
+            columns=cols,
+        )
+        exp = (start.get("exportOrganizationReport") or {}).get(
+            "organizationReportExport"
+        ) or {}
+        export_id = exp.get("id")
+        if not export_id:
+            typer.echo(
+                "Could not read export id from exportOrganizationReport response.",
+                err=True,
+            )
+            raise typer.Exit(1)
+        await write_export_csv_to_stdout(
+            export_id=str(export_id),
+            poll_fetch=client.get_organization_report_export,
+            unwrap_status=lambda raw: (raw or {}).get("organizationReportExport") or {},
+            poll_timeout_seconds=poll_timeout,
+        )
+
+    run_pipefy_client_coroutine(ctx, csv_factory, value_error_exit_code=1)