datex-studio-cli 0.3.0__tar.gz → 0.3.1__tar.gz

{datex_studio_cli-0.3.0 → datex_studio_cli-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datex-studio-cli
-Version: 0.3.0
+Version: 0.3.1
 Summary: CLI for Datex Studio low-code platform, designed for LLM-based AI agents
 Project-URL: Homepage, https://github.com/datex/datex-studio-cli
 Project-URL: Documentation, https://github.com/datex/datex-studio-cli

{datex_studio_cli-0.3.0 → datex_studio_cli-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "datex-studio-cli"
-version = "0.3.0"
+version = "0.3.1"
 description = "CLI for Datex Studio low-code platform, designed for LLM-based AI agents"
 readme = "README.md"
 license = "MIT"

{datex_studio_cli-0.3.0 → datex_studio_cli-0.3.1}/src/dxs/__init__.py

@@ -1,4 +1,4 @@
 """Datex Studio CLI - Command-line interface for Datex Studio platform."""
 
-__version__ = "0.3.0"
+__version__ = "0.3.1"
 __app_name__ = "dxs"

{datex_studio_cli-0.3.0 → datex_studio_cli-0.3.1}/src/dxs/commands/auth.py

@@ -669,42 +669,61 @@ def consent(ctx: DxsContext, org: str, open: bool) -> None:
         )
         raise SystemExit(1)
 
-    # Construct admin consent URL
+    # Construct admin consent URLs for both apps
     settings = get_settings()
-    consent_url = (
-        f"https://login.microsoftonline.com/{org_info.tenant_id}/adminconsent"
-        f"?client_id={settings.azure_client_id}"
-    )
+    base_consent = f"https://login.microsoftonline.com/{org_info.tenant_id}/adminconsent"
+
+    datex_consent_url = f"{base_consent}?client_id={settings.azure_client_id}"
+
+    # Extract Footprint API client ID from scope (api://{client_id}/access_as_user)
+    fp_scope = settings.footprint_scope
+    fp_client_id = fp_scope.split("://")[1].split("/")[0] if "://" in fp_scope else None
+    footprint_consent_url = f"{base_consent}?client_id={fp_client_id}" if fp_client_id else None
+
+    consent_apps = [
+        {"name": "Datex Studio API", "client_id": settings.azure_client_id, "url": datex_consent_url},
+    ]
+    if footprint_consent_url and fp_client_id:
+        consent_apps.append(
+            {"name": "Footprint API", "client_id": fp_client_id, "url": footprint_consent_url}
+        )
 
     if open:
         ctx.output(
             single(
                 item={
                     "status": "opening_browser",
-                    "message": f"Opening admin consent page for {org_info.name}",
+                    "message": f"Opening admin consent pages for {org_info.name}",
                     "organization": org_info.name,
                     "organization_id": org_info.id,
                     "tenant_id": org_info.tenant_id,
                     "domain": org_info.external_entra_id_domain_name,
-                    "consent_url": consent_url,
-                    "instructions": "A tenant admin must complete the consent flow in the browser",
+                    "consent_apps": consent_apps,
+                    "instructions": (
+                        "A tenant admin must complete the consent flow for BOTH apps. "
+                        "Two browser tabs will open — approve each one."
+                    ),
                 },
                 semantic_key="consent",
             )
         )
-        webbrowser.open(consent_url)
+        for app in consent_apps:
+            webbrowser.open(app["url"])
     else:
         ctx.output(
             single(
                 item={
                     "status": "url_generated",
-                    "message": f"Admin consent URL for {org_info.name}",
+                    "message": f"Admin consent URLs for {org_info.name}",
                     "organization": org_info.name,
                     "organization_id": org_info.id,
                     "tenant_id": org_info.tenant_id,
                     "domain": org_info.external_entra_id_domain_name,
-                    "consent_url": consent_url,
-                    "instructions": "Have a tenant admin open this URL to grant consent",
+                    "consent_apps": consent_apps,
+                    "instructions": (
+                        "Have a tenant admin open BOTH URLs to grant consent. "
+                        "Both apps must be approved for full CLI functionality."
+                    ),
                 },
                 semantic_key="consent",
             )

{datex_studio_cli-0.3.0 → datex_studio_cli-0.3.1}/src/dxs/commands/datasource.py

@@ -13,101 +13,36 @@ from dxs.core.api.client import ApiClient
 from dxs.core.api.endpoints import ConfigurationEndpoints
 from dxs.core.auth import require_auth
 from dxs.core.datasource import DatasourceGenerator
-from dxs.core.datasource.models import (
-    DatasourceConfig,
-    DSDynamicOrderByConfig,
-    DSLinkedDatasourceConfig,
-    DSLinkedDatasourceConfigRef,
-    DSValueConfig,
-    TypeConfig,
+from dxs.core.datasource.models import DatasourceConfig
+from dxs.core.datasource.parsers import (
+    auto_populate_dynamic_filters as _auto_populate_dynamic_filters,
+)
+from dxs.core.datasource.parsers import (
+    auto_populate_dynamic_orderbys as _auto_populate_dynamic_orderbys,
+)
+from dxs.core.datasource.parsers import (
+    parse_custom_column as _parse_custom_column,
+)
+from dxs.core.datasource.parsers import (
+    parse_dynamic_filter as _parse_dynamic_filter,
+)
+from dxs.core.datasource.parsers import (
+    parse_dynamic_orderby as _parse_dynamic_orderby,
+)
+from dxs.core.datasource.parsers import (
+    parse_linked as _parse_linked,
+)
+from dxs.core.datasource.parsers import (
+    parse_linked_skip as _parse_linked_skip,
+)
+from dxs.core.datasource.parsers import (
+    parse_linked_top as _parse_linked_top,
 )
 from dxs.core.datasource.validator import DatasourceValidator
 from dxs.utils.errors import ApiError, ValidationError
 from dxs.utils.responses import list_response, single
 
 
-def _parse_dynamic_filter(value: str) -> TypeConfig:
-    """Parse 'property:type' → TypeConfig. Raises UsageError if malformed."""
-    parts = value.split(":", 1)
-    if len(parts) != 2:
-        raise click.UsageError(f"--dynamic-filter must be 'property:type', got: {value!r}")
-    prop, typ = parts
-    valid_types = {"string", "number", "date", "boolean"}
-    if typ not in valid_types:
-        raise click.UsageError(f"--dynamic-filter type must be one of {valid_types}, got: {typ!r}")
-    return TypeConfig(id=prop, type=typ)  # type: ignore[arg-type]
-
-
-def _parse_dynamic_orderby(value: str) -> DSDynamicOrderByConfig:
-    """Parse 'Property' or 'Owner.Name' → DSDynamicOrderByConfig."""
-    return DSDynamicOrderByConfig(property=value.split("."))
-
-
-def _parse_linked(value: str) -> DSLinkedDatasourceConfig:
-    """Parse linked datasource spec → DSLinkedDatasourceConfig.
-
-    Format:
-      oneToOne/oneToMany:    'name:type:target'            (mergeByValue is always null for these types)
-      oneToOneWithMerge:     'name:type:target:mergeBy'    (mergeByValue required)
-
-    A 4th component is accepted for all types for convenience but is silently
-    discarded for oneToOne/oneToMany — the C# validator and Handlebars template
-    do not use mergeByValue for those types (the UI always sets it to null).
-    """
-    parts = value.split(":", 3)
-    if len(parts) < 3:
-        raise click.UsageError(f"--linked must be 'name:type:target[:mergeBy]', got: {value!r}")
-    name, typ = parts[0], parts[1]
-    valid_types = {"oneToOne", "oneToMany", "oneToOneWithMerge"}
-    if typ not in valid_types:
-        raise click.UsageError(f"--linked type must be one of {valid_types}, got: {typ!r}")
-    target = parts[2]
-    if typ == "oneToOneWithMerge":
-        if len(parts) < 4 or not parts[3]:
-            raise click.UsageError(
-                "--linked oneToOneWithMerge requires a mergeBy expression: 'name:type:target:mergeBy'"
-            )
-        merge_by: str | None = parts[3]
-    else:
-        # oneToOne / oneToMany: mergeByValue must be null — the template does not use it
-        # and the C# validator type-checks any non-null value against the entity type.
-        merge_by = None
-    return DSLinkedDatasourceConfig(
-        name=name,
-        type=typ,  # type: ignore[arg-type]
-        datasourceConfig=DSLinkedDatasourceConfigRef(configId=target),
-        mergeByValue=merge_by,
-    )
-
-
-def _parse_custom_column(value: str) -> DSValueConfig:
-    """Parse 'name:type:expression' → DSValueConfig (splits on first 2 colons)."""
-    parts = value.split(":", 2)
-    if len(parts) != 3:
-        raise click.UsageError(f"--custom-column must be 'name:type:expression', got: {value!r}")
-    name, typ, expression = parts
-    valid_types = {"string", "number", "boolean", "date", "object"}
-    if typ not in valid_types:
-        raise click.UsageError(f"--custom-column type must be one of {valid_types}, got: {typ!r}")
-    return DSValueConfig(name=name, type=typ, value=expression)  # type: ignore[arg-type]
-
-
-def _parse_linked_top(value: str) -> tuple[str, str]:
-    """Parse 'name:value' → (linked_name, top_value) for --linked-top."""
-    parts = value.split(":", 1)
-    if len(parts) != 2 or not parts[0] or not parts[1]:
-        raise click.UsageError(f"--linked-top must be 'name:value', got: {value!r}")
-    return parts[0], parts[1]
-
-
-def _parse_linked_skip(value: str) -> tuple[str, str]:
-    """Parse 'name:value' → (linked_name, skip_value) for --linked-skip."""
-    parts = value.split(":", 1)
-    if len(parts) != 2 or not parts[0] or not parts[1]:
-        raise click.UsageError(f"--linked-skip must be 'name:value', got: {value!r}")
-    return parts[0], parts[1]
-
-
 def _build_upsert_summary(config: DatasourceConfig) -> dict:
     """Build a summary of the generated datasource configuration."""
     summary: dict = {"result_type": "single" if not config.isCollection else "collection"}
@@ -123,65 +58,6 @@ def _build_upsert_summary(config: DatasourceConfig) -> dict:
     return summary
 
 
-_DYNAMIC_FILTER_TYPES = {"boolean", "date", "number", "string"}
-
-
-def _auto_populate_dynamic_filters(
-    type_def: list[TypeConfig] | None,
-) -> list[TypeConfig]:
-    """Auto-populate dynamic filters from queryOptionsObjectTypeDef.
-
-    Mirrors the UI's getQueryOptionsSelectedAsDynamicFilter: includes primitive
-    non-collection properties and recurses into non-collection object properties.
-    """
-    if not type_def:
-        return []
-    result: list[TypeConfig] = []
-    for prop in type_def:
-        if prop.type in _DYNAMIC_FILTER_TYPES and not prop.isCollection:
-            result.append(TypeConfig(id=prop.id, type=prop.type))
-        elif (
-            prop.type == "object"
-            and prop.objectTypeDef
-            and not prop.isCollection
-        ):
-            nested = _auto_populate_dynamic_filters(prop.objectTypeDef)
-            if nested:
-                result.append(
-                    TypeConfig(id=prop.id, type="object", objectTypeDef=nested)
-                )
-    return result
-
-
-def _auto_populate_dynamic_orderbys(
-    type_def: list[TypeConfig] | None,
-    parent_property: list[str] | None = None,
-) -> list[DSDynamicOrderByConfig]:
-    """Auto-populate dynamic orderbys from queryOptionsObjectTypeDef.
-
-    Mirrors the UI's getQueryOptionsSelectedAsDynamicOrderBy: includes primitive
-    non-collection properties and recurses into non-collection object properties.
-    """
-    if not type_def:
-        return []
-    prefix = parent_property or []
-    result: list[DSDynamicOrderByConfig] = []
-    for prop in type_def:
-        if prop.type in _DYNAMIC_FILTER_TYPES and not prop.isCollection:
-            result.append(DSDynamicOrderByConfig(property=[*prefix, prop.id]))
-        elif (
-            prop.type == "object"
-            and prop.objectTypeDef
-            and not prop.isCollection
-        ):
-            result.extend(
-                _auto_populate_dynamic_orderbys(
-                    prop.objectTypeDef, [*prefix, prop.id]
-                )
-            )
-    return result
-
-
 @click.group()
 def datasource() -> None:
     """Datasource configuration generation and management.
@@ -478,9 +354,9 @@ def upsert(
         # Auto-populate dynamicFilters from queryOptionsObjectTypeDef if none specified,
         # matching the UI's allSelectedIsDynamicFiltersChanged() behavior.
         if not dynamic_filters:
-            config.dynamicFilters = _auto_populate_dynamic_filters(
-                config.queryOptionsObjectTypeDef
-            ) or None
+            config.dynamicFilters = (
+                _auto_populate_dynamic_filters(config.queryOptionsObjectTypeDef) or None
+            )
     elif dynamic_filters:
         config.allSelectedIsDynamicFilters = False
 
@@ -492,9 +368,9 @@ def upsert(
         # Auto-populate dynamicOrderBys from queryOptionsObjectTypeDef if none specified,
         # matching the UI's allSelectedIsDynamicOrderBysChanged() behavior.
         if not dynamic_orderbys:
-            config.dynamicOrderBys = _auto_populate_dynamic_orderbys(
-                config.queryOptionsObjectTypeDef
-            ) or None
+            config.dynamicOrderBys = (
+                _auto_populate_dynamic_orderbys(config.queryOptionsObjectTypeDef) or None
+            )
     elif dynamic_orderbys:
         config.allSelectedIsDynamicOrderBys = False
 
@@ -661,9 +537,7 @@ def delete(ctx: DxsContext, reference_name: str, branch: int | None) -> None:
     )
     config_id = existing["id"]
 
-    api_client.delete(
-        ConfigurationEndpoints.delete(branch_id, "datasource", config_id)
-    )
+    api_client.delete(ConfigurationEndpoints.delete(branch_id, "datasource", config_id))
     ctx.output(
         single(
             item={

{datex_studio_cli-0.3.0 → datex_studio_cli-0.3.1}/src/dxs/commands/report.py

@@ -1235,7 +1235,9 @@ def validate(ctx: DxsContext, file: str) -> None:
     default=False,
     help="Separate PNG per page instead of single stitched image",
 )
-@click.option("--width", type=int, default=None, help="Image width in pixels (default: match page at 96 DPI)")
+@click.option(
+    "--width", type=int, default=None, help="Image width in pixels (default: match page at 96 DPI)"
+)
 @click.option("--timeout", type=int, default=30, help="Render timeout in seconds")
 @pass_context
 @handle_errors
@@ -1330,6 +1332,133 @@ def preview(
         "Format: ds_param=expression or Alias.ds_param=expression. Repeatable."
     ),
 )
+@click.option(
+    "--owned-datasource",
+    "owned_datasources",
+    multiple=True,
+    metavar="REF:ALIAS",
+    help="Embed an owned datasource in the report. Format: ref_name:alias. Repeatable.",
+)
+@click.option(
+    "--owned-connection",
+    "owned_connections",
+    multiple=True,
+    type=int,
+    metavar="ID",
+    help="Connection ID for owned datasource (index-matched with --owned-datasource).",
+)
+@click.option(
+    "--owned-query",
+    "owned_queries",
+    multiple=True,
+    metavar="QUERY",
+    help="OData query for owned datasource (index-matched).",
+)
+@click.option(
+    "--owned-title",
+    "owned_titles",
+    multiple=True,
+    metavar="TITLE",
+    help="Title for owned datasource (index-matched).",
+)
+@click.option(
+    "--owned-description",
+    "owned_descriptions",
+    multiple=True,
+    metavar="DESC",
+    help="Description for owned datasource (index-matched, optional).",
+)
+@click.option(
+    "--owned-api-setting-name",
+    "owned_api_setting_names",
+    multiple=True,
+    metavar="NAME",
+    help="API setting name for owned datasource (index-matched, optional — auto-resolved).",
+)
+@click.option(
+    "--owned-param-keys",
+    "owned_param_keys",
+    multiple=True,
+    metavar="DS_NAME",
+    help="Enable param-keys for named owned datasource.",
+)
+@click.option(
+    "--owned-key-param-name",
+    "owned_key_param_names",
+    multiple=True,
+    metavar="DS_NAME:VALUE",
+    help="Custom key param name for named owned datasource.",
+)
+@click.option(
+    "--owned-detect-params",
+    "owned_detect_params",
+    multiple=True,
+    metavar="DS_NAME",
+    help="Enable detect-params for named owned datasource.",
+)
+@click.option(
+    "--owned-output-single",
+    "owned_output_singles",
+    multiple=True,
+    metavar="DS_NAME",
+    help="Enable output-single for named owned datasource.",
+)
+@click.option(
+    "--owned-all-dynamic-filters",
+    "owned_all_dynamic_filters",
+    multiple=True,
+    metavar="DS_NAME",
+    help="Enable all-dynamic-filters for named owned datasource.",
+)
+@click.option(
+    "--owned-all-dynamic-orderbys",
+    "owned_all_dynamic_orderbys",
+    multiple=True,
+    metavar="DS_NAME",
+    help="Enable all-dynamic-orderbys for named owned datasource.",
+)
+@click.option(
+    "--owned-dynamic-filter",
+    "owned_dynamic_filters",
+    multiple=True,
+    metavar="DS_NAME:PROP:TYPE",
+    help="Add dynamic filter to named owned datasource. Repeatable.",
+)
+@click.option(
+    "--owned-dynamic-orderby",
+    "owned_dynamic_orderbys",
+    multiple=True,
+    metavar="DS_NAME:PROP",
+    help="Add dynamic orderby to named owned datasource. Repeatable.",
+)
+@click.option(
+    "--owned-linked",
+    "owned_linkeds",
+    multiple=True,
+    metavar="DS_NAME:NAME:TYPE:TARGET[:MERGE]",
+    help="Add linked datasource to named owned datasource. Repeatable.",
+)
+@click.option(
+    "--owned-custom-column",
+    "owned_custom_columns",
+    multiple=True,
+    metavar="DS_NAME:NAME:TYPE:EXPR",
+    help="Add custom column to named owned datasource. Repeatable.",
+)
+@click.option(
+    "--owned-linked-top",
+    "owned_linked_tops",
+    multiple=True,
+    metavar="DS_NAME:LINKED:VALUE",
+    help="Set top limit on linked within owned datasource. Repeatable.",
+)
+@click.option(
+    "--owned-linked-skip",
+    "owned_linked_skips",
+    multiple=True,
+    metavar="DS_NAME:LINKED:VALUE",
+    help="Set skip offset on linked within owned datasource. Repeatable.",
+)
 @pass_context
 @require_auth
 @handle_errors
@@ -1344,6 +1473,24 @@ def upload(
     use_datasources: tuple[str, ...],
     params_raw: tuple[str, ...],
     datasource_params_raw: tuple[str, ...],
+    owned_datasources: tuple[str, ...],
+    owned_connections: tuple[int, ...],
+    owned_queries: tuple[str, ...],
+    owned_titles: tuple[str, ...],
+    owned_descriptions: tuple[str, ...],
+    owned_api_setting_names: tuple[str, ...],
+    owned_param_keys: tuple[str, ...],
+    owned_key_param_names: tuple[str, ...],
+    owned_detect_params: tuple[str, ...],
+    owned_output_singles: tuple[str, ...],
+    owned_all_dynamic_filters: tuple[str, ...],
+    owned_all_dynamic_orderbys: tuple[str, ...],
+    owned_dynamic_filters: tuple[str, ...],
+    owned_dynamic_orderbys: tuple[str, ...],
+    owned_linkeds: tuple[str, ...],
+    owned_custom_columns: tuple[str, ...],
+    owned_linked_tops: tuple[str, ...],
+    owned_linked_skips: tuple[str, ...],
 ) -> None:
     """Upload report to Datex Studio as a report configuration.
 
@@ -1412,13 +1559,16 @@ def upload(
                 f"Ensure the datasource is upserted before uploading the report."
             ) from exc
         ds_json: dict = ds.get("json") or {}
-        type_def = ds_json.get("queryOptionsObjectTypeDef") or []
-        is_coll = ds_json.get("resultIsCollection", False)
-        config_out_parameters: list[dict] = (
-            [{"id": "result", "type": "object", "isCollection": is_coll, "objectTypeDef": type_def}]
-            if type_def
-            else []
-        )
+        config_out_parameters: list[dict] = ds_json.get("outParams") or []
+
+        # Extract dynamic ordering/filtering and determine method name
+        dynamic_order_bys = ds_json.get("dynamicOrderBys")
+        dynamic_filters = ds_json.get("dynamicFilters")
+        ds_type = ds_json.get("type", "oDataQuery")
+        if ds_type == "oDataQuery":
+            datasource_method_name = "get"
+        else:
+            datasource_method_name = "get" if ds_json.get("getFlow") else "getList"
 
         # Collect param type info from datasource inParams
         ds_in_params: list[dict] = ds_json.get("inParams") or []
@@ -1439,14 +1589,85 @@ def upload(
             param_types=param_types,
             param_required=param_required,
             key_def=ds_json.get("keyDef"),
+            dynamic_order_bys=dynamic_order_bys,
+            dynamic_filters=dynamic_filters,
+            datasource_method_name=datasource_method_name,
         )
         datasource_configs.append(entry)
 
+    # Process owned datasources
+    owned_ds_configs: list[dict] = []
+    if owned_datasources:
+        from dxs.report.owned_datasource import (
+            generate_owned_datasource,
+            group_owned_specs,
+        )
+
+        specs = group_owned_specs(
+            owned_datasources=owned_datasources,
+            owned_connections=owned_connections,
+            owned_queries=owned_queries,
+            owned_titles=owned_titles,
+            owned_descriptions=owned_descriptions,
+            owned_api_setting_names=owned_api_setting_names,
+            owned_param_keys=owned_param_keys,
+            owned_key_param_names=owned_key_param_names,
+            owned_detect_params=owned_detect_params,
+            owned_output_singles=owned_output_singles,
+            owned_all_dynamic_filters=owned_all_dynamic_filters,
+            owned_all_dynamic_orderbys=owned_all_dynamic_orderbys,
+            owned_dynamic_filters=owned_dynamic_filters,
+            owned_dynamic_orderbys=owned_dynamic_orderbys,
+            owned_linkeds=owned_linkeds,
+            owned_custom_columns=owned_custom_columns,
+            owned_linked_tops=owned_linked_tops,
+            owned_linked_skips=owned_linked_skips,
+        )
+
+        for spec in specs:
+            ctx.log(f"Generating owned datasource: {spec.reference_name}")
+            ds_config, ds_ref = generate_owned_datasource(
+                spec=spec,
+                api_client=client,
+                branch_id=branch_id,
+            )
+
+            # Apply --datasource-param mappings for this owned DS
+            ds_params_owned: list[tuple[str, str]] = []
+            ds_params_owned.extend(ds_params_by_alias.get("", []))
+            ds_params_owned.extend(ds_params_by_alias.get(spec.alias, []))
+            if ds_params_owned:
+                in_params_list = ds_config.get("inParams") or []
+                pt = {p["id"]: p.get("type", "string") for p in in_params_list if "id" in p}
+                pr = {p["id"]: p.get("required") for p in in_params_list if "id" in p}
+                ds_ref["datasourceConfig"]["configParameters"] = [
+                    {
+                        "parameter": {
+                            "id": ds_param,
+                            "type": pt.get(ds_param, "string"),
+                            "required": pr.get(ds_param),
+                        },
+                        "value": expr,
+                    }
+                    for ds_param, expr in ds_params_owned
+                ]
+
+            owned_ds_configs.append(ds_config)
+            datasource_configs.append(ds_ref)
+
+    # Validate alias uniqueness across all datasources (external + owned)
+    seen_aliases: set[str] = set()
+    for dc in datasource_configs:
+        alias = dc["alias"]
+        if alias in seen_aliases:
+            raise click.UsageError(
+                f"Duplicate datasource alias: {alias!r}. "
+                f"Each --use-datasource and --owned-datasource must have a unique alias."
+            )
+        seen_aliases.add(alias)
+
     # Build inParams from --param flags
-    in_params = [
-        {"id": name, "type": ptype, "required": True}
-        for name, ptype in parsed_params
-    ]
+    in_params = [{"id": name, "type": ptype, "required": True} for name, ptype in parsed_params]
 
     # Build Datex Studio wrapper
     wrapper = rdl_to_datex_wrapper(
@@ -1457,6 +1678,7 @@ def upload(
         report_type=report_type,
         datasource_configs=datasource_configs if datasource_configs else None,
         in_params=in_params if in_params else None,
+        datasources=owned_ds_configs if owned_ds_configs else None,
     )
 
     # Upload via API — upsert using ConfigurationEndpoints
@@ -1643,13 +1865,7 @@ def datasource_fields(ctx: DxsContext, datasource_ref: str, branch: int | None)
     )
 
     ds_json: dict = ds.get("json") or {}
-    type_def = ds_json.get("queryOptionsObjectTypeDef") or []
-    is_coll = ds_json.get("resultIsCollection", False)
-    config_out_parameters: list[dict] = (
-        [{"id": "result", "type": "object", "isCollection": is_coll, "objectTypeDef": type_def}]
-        if type_def
-        else []
-    )
+    config_out_parameters: list[dict] = ds_json.get("outParams") or []
     is_collection, flat_fields, collections = parse_fields(config_out_parameters)
 
     def _field_entry(f: ParsedField) -> dict: