Add profile-derived dispatch adapter identity (#66)

Author: sabino

.agent/research/dbt-upstream-reference-map.md

@@ -47,6 +47,7 @@ Every compatibility slice should record:
 | YAML properties and resource patches | `core/dbt/parser/schemas.py::SchemaParser`, `SourceParser`, `PatchParser`, `ModelPatchParser`, `MacroPatchParser`; `core/dbt/parser/schema_yaml_readers.py::ExposureParser`, `MetricParser`, `SemanticModelParser`, `SavedQueryParser` | `crates/dbt-parser/src/resolver.rs::resolve_package_waves` resource order: sources, seeds, snapshots, groups, models, analyses, functions, exposures, semantic models, metrics, saved queries, data tests, unit tests | Current `src/project.zig` YAML routines and `src/project/parse.zig` helpers; future `src/project/parse.zig` plus narrower modules if needed |
 | Exposure, source, ref, metric dependency resolution | `core/dbt/parser/manifest.py::_process_refs`, `_process_sources_for_node`, `_process_sources_for_exposure`, `_process_metrics_for_node` | `crates/dbt-jinja-utils/src/node_resolver.rs::resolve_dependencies`; `crates/dbt-parser/src/resolver.rs` access validation, relation uniqueness, primary-key inference | `src/project/resolve.zig`; current higher-level orchestration still in `src/project.zig` |
 | Parse vs runtime Jinja context | `core/dbt/context/providers.py::ParseProvider`, `RuntimeProvider`, `ProviderContext.ref`, `source`, `execute`, `var`, `graph`, `env_var`, `selected_resources`, `generate_parser_model_context`, `generate_runtime_model_context`, `generate_parse_exposure`, `generate_parse_semantic_models` | `crates/dbt-parser/src/renderer.rs::render_sql_file_inner`, `augment_sql_resources_with_static_sources`; `crates/dbt-parser/src/dbt_namespace.rs::DbtNamespace` parse-mode interception of `get_relation` and `get_columns_in_relation` | Current lexical `src/project/jinja.zig`; future parse context and compile/runtime context modules before M2 |
+| Profile and adapter identity | `core/dbt/config/profile.py::Profile.pick_profile_name`, `render_profile`, `from_raw_profile_info`, `_get_profile_data`, `_credentials_from_profile`, `to_target_dict`; `core/dbt/config/runtime.py::load_profile`, `RuntimeConfig.get_metadata`; `core/dbt/context/target.py::TargetContext.target` | `crates/dbt-loader/src/load_profiles.rs::load_profiles`; `crates/dbt-profile/src/resolve.rs`; `crates/dbt-schemas/src/schemas/profiles.rs::DbConfig::adapter_type`; `crates/dbt-adapter-core/src/lib.rs::AdapterType` | `src/project/profile.zig` owns the current scalar `profiles.yml` adapter-type parser; `src/project/config.zig` owns `dbt_project.yml` `profile:`; future profile/context modules own Jinja rendering, credentials, target context, and relation identity |
 | Manifest data model and maps | `core/dbt/contracts/graph/manifest.py::Manifest` maps for nodes, sources, macros, docs, exposures, metrics, groups, selectors, files, disabled, semantic_models, unit_tests, saved_queries, fixtures; `build_flat_graph`, `build_parent_and_child_maps`, lookup rebuilders, resource adders | `crates/dbt-schemas/src/schemas/manifest/manifest.rs::build_manifest`, `build_disabled_map`, `build_parent_and_child_maps`, path normalization, `nodes_from_dbt_manifest` | `src/project/types.zig`, `src/project/manifest.zig`, `src/project/resolve.zig` |
 | Selector grammar and methods | `core/dbt/graph/selector_spec.py`, `selector.py`, `selector_methods.py`, `cli.py`, `graph.py`, `queue.py`; methods include FQN, tag, group, access, source, exposure, metric, semantic_model, saved_query, unit_test, path, file, package, config, resource_type, test_name, test_type, state, result, source_status, version, selector | `crates/dbt-parser/src/resolver.rs` selector YAML loading; command flags in `crates/dbt-clap-core/src/commands.rs` | `src/project/selector.zig` and CLI validation in `src/root.zig`; future state/result/source-status work in `src/project/state.zig` |
 | Artifact schemas | `schemas/dbt/manifest/v12.json`, `schemas/dbt/run-results/v6.json`, `schemas/dbt/sources/v3.json`, `schemas/dbt/catalog/v1.json` | v2 still emits JSON for compatibility and adds Parquet artifacts per README; manifest builder in `crates/dbt-schemas/src/schemas/manifest/manifest.rs` | `src/project/manifest.zig`, future run/catalog/source writers and schema validators under tests/scripts |

.agent/research/m2-profile-adapter-dispatch-identity.md

@@ -0,0 +1,96 @@
+# M2 Profile-Derived Adapter Dispatch Identity Slice
+
+This slice replaces dxt's temporary static adapter dispatch prefix list with a
+profile-derived adapter type for parse-time `adapter.dispatch(...)` dependency
+recording. It still records `depends_on.macros` only. It does not validate
+credentials, render secrets, open adapter connections, execute macros, implement
+project `dispatch:` config, compile `target.*`, or run materializations.
+
+## Upstream References
+
+dbt Core v1, branch `1.latest`, commit `566b75d`:
+
+- `core/dbt/config/runtime.py::load_profile` selects the project profile and
+  passes CLI profile, target, and threads overrides into profile loading.
+- `core/dbt/config/profile.py::Profile.pick_profile_name`,
+  `render_profile`, `from_raw_profile_info`, `_get_profile_data`, and
+  `_credentials_from_profile` define profile-name selection, target selection,
+  selected-output lookup, required `type`, and adapter plugin identity.
+- `core/dbt/config/profile.py::Profile.to_target_dict` and
+  `core/dbt/context/target.py::TargetContext.target` define the common target
+  context fields, including `type`, `name`, `target_name`, `profile_name`, and
+  `threads`.
+- `core/dbt/config/runtime.py::RuntimeConfig.get_metadata` emits manifest
+  metadata `adapter_type` from credentials.
+- `core/dbt/context/providers.py::BaseDatabaseWrapper._get_adapter_macro_prefixes`
+  defines dispatch prefixes as adapter type hierarchy plus `default`.
+- `core/dbt/context/providers.py::BaseDatabaseWrapper.dispatch` rejects dotted
+  macro names and deprecated `packages`, then searches
+  `{adapter_prefix}__{macro_name}` candidates.
+- `core/dbt/clients/jinja_static.py::statically_parse_adapter_dispatch` uses the
+  adapter wrapper to statically resolve literal dispatch calls into macro
+  dependencies.
+
+dbt Core v2 / Fusion foundation, branch `main`, commit `0529e06`:
+
+- `crates/dbt-loader/src/load_profiles.rs::load_profiles` locates
+  `profiles.yml`, selects profile and target, resolves profile data, and stores
+  the adapter type in `DbtProfile`.
+- `crates/dbt-profile/src/resolve.rs` resolves profile name, target override,
+  selected output, and adapter type as data.
+- `crates/dbt-schemas/src/schemas/profiles.rs::DbConfig::adapter_type` maps
+  typed profile configuration into `AdapterType`.
+- `crates/dbt-adapter-core/src/lib.rs::AdapterType` defines adapter identity and
+  accepts the Postgres naming forms.
+- `crates/dbt-jinja/minijinja/src/dispatch_object.rs::get_adapter_prefixes`
+  defines Fusion's current parent-prefix fallback: `redshift -> postgres`,
+  `databricks -> spark`, then `default`.
+- `crates/dbt-jinja/minijinja/src/dispatch_object.rs::DispatchObject::call`
+  applies adapter prefixes during dispatch resolution.
+
+## dxt Ownership
+
+- `src/project/profile.zig` owns the narrow scalar profile/target adapter-type
+  parser.
+- `src/project/config.zig` owns `dbt_project.yml` `profile:` discovery.
+- `src/project/loader.zig` resolves profile identity before loading macros and
+  resources, so parse-time Jinja scanning sees the selected adapter type.
+- `src/project/jinja.zig` derives static dispatch prefixes from
+  `Graph.adapter_type`.
+- `src/project/manifest.zig` emits manifest `metadata.adapter_type`.
+
+## Supported Surface
+
+- Select profile from CLI `--profile`, falling back to `dbt_project.yml`
+  `profile:`.
+- Select target from CLI `--target`, falling back to profile `target:`, then
+  `default`.
+- Read selected output scalar `type` from `profiles.yml`.
+- Normalize `postgresql` to dispatch adapter type `postgres`.
+- Use dispatch prefix order:
+  - `redshift`, `postgres`, `default`
+  - `databricks`, `spark`, `default`
+  - selected adapter, `default`
+- Preserve the current `duckdb` default only when no profile file is found and
+  no profile-related CLI flag requested profile loading.
+
+## Validation
+
+- Native Zig tests cover profile/target selection, missing profile/target/type
+  errors, Postgres alias normalization, profile-derived dispatch prefix choice,
+  and parent prefix fallback.
+- Pytest fixture `profile_adapter_dispatch` validates parse-time manifest
+  `depends_on.macros` and `metadata.adapter_type` for default Postgres, explicit
+  DuckDB, and Redshift parent fallback targets through the Zig binary.
+- Existing no-profile fixtures remain covered by the default DuckDB identity.
+
+## Stop Conditions
+
+- Do not render Jinja in `profiles.yml` in this slice.
+- Do not read host-global profile locations beyond the project or explicit
+  `--profiles-dir` path.
+- Do not validate or emit credentials.
+- Do not implement project `dispatch:` config.
+- Do not execute dispatched macros, materializations, tests, or adapter SQL.
+- Do not add relation identity, quoting, `target.*`, `this`, catalog
+  introspection, or `run_results.json`.

PLAN.md

@@ -304,10 +304,19 @@ Current static adapter dispatch dependency source note:
 `.agent/research/m2-static-adapter-dispatch-deps.md` maps upstream dbt Core v1
 `BaseDatabaseWrapper.dispatch` and Fusion `DispatchObject` behavior to dxt's
 static `depends_on.macros` extraction for literal `adapter.dispatch(...)` calls.
-This slice records dispatch macro dependencies only, using a temporary
-`duckdb`, `default` prefix list until profile-derived adapter identity exists.
-It does not execute dispatched macros, implement project `dispatch:` config,
-parse profiles, or run adapters.
+This slice records dispatch macro dependencies only. It does not execute
+dispatched macros, implement project `dispatch:` config, or run adapters.
+
+Current profile-derived adapter identity source note:
+`.agent/research/m2-profile-adapter-dispatch-identity.md` maps upstream dbt Core
+v1 profile/target selection, manifest `adapter_type`, and dispatch prefix
+behavior plus Fusion `AdapterType` and `get_adapter_prefixes` behavior to dxt's
+narrow scalar `profiles.yml` parser. This slice lets parse-time static
+`adapter.dispatch(...)` dependency extraction use the selected profile output
+`type`, including `redshift -> postgres -> default` and
+`databricks -> spark -> default` parent fallbacks. It does not render Jinja in
+profiles, validate credentials, read host-global profile locations, implement
+project `dispatch:` config, execute macros, or open adapter connections.
 
 The next source-grounded M1/M2 slices after macro block variant support are:
 
@@ -341,9 +350,9 @@ The next source-grounded M1/M2 slices after macro block variant support are:
 5. Grow artifact schema coverage only alongside emitted fields, using v1 JSON
    schemas and v2 manifest builder behavior while keeping dxt-specific metadata
    out of dbt schemas.
-6. Add adapter relation identity and profile-derived target values after the
-   render-only compile boundary is stable, using v1 compile runner/compiler
-   behavior plus v2 adapter core/SQL identity references.
+6. Add adapter relation identity and target context values after the render-only
+   compile boundary is stable, using v1 compile runner/compiler behavior plus
+   v2 adapter core/SQL identity references.
 
 ## Fixture Ladder
 
@@ -675,4 +684,4 @@ Exit criteria:
 - Selector wildcard behavior is currently pinned to observed dbt Core 1.10 behavior. dbt Fusion preview currently differs for resource-type-prefixed wildcard selectors such as `model.<package>.*` and filename-suffix path selectors such as `path:*orders.sql`; a future Fusion-compatibility slice must decide whether to support a selector dialect switch or a compatible superset.
 - Compatibility planning now uses a source-grounded reference map under `.agent/research/dbt-upstream-reference-map.md`; future feature slices should name upstream dbt v1/v2 source references, dxt Zig owners, affected artifact fields, validation gates, and stop conditions before implementation.
 - The committed dbt Core M1 oracle harness lives in `scripts/check_dbt_core_m1_oracle.py`. It is optional developer-side Python tooling that requires `dbt-core` and `dbt-duckdb`, invokes dbt Core through its Python runner, runs `dxt parse` through the Zig binary, and compares stable manifest slices for the supported synthetic M1 fixture ladder. It ignores dbt internal package docs/macros that are outside the current dxt artifact scope, records a known allowed gap for installed-package exposure refs that dbt Core resolves to a root same-name model while dxt currently resolves package-local, and leaves full source-map parity, full artifact schemas, and execution parity for later slices.
-- Before broadening M2 product implementation, close or explicitly re-scope the remaining M1 macro-compatibility behavior gaps. Macro `docs`/`meta` patch fields are covered for the current scalar artifact subset. Macro argument extraction under dbt Core v1 `flags.validate_macro_args` semantics and YAML patch argument validation/replacement are implemented for the manifest artifact surface. Static macro dependency lookup now uses the supported dbt order of current package, root project, other-package fallback for macro bodies, graph-present internal `dbt` macros, and literal `adapter.dispatch(...)` dependency extraction with a temporary `duckdb`, `default` prefix list. Macro execution, bundled dbt internal macros, project `dispatch:` config, profile-derived adapter identity, and materialization runtime lookup remain planned. `{% data_test %}` has native source-grounded parser coverage, but the local dbt Core 1.10 oracle rejects that tag before writing artifacts, so dbt-oracle coverage currently pins `{% test %}` and `{% materialization %}` block parity.
+- Before broadening M2 product implementation, close or explicitly re-scope the remaining M1 macro-compatibility behavior gaps. Macro `docs`/`meta` patch fields are covered for the current scalar artifact subset. Macro argument extraction under dbt Core v1 `flags.validate_macro_args` semantics and YAML patch argument validation/replacement are implemented for the manifest artifact surface. Static macro dependency lookup now uses the supported dbt order of current package, root project, other-package fallback for macro bodies, graph-present internal `dbt` macros, and literal `adapter.dispatch(...)` dependency extraction. Parse-time dispatch prefixes now come from a narrow source-grounded `profiles.yml` adapter identity parser and emit manifest `metadata.adapter_type`, with default DuckDB behavior preserved when no profile file is loaded. Macro execution, bundled dbt internal macros, project `dispatch:` config, full target context, credential validation, and materialization runtime lookup remain planned. `{% data_test %}` has native source-grounded parser coverage, but the local dbt Core 1.10 oracle rejects that tag before writing artifacts, so dbt-oracle coverage currently pins `{% test %}` and `{% materialization %}` block parity.