Skip to content

fides-pbac standalone CLI and demo fixtures (reference, not for merge)#7941

Draft
galvana wants to merge 16 commits intomainfrom
fides-pbac-cli-reference
Draft

fides-pbac standalone CLI and demo fixtures (reference, not for merge)#7941
galvana wants to merge 16 commits intomainfrom
fides-pbac-cli-reference

Conversation

@galvana
Copy link
Copy Markdown
Contributor

@galvana galvana commented Apr 15, 2026

Reference-only. Not intended for merge. Built on top of policy-engine-go-library to illustrate the shape a standalone fides-pbac CLI could take, and the fixture directory layout it would consume.

What this adds

A single Go binary (fides-pbac) that:

  • reads a directory of YAML fixtures (consumers/, purposes/, datasets/, policies/)
  • extracts table references from raw SQL
  • runs each statement through identity resolution, dataset resolution, purpose evaluation, gap reclassification, and access-policy filtering
  • emits JSON that mirrors EvaluationRecord from src/fides/service/pbac/types.py

No Python runtime, no server, no Redis, no database. ~3 ms median startup+config-load. 3.5 MB static binary.

Static fixture files (pbac/ at the repo root)

pbac/
├── README.md                     Cast, scenarios, schema notes
├── consumers/                    One YAML per consumer (top-level: consumer:)
│   ├── analytics-team.yml        alice, priya -> [analytics]
│   ├── marketing-team.yml        bob, maria   -> [marketing]
│   └── onboarding-unconfigured.yml  dave -> []  (for UNCONFIGURED_CONSUMER gap)
├── purposes/                     One YAML per purpose (top-level: purpose:)
│   ├── analytics.yml             analytics.reporting
│   ├── billing.yml               essential.service.payment_processing
│   └── marketing.yml             marketing.advertising
├── datasets/                     Standard fideslang Dataset YAML (top-level: dataset:)
│   ├── sales.yml                 billing at dataset, analytics at collection `invoices`
│   ├── events.yml                analytics
│   └── campaigns.yml             marketing
├── policies/                     One YAML per access policy (top-level: policy:)
│   └── allow-analytics-on-billing-data.yml
│                                 ALLOW on data_use essential.service.payment_processing
└── entries/                      One .txt per identity; SQL separated by ;
    ├── alice.txt                 compliant / suppressed / compliant / violation
    ├── bob.txt                   UNCONFIGURED_DATASET
    ├── carol.txt                 UNRESOLVED_IDENTITY
    └── dave.txt                  UNCONFIGURED_CONSUMER

Fixture schema conventions

Consumer — four fields: name, description, members (list of emails), purposes. Identity resolution is "does --identity appear in some consumer's members list."

Purpose — mirrors fidesplus/seed/pbac/data.py::PURPOSES: fides_key, name, data_use, optional data_subject, data_categories, description.

Dataset — standard fideslang. data_purposes can be declared at the dataset, collection, and field levels; effective purposes for a query on <dataset>.<collection> stack additively:

effective = dataset.data_purposes
          ∪ collection.data_purposes
          ∪ union(field.data_purposes for each field in the collection)

sales.invoices is the live demonstration: dataset is billing, collection adds analytics, so analytics-team queries against invoices pass the purpose check directly without a policy override.

Policy — matches pbac.AccessPolicy. Disabled policies (enabled: false) are filtered out at load time.

Dataset resolution

Collection names are assumed globally unique across datasets, so queries resolve by bare table name regardless of catalog/schema prefix. SELECT FROM orders and SELECT FROM archive.legacy_sales.orders both resolve to the dataset that declares an orders collection. Unknown tables fall through to their qualified name as the identifier on the resulting UNCONFIGURED_DATASET gap.

fides-pbac CLI options

fides-pbac --config DIR --identity EMAIL [FILE]
Flag Required Description
--config DIR yes Directory containing consumers/, purposes/, datasets/, policies/ YAML subdirectories
--identity EMAIL yes User identity to attribute every query in the input to
FILE (positional) no SQL input file. Omit or pass - to read from stdin

Statements are split on top-level ; (respecting single-quoted strings, -- line comments, and /* */ block comments). Each statement becomes one record in the output.

Evaluation pipeline (per statement)

  1. Table extractionpkg/sqlextract pulls 1-3 part qualified identifiers from the SQL.
  2. Identity resolution--identity looked up against consumers/ by member email.
  3. Dataset resolution — each extracted table looked up against the collection-name index built from collections[].name. Unknown tables fall through to their qualified name.
  4. Purpose evaluation — consumer purposes intersected with the effective purposes at (dataset, collection); empty intersection is a PurposeViolation, missing configuration is an EvaluationGap.
  5. Gap reclassificationUNRESOLVED_IDENTITY becomes UNCONFIGURED_CONSUMER when the consumer exists but declares no purposes.
  6. Policy filtering — each violation's dataset purposes are mapped to data_use strings (via purposes/), then evaluated against policies/. An ALLOW sets suppressed_by_policy (and suppressed_by_action when the policy has an action.message) on the violation in place.

Gaps do not flow through policy filtering. A record is compliant when every violation is suppressed and no gaps were recorded.

Output

JSON on stdout. One records array with:

  • query_id, identity, consumer, dataset_keys
  • is_compliant
  • violations — each PurposeViolation with consumer_id/name, dataset_key, collection, consumer_purposes, dataset_purposes, reason, and the optional suppressed_by_policy / suppressed_by_action inline when an ALLOW policy matched
  • gaps, total_accesses, query_text

Mirrors EvaluationRecord from src/fides/service/pbac/types.py with three deliberate deltas: simplified consumer (name string instead of full entity), no timestamp (not available in SQL text), and the inline suppressed_by_policy / suppressed_by_action fields on PurposeViolation.

Install (local checkout)

cd policy-engine
go install ./cmd/fides-pbac

Expected outcomes from the fixture set

Invocation Outcome
fides-pbac --config pbac/ --identity alice@demo.example pbac/entries/alice.txt 4 records: compliant, suppressed violation, compliant via collection, violation stands
fides-pbac --config pbac/ --identity bob@demo.example pbac/entries/bob.txt gap unconfigured_dataset identified as cold_storage
fides-pbac --config pbac/ --identity carol@demo.example pbac/entries/carol.txt gap unresolved_identity
fides-pbac --config pbac/ --identity dave@demo.example pbac/entries/dave.txt gap unconfigured_consumer

Package additions under policy-engine/

  • cmd/fides-pbac/ — CLI entrypoint
  • pkg/sqlextract/ — regex-based SQL table extractor + StripComments helper, 31 subtests
  • pkg/fixtures/ — YAML loaders returning typed structs consumable by pkg/pbac

Minimal changes to pkg/pbac

  • yaml: tags added alongside existing json: tags on AccessPolicy and its nested types. Non-breaking.
  • PurposeViolation.SuppressedByPolicy and SuppressedByAction added next to the existing service-enriched fields (DataUse, Control). Optional; absent when the violation wasn't suppressed.

thabofletcher and others added 16 commits April 13, 2026 20:00
Go library implementing the PBAC purpose-overlap evaluation algorithm
and fideslang policy rule evaluation. Provides two packages:

- pkg/pbac: Purpose evaluation (set intersection of consumer vs dataset purposes)
- pkg/fideslang: Fideslang policy rule evaluation (taxonomy hierarchy matching)
- cmd/fides-evaluate: CLI binary for stdin/file-based evaluation

The library is designed to be imported by the fidesplus sidecar for
high-throughput HTTP evaluation (~13x faster than Python).
The fideslang package implemented the old policy rule evaluation
(taxonomy hierarchy matching against privacy declarations). This is
replaced by the Access Policy v2 system which will be added to
pkg/pbac/ as the next step in the PBAC pipeline.
Implements the policy evaluation algorithm from IMPLEMENTATION_GUIDE.md
as step 7 of the PBAC pipeline — filtering violations through access
policies created via the UI.

Features:
- Priority-ordered, first-decisive-match-wins evaluation
- Match blocks with any/all operators and taxonomy hierarchy matching
- Unless conditions: consent, geo_location, data_flow (AND logic)
- ALLOW + unless triggered = DENY (decisive)
- DENY + unless triggered = SUPPRESSED (continues to next policy)
- Audit trail of evaluated policies

25 tests covering priority ordering, match modes, all three unless
condition types, multi-constraint AND logic, and taxonomy matching.
Library tests (pkg/pbac/):
- edge_cases_test.go: empty datasets, nil collections, multiple
  collections counted separately, duplicate purpose keys, sorted
  output, non-nil slices for JSON, EffectivePurposes inheritance,
  policy catch-all, match all/any combined, unless without context,
  deny action only on deny, context field resolution (nested, missing,
  non-string)

CLI integration tests (cmd/fides-evaluate/):
- Builds the binary once, exercises both purpose and policies commands
  via stdin and file input
- Purpose: compliant, violation, gap, collections, multiple datasets
- Policies: allow, deny, no-decision, unless-inverts, priority ordering
- Error handling: no args, unknown command, invalid JSON, missing file,
  empty input, output is valid JSON

Also adds 'policies' subcommand to the CLI.

63 tests total, all passing.
Drops the standalone Go binary (cmd/fides-evaluate/) and adds PBAC
evaluation to the existing fides CLI:

  fides pbac evaluate-purpose   — purpose overlap check (stdin/file)
  fides pbac evaluate-policies  — access policy evaluation (stdin/file)

The CLI calls the Python evaluation engine directly. Performance is
not the concern here — the Go sidecar handles API throughput. The CLI
is for local testing and debugging.

Adds:
- src/fides/cli/commands/pbac.py — Click command group
- src/fides/service/pbac/policies/evaluate.py — Python policy v2 engine
  (mirrors Go implementation in policy-engine/pkg/pbac/)
- tests for both the evaluation engine and CLI passthrough
Go library (50 tests) — adds:
- data_subject match dimension
- three-dimension match (use + category + subject)
- consent not_opt_in / not_opt_out requirements
- data_flow none_of operator

Python evaluation (42 tests) — adds:
- data_subject match + three-dimension match
- match any+all combined across dimensions
- consent not_opt_in / not_opt_out
- geo not_in operator
- data_flow none_of operator
- nested context field resolution

92 automated tests total across Go and Python, covering every
rule, match mode, unless condition type, and operator.
Runs go build, go vet, and go test on pull_request/push when
policy-engine/ files change. Uses setup-go with module caching.
…verage

CI blockers:
- Fix mypy: click.utils.LazyFile → typing.TextIO in pbac.py
- Run ruff format on all Python files

Logic fixes:
- Deterministic output: sort dataset keys before iterating Go map
- Stable sort: sort.Slice → sort.SliceStable for policy priority ties
- Enabled default: *bool pointer so nil (omitted) defaults to true,
  matching Python's p.get("enabled", True)
- Complete audit trail: decisive policy now included in EvaluatedPolicies
  for both ALLOW-inverted-to-DENY and normal decisive paths
- Empty taxonomy guard: taxonomyMatch("", x) returns false in both Go
  and Python to prevent accidental catch-all

Code smells:
- Replace interface{} return from checkAccess with typed accessCheckResult
- Remove unused GapUnconfiguredConsumer from Go (service-layer concern)
- Document Constraint.Operator field: which operators apply to which types

Missing tests (Go + Python):
- MatchDimension with both Any and All on same dimension
- Duplicate Unless constraints (AND of identical = no-op)
- Empty taxonomy match key never matches
- Enabled defaults to true when omitted

54 Go tests + 48 Python tests, all passing.
Critical fixes:
- evaluate.py now uses typed dataclasses (ParsedPolicy,
  AccessEvaluationRequest, PolicyEvaluationResult) instead of raw dicts
- InProcessAccessPolicyEvaluator conforms to the existing
  AccessPolicyEvaluator Protocol from interface.py
- JSON conversion (parsed_policy_from_dict, request_from_dict,
  result_to_dict) pushed to CLI boundary, not inside the service
- CLI evaluate-policies now constructs typed objects from JSON, matching
  the pattern used by evaluate-purpose
- Lazy import removed — all imports at module level

Significant fixes:
- CI: add go mod tidy verification step
- Go: document EvaluatePoliciesRequest/EvaluatePurposeRequest as
  sidecar types (used by fidesplus companion PR)
- Go + Python: add priority tie-breaking test (stable sort preserves
  insertion order)

55 Go tests + 51 Python tests, all passing.
- Go CI: remove go.sum from git diff check (no external deps, file
  doesn't exist)
- Ruff: fix import block formatting (extra blank line)
- ParsedPolicy.decision: change from str to PolicyDecision enum so
  invalid values fail at construction time rather than evaluation time
- .gitignore: add test_report.xml (pytest junitxml artifact)
Tests were constructing ParsedPolicy with decision="ALLOW"/"DENY"
strings, but the field is now PolicyDecision. This caused
'str' object has no attribute 'value' in evaluate_policies.
- CI: add gofmt check and include go.sum in module verification diff
- Fix gofmt alignment drift in Constraint and EvaluatedPolicyInfo structs
- parsed_policy_from_dict: raise InvalidPolicyError with friendly message
  on bad decision values (instead of raw ValueError)
- CLI: catch InvalidPolicyError for clean error output on bad JSON
- result_to_dict: omit null action (matches Go omitempty behavior)
Reference-only bundle showing how a single Go binary can evaluate
SQL queries against a YAML PBAC config directory with no dependency
on the fides Python stack.

Adds:
- policy-engine/cmd/fides-pbac/ — the CLI (flag parsing, statement
  splitter, output shape matching EvaluationRecord)
- policy-engine/pkg/sqlextract/ — regex-based table extractor plus
  StripComments helper (31 subtests)
- policy-engine/pkg/fixtures/ — YAML loaders for consumers, purposes,
  datasets, policies; builds the collection-name -> dataset_key index
- policy-engine/README.md — module-level docs
- pbac/ — demo fixture directory used by the CLI

Extends pbac types minimally to support the CLI:
- yaml tags on pbac.AccessPolicy and its nested types (non-breaking)
- PurposeViolation.SuppressedByPolicy / SuppressedByAction so
  suppressions are auditable inline instead of being filtered out

Removes an unused asdict import from src/fides/cli/commands/pbac.py.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
@vercel
Copy link
Copy Markdown
Contributor

vercel Bot commented Apr 15, 2026

The latest updates on your projects. Learn more about Vercel for GitHub.

2 Skipped Deployments
Project Deployment Actions Updated (UTC)
fides-plus-nightly Ignored Ignored Apr 15, 2026 10:29pm
fides-privacy-center Ignored Ignored Apr 15, 2026 10:29pm

Request Review

@codecov
Copy link
Copy Markdown

codecov Bot commented Apr 15, 2026

Codecov Report

✅ All modified and coverable lines are covered by tests.
✅ Project coverage is 83.41%. Comparing base (59dc9c8) to head (1d27def).

❌ Your project check has failed because the head coverage (83.41%) is below the target coverage (85.00%). You can increase the head coverage or adjust the target coverage.

Additional details and impacted files
@@                     Coverage Diff                      @@
##           policy-engine-go-library    #7941      +/-   ##
============================================================
- Coverage                     85.09%   83.41%   -1.69%     
============================================================
  Files                           631      631              
  Lines                         41053    41052       -1     
  Branches                       4781     4781              
============================================================
- Hits                          34933    34242     -691     
- Misses                         5040     5627     +587     
- Partials                       1080     1183     +103     

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:
  • ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.
  • 📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.

thabofletcher added a commit that referenced this pull request Apr 15, 2026
Mirrors the POC fides-pbac CLI (#7941) but with the CLI staying in
Python and the SQL parsing staying in Python. The Go library gets a
new pipeline package that can drive the same flow over HTTP or
in-process — useful when we want to move the hot path off of Python
later without rewriting the CLI UX.

Go additions (policy-engine/):
- pkg/fixtures — YAML loaders for consumers/, purposes/, datasets/,
  policies/ matching the POC's config dir layout
- pkg/pipeline — identity resolution + dataset resolution + purpose
  eval + gap reclassification + policy filtering, returning one
  EvaluationRecord per statement. 8 tests against the pbac/ fixtures.
- pkg/pbac/types.go — SuppressedByPolicy + SuppressedByAction on
  PurposeViolation so suppressed violations stay in the record for
  audit instead of being dropped. GapUnconfiguredConsumer restored
  (the pipeline needs it; the engine still doesn't produce it).
- pkg/pbac/policy_types.go — yaml: tags alongside json: on the policy
  types so YAML-loaded policies round-trip through the same struct.
  New Identity field on AccessEvaluationRequest carries the caller
  identity through the engine so identity-aware policies become an
  additive change rather than a request-shape break.

Python additions (src/fides/):
- service/pbac/fixtures.py — Python mirror of the Go fixture loaders
- service/pbac/pipeline.py — Python mirror of the Go pipeline; reuses
  the existing sql_parser (sqlglot), evaluate_purpose, and
  evaluate_policies primitives
- service/pbac/policies/interface.py — Identity field on
  AccessEvaluationRequest to match the Go side
- cli/commands/pbac.py — new `fides pbac evaluate --config DIR
  --identity EMAIL [SQL_FILE]` command. Existing evaluate-purpose and
  evaluate-policies commands stay as lower-level JSON primitives.

Fixtures (pbac/):
- Ported verbatim from the POC to serve as both demo data and the
  test fixture set for the pipeline tests.
thabofletcher added a commit that referenced this pull request Apr 16, 2026
Mirrors the POC fides-pbac CLI (#7941) but with the CLI staying in
Python and the SQL parsing staying in Python. The Go library gets a
new pipeline package that can drive the same flow over HTTP or
in-process — useful when we want to move the hot path off of Python
later without rewriting the CLI UX.

Go additions (policy-engine/):
- pkg/fixtures — YAML loaders for consumers/, purposes/, datasets/,
  policies/ matching the POC's config dir layout
- pkg/pipeline — identity resolution + dataset resolution + purpose
  eval + gap reclassification + policy filtering, returning one
  EvaluationRecord per statement. 8 tests against the pbac/ fixtures.
- pkg/pbac/types.go — SuppressedByPolicy + SuppressedByAction on
  PurposeViolation so suppressed violations stay in the record for
  audit instead of being dropped. GapUnconfiguredConsumer restored
  (the pipeline needs it; the engine still doesn't produce it).
- pkg/pbac/policy_types.go — yaml: tags alongside json: on the policy
  types so YAML-loaded policies round-trip through the same struct.
  New Identity field on AccessEvaluationRequest carries the caller
  identity through the engine so identity-aware policies become an
  additive change rather than a request-shape break.

Python additions (src/fides/):
- service/pbac/fixtures.py — Python mirror of the Go fixture loaders
- service/pbac/pipeline.py — Python mirror of the Go pipeline; reuses
  the existing sql_parser (sqlglot), evaluate_purpose, and
  evaluate_policies primitives
- service/pbac/policies/interface.py — Identity field on
  AccessEvaluationRequest to match the Go side
- cli/commands/pbac.py — new `fides pbac evaluate --config DIR
  --identity EMAIL [SQL_FILE]` command. Existing evaluate-purpose and
  evaluate-policies commands stay as lower-level JSON primitives.

Fixtures (pbac/):
- Ported verbatim from the POC to serve as both demo data and the
  test fixture set for the pipeline tests.
thabofletcher added a commit that referenced this pull request Apr 16, 2026
Mirrors the POC fides-pbac CLI (#7941) but with the CLI staying in
Python and the SQL parsing staying in Python. The Go library gets a
new pipeline package that can drive the same flow over HTTP or
in-process — useful when we want to move the hot path off of Python
later without rewriting the CLI UX.

Go additions (policy-engine/):
- pkg/fixtures — YAML loaders for consumers/, purposes/, datasets/,
  policies/ matching the POC's config dir layout
- pkg/pipeline — identity resolution + dataset resolution + purpose
  eval + gap reclassification + policy filtering, returning one
  EvaluationRecord per statement. 8 tests against the pbac/ fixtures.
- pkg/pbac/types.go — SuppressedByPolicy + SuppressedByAction on
  PurposeViolation so suppressed violations stay in the record for
  audit instead of being dropped. GapUnconfiguredConsumer restored
  (the pipeline needs it; the engine still doesn't produce it).
- pkg/pbac/policy_types.go — yaml: tags alongside json: on the policy
  types so YAML-loaded policies round-trip through the same struct.
  New Identity field on AccessEvaluationRequest carries the caller
  identity through the engine so identity-aware policies become an
  additive change rather than a request-shape break.

Python additions (src/fides/):
- service/pbac/fixtures.py — Python mirror of the Go fixture loaders
- service/pbac/pipeline.py — Python mirror of the Go pipeline; reuses
  the existing sql_parser (sqlglot), evaluate_purpose, and
  evaluate_policies primitives
- service/pbac/policies/interface.py — Identity field on
  AccessEvaluationRequest to match the Go side
- cli/commands/pbac.py — new `fides pbac evaluate --config DIR
  --identity EMAIL [SQL_FILE]` command. Existing evaluate-purpose and
  evaluate-policies commands stay as lower-level JSON primitives.

Fixtures (pbac/):
- Ported verbatim from the POC to serve as both demo data and the
  test fixture set for the pipeline tests.
thabofletcher added a commit that referenced this pull request Apr 17, 2026
Mirrors the POC fides-pbac CLI (#7941) but with the CLI staying in
Python and the SQL parsing staying in Python. The Go library gets a
new pipeline package that can drive the same flow over HTTP or
in-process — useful when we want to move the hot path off of Python
later without rewriting the CLI UX.

Go additions (policy-engine/):
- pkg/fixtures — YAML loaders for consumers/, purposes/, datasets/,
  policies/ matching the POC's config dir layout
- pkg/pipeline — identity resolution + dataset resolution + purpose
  eval + gap reclassification + policy filtering, returning one
  EvaluationRecord per statement. 8 tests against the pbac/ fixtures.
- pkg/pbac/types.go — SuppressedByPolicy + SuppressedByAction on
  PurposeViolation so suppressed violations stay in the record for
  audit instead of being dropped. GapUnconfiguredConsumer restored
  (the pipeline needs it; the engine still doesn't produce it).
- pkg/pbac/policy_types.go — yaml: tags alongside json: on the policy
  types so YAML-loaded policies round-trip through the same struct.
  New Identity field on AccessEvaluationRequest carries the caller
  identity through the engine so identity-aware policies become an
  additive change rather than a request-shape break.

Python additions (src/fides/):
- service/pbac/fixtures.py — Python mirror of the Go fixture loaders
- service/pbac/pipeline.py — Python mirror of the Go pipeline; reuses
  the existing sql_parser (sqlglot), evaluate_purpose, and
  evaluate_policies primitives
- service/pbac/policies/interface.py — Identity field on
  AccessEvaluationRequest to match the Go side
- cli/commands/pbac.py — new `fides pbac evaluate --config DIR
  --identity EMAIL [SQL_FILE]` command. Existing evaluate-purpose and
  evaluate-policies commands stay as lower-level JSON primitives.

Fixtures (pbac/):
- Ported verbatim from the POC to serve as both demo data and the
  test fixture set for the pipeline tests.
Base automatically changed from policy-engine-go-library to main April 17, 2026 22:55
thabofletcher added a commit that referenced this pull request Apr 17, 2026
Mirrors the POC fides-pbac CLI (#7941) but with the CLI staying in
Python and the SQL parsing staying in Python. The Go library gets a
new pipeline package that can drive the same flow over HTTP or
in-process — useful when we want to move the hot path off of Python
later without rewriting the CLI UX.

Go additions (policy-engine/):
- pkg/fixtures — YAML loaders for consumers/, purposes/, datasets/,
  policies/ matching the POC's config dir layout
- pkg/pipeline — identity resolution + dataset resolution + purpose
  eval + gap reclassification + policy filtering, returning one
  EvaluationRecord per statement. 8 tests against the pbac/ fixtures.
- pkg/pbac/types.go — SuppressedByPolicy + SuppressedByAction on
  PurposeViolation so suppressed violations stay in the record for
  audit instead of being dropped. GapUnconfiguredConsumer restored
  (the pipeline needs it; the engine still doesn't produce it).
- pkg/pbac/policy_types.go — yaml: tags alongside json: on the policy
  types so YAML-loaded policies round-trip through the same struct.
  New Identity field on AccessEvaluationRequest carries the caller
  identity through the engine so identity-aware policies become an
  additive change rather than a request-shape break.

Python additions (src/fides/):
- service/pbac/fixtures.py — Python mirror of the Go fixture loaders
- service/pbac/pipeline.py — Python mirror of the Go pipeline; reuses
  the existing sql_parser (sqlglot), evaluate_purpose, and
  evaluate_policies primitives
- service/pbac/policies/interface.py — Identity field on
  AccessEvaluationRequest to match the Go side
- cli/commands/pbac.py — new `fides pbac evaluate --config DIR
  --identity EMAIL [SQL_FILE]` command. Existing evaluate-purpose and
  evaluate-policies commands stay as lower-level JSON primitives.

Fixtures (pbac/):
- Ported verbatim from the POC to serve as both demo data and the
  test fixture set for the pipeline tests.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants