Connectors.

Connectors

What it is. The catalog of databases AccessFlow can talk to, and the one-click way to enable them. Use it to turn on support for an engine before you add a datasource for it — so the image doesn't have to ship every database driver. The Admin → Connectors marketplace (/admin/connectors) groups the SQL (relational) family separately from the NoSQL family.

Configure it. Click Install on a connector card; AccessFlow downloads its driver, verifies it against a pinned checksum, and caches it. PostgreSQL ships Installed; everything else — MongoDB, Couchbase, Redis, Cassandra, ScyllaDB, Elasticsearch, OpenSearch, Amazon DynamoDB, Neo4j, Snowflake, BigQuery, Databricks, and the other SQL drivers — shows an Install action.

Which databases does AccessFlow support?

AccessFlow ships connectors for 18 engines across three families. Relational engines run over pooled JDBC; data-warehouse and NoSQL engines run through native plugins that are downloaded on demand, SHA-256-verified, and cached. Every engine gets the same review pipeline, masking, and audit log — only the query language and the row-security mechanics differ.

Any other JDBC-compatible engine can be added by uploading its driver JAR and creating a Custom datasource. The per-engine detail — ports, credential shapes, and what each engine rejects up front — follows below.

Built-in connectors — SQL:

• PostgreSQL — bundled (ships in the image, no download).
• MySQL — com.mysql:mysql-connector-j · 1-click install.
• MariaDB — org.mariadb.jdbc:mariadb-java-client · 1-click install.
• Oracle Database — com.oracle.database.jdbc:ojdbc11 · 1-click install.
• Microsoft SQL Server — com.microsoft.sqlserver:mssql-jdbc · 1-click install.
• ClickHouse — com.clickhouse:clickhouse-jdbc · 1-click install (a CUSTOM-dialect connector, the first engine beyond the built-in five).

Built-in connectors — NoSQL:

• MongoDB — native engine plugin (not JDBC) · 1-click install; the engine downloads on demand like a JDBC driver and is cached in the same driver-cache directory (pre-seed it for air-gapped installs). Users write queries in the mongo shell form (db.users.find({ … })) or a JSON command document, chosen in the editor; results show in both a JSON document view and a flattened table. AI risk analysis, human approval, row-level security ($match injection), and field masking all apply. Configure it with the standard host/port/database/username/password/SSL fields.
• Couchbase — native engine plugin (not JDBC) · 1-click install; same on-demand download/verify/cache model as MongoDB. Users write SQL++ (N1QL) statements with SQL-style highlighting and formatting in the editor; results show in both a table and a JSON document view. AI risk analysis, human approval, row-level security (predicates ANDed into the WHERE clause with parameter binding; unrewritable shapes rejected), and field masking all apply; CURL(), JavaScript UDFs, and system:* keyspaces are rejected up front. The database field holds the bucket; plain connections bootstrap on port 11210 (couchbase://), TLS on 11207 (couchbases://) — pick the matching port or use a connection-string override.
• Redis — native key-value engine plugin (not JDBC) · 1-click install; same on-demand download/verify/cache model as MongoDB. Users submit redis-cli commands (GET user:42, HGETALL session:abc, SCAN 0 MATCH orders:* COUNT 100, SET, DEL) classified onto the same approval workflow; server-side scripting and blast-radius commands (EVAL, CONFIG, FLUSHALL, SHUTDOWN) are rejected at submission. Field masking applies to returned hash fields / values; row-security policies on a Redis datasource fail closed (row predicates have no key-value meaning). The database field holds the numeric DB index (default 0); plain connections use port 6379 (redis://), TLS uses rediss://.
• Apache Cassandra — native wide-column engine plugin (not JDBC) · 1-click install; same on-demand download/verify/cache model as MongoDB. Users write CQL statements classified onto the same approval workflow (SELECT / INSERT / UPDATE / DELETE plus CREATE/ALTER/DROP of table/keyspace/index/type/materialized-view and TRUNCATE); server-side code (BEGIN … BATCH, CREATE/DROP FUNCTION/AGGREGATE) is rejected up front. Row-level security is key-aware and fails closed — predicates splice into the WHERE clause only on partition/clustering key columns with CQL-filterable operators (=, IN, <, <=, >, >=); a non-key column, !=/NOT IN, or INSERT into a policied table is rejected rather than injecting ALLOW FILTERING. Field masking applies to returned columns. The database field holds the keyspace; the per-datasource local datacenter field is required (the driver's load-balancing datacenter). Default port 9042.
• ScyllaDB — native wide-column engine plugin (not JDBC) · 1-click install; CQL-compatible and served by the same engine plugin as Apache Cassandra. Identical governance: CQL classification, key-aware fail-closed row-level security, field masking, and rejected server-side code. The database field holds the keyspace; the per-datasource local datacenter field is required. Default port 9042.
• Elasticsearch — native search engine plugin (not JDBC) · 1-click install; same on-demand download/verify/cache model as MongoDB. Users write a JSON query envelope ({"search":"logs-*","query":{…}}, plus count, get/mget, index/bulk, update_by_query/delete_by_query, and index management) classified onto the same approval workflow; server-side scripting (script, runtime_mappings, Painless) and cluster/system-index APIs are rejected up front. Row-level security injects bool.filter clauses on keyword fields (fail-closed on writes into a policied index), and field masking applies recursively to _source fields including nested dot-paths. Authenticate with basic auth (username + password) or an API key — pick the method in the connection wizard. The database field is optional (it only scopes introspection — the index is named in the query). Default port 9200, SSL REQUIRE.
• OpenSearch — native search engine plugin (not JDBC) · 1-click install; wire-compatible and served by the same engine plugin as Elasticsearch. Identical governance: JSON query envelope classification, bool.filter row-level security on keyword fields, nested field masking, rejected scripting/cluster APIs, and basic-or-API-key auth. The database field is optional. Default port 9200.
• Amazon DynamoDB — native key-value engine plugin (not JDBC) · 1-click install; same on-demand download/verify/cache model as MongoDB (AWS SDK for Java v2 over the url-connection HTTP client — no Netty). Users write PartiQL (SELECT / INSERT / UPDATE / DELETE), and table management arrives as a JSON command document ({"CreateTable": {…}}, DeleteTable, UpdateTable); transaction/batch statements are rejected. Row-level security splices predicates into the PartiQL WHERE clause with parameter binding on any attribute (DynamoDB filters via Scan), failing closed on INSERT-into-policied and deny-all; field masking applies recursively by dot-path including nested maps/lists. Its connection is cloud credentials + region, not host/port: the database field holds the AWS region, the username/password hold the access key id / secret access key, and an optional custom endpoint targets DynamoDB Local / VPC. Default port 8000 (DynamoDB Local; AWS uses the SDK regional endpoint).
• Neo4j — native graph engine plugin (not JDBC) · 1-click install; same on-demand download/verify/cache model as MongoDB (native Neo4j Java driver over the Bolt protocol). Users write Cypher; the query type is the strongest write clause present (DELETE/REMOVE → DELETE, CREATE/MERGE → INSERT, SET → UPDATE, else a MATCH … RETURN / SHOW read → SELECT), with index / constraint / database / role schema commands as DDL. LOAD CSV, procedure calls outside a read-only allow-list, and multi-statement input are rejected. Row-level security ANDs property predicates onto each MATCH's WHERE with parameter binding (node-label policies), failing closed on anonymous or write-creates-policied-label shapes; field masking is label-aware and recursive. Connection is host/port + database (the Neo4j database, required) with the SSL mode encoded in the Bolt scheme, or a full bolt:// / neo4j+s:// URI in the optional Bolt connection URI field (Neo4j Aura / clustered routing). Default port 7687 (Bolt).

Built-in connectors — Cloud data warehouses:

• Snowflake — native warehouse engine plugin · 1-click install; same on-demand download/verify/cache model as MongoDB (the plugin bundles the Snowflake JDBC driver but opens a short-lived connection per request — warehouse sessions are billed while resumed, so nothing is pooled). Users write Snowflake SQL classified onto the same approval workflow; CALL, EXECUTE IMMEDIATE, scripting blocks, COPY INTO, PUT/GET, USE, and SHOW are rejected up front. Row-level security splices predicates into the WHERE clause with parameter binding (fail-closed on CTE / subquery / JOIN / set-operation shapes), and field masking applies to returned columns. Connection is the account host + database + user, with a credential that is a password or an unencrypted PKCS#8 private key (key-pair authentication), plus an optional full jdbc:snowflake:// URL for warehouse / role / schema parameters. Port is unused (HTTPS 443).
• Google BigQuery — native warehouse engine plugin (not JDBC) · 1-click install; same on-demand model (Google Cloud HTTP/JSON client). Users write GoogleSQL; scripting (BEGIN/DECLARE/CALL/EXECUTE IMMEDIATE), EXPORT DATA, and LOAD DATA are rejected up front. Row-level security splices positional-parameter predicates into the WHERE clause (same fail-closed shapes), and field masking applies recursively by dot-path across nested RECORD fields. Its connection is cloud credentials, not host/port: the database field holds the GCP project (optionally project.dataset to pin a default dataset) and the credential is the service-account key JSON; an optional custom endpoint targets the BigQuery emulator.
• Databricks SQL — native warehouse engine plugin (not JDBC, no vendor SDK) · 1-click install; the engine talks to the SQL Statement Execution REST API. Users write Databricks SQL; USE, SET, COPY INTO, CALL, and maintenance commands (OPTIMIZE, VACUUM, ANALYZE) are rejected up front. Row-level security splices named-parameter predicates into the WHERE clause (same fail-closed shapes), and field masking applies to returned columns. Connection is the workspace host + a required warehouse HTTP path (/sql/1.0/warehouses/<id>) + a personal access token, with an optional Unity Catalog catalog in the database field. Port is unused (HTTPS 443).

Adding a new database to the catalog is a data change, not a code change — see the connectors design doc if you want to contribute one.

1. Install. Click Install on a connector card. The driver is fetched from the configured Maven repository (ACCESSFLOW_DRIVERS_REPOSITORY_URL), SHA-256-verified, and cached to ACCESSFLOW_DRIVER_CACHE.
2. Use it. Installed connectors appear in the datasource create wizard. The five core engines are first-class database types; additional engines (e.g. ClickHouse) are created as a Custom datasource backed by the connector — you fill in host / port / database and AccessFlow builds the JDBC URL from the connector's template.
3. Air-gapped. Pre-seed the driver cache and set ACCESSFLOW_DRIVERS_OFFLINE=true; connectors whose JAR isn't cached then report Unavailable.

API connectors

What it is. API Access Governance lets you govern outbound API calls — REST, SOAP, GraphQL, and gRPC — with the same review, approval, and audit machinery as a database query. An API connector (/api-connectors) is a registered API target: a base URL, a protocol, and an authentication method.

Configure it (admin). Create a connector with a base URL, protocol, and an auth method — None, API key, Bearer token, Basic, OAuth2 client-credentials, Custom header, or mTLS. Secrets are AES-256-GCM encrypted at rest and never returned. For OAuth2 client-credentials, AccessFlow fetches, caches, and refreshes the upstream access token itself — configure the token endpoint, client ID/secret, scopes, audience, grant type (client-credentials, refresh-token, or resource-owner password), and client-auth method (Basic header or POST body); the token is reused across calls and refreshed on expiry or a 401, so no token needs to be pasted by hand. Define default headers sent on every governed call (users see them but cannot change them) and, optionally, rename the trace-context header keys AccessFlow uses to propagate W3C traceparent. Optionally upload a schema (OpenAPI / WSDL / GraphQL SDL / gRPC .proto, or a Postman Collection v2.1 export) by pasting it, dragging a file in, or pointing at a URL to fetch; AccessFlow parses it into a normalized operation catalog with read/write classification. A Postman collection is handy when a team has no OpenAPI document — folders flatten into operation ids and {{variables}} become path templates. Two caveats it states at upload time: Postman stores examples, not schemas, so request/response shapes are inferred and less precise; and any credentials in your export are ignored and never stored — re-enter them in the connector's authentication settings above. Pre-request and test scripts in the export are dropped entirely. An optional import filter keeps the ungovernable parts of a real-world spec out of that catalog: exclude (or restrict to) path globs such as /internal/**, exclude HTTP verbs, operation-id globs, OpenAPI tags, and deprecated operations. Preview shows exactly which operations a pattern drops before you commit, the schema list reports "keeps N of M", and the filter stays editable afterwards without re-uploading the document. Filtered-out operations are unreachable everywhere — the API editor, text-to-API, and the per-user allowed-operations picker. Set the review plan, AI-analysis toggle + AI config, text-to-API toggle, require-review-on-reads/writes, and the max response size (default 10 MiB — the full response is stored and downloadable up to this cap, with only a bounded preview shown inline). A Test connection button probes reachability (and, for OAuth2 connectors, exercises the token fetch).

Share with the team. Grant per-user access on a connector (can read / can write / can break-glass, an optional expiry, an allowed-operations subset, and response fields to mask). Users see only the connectors they are granted.

Mask & classify responses. On the connector's Masking and Classification tabs (admin), define connector-level masking policies that redact response fields before the snapshot is stored. Because API responses aren't columnar, a policy targets a field four ways — a schema field (operation + field from the parsed catalog), a JSON path, an XML path (XPath), or a regex — each with a masking strategy (full, partial, hash, email, format-preserving) and role / group / user reveal scoping (a requester in a reveal list sees the unmasked value; no implicit admin bypass). Data-classification tags (PII, PCI, PHI, GDPR, FINANCIAL, SENSITIVE) on a field auto-derive a masking policy and raise the AI risk score for calls to the operation, with a derivation preview of the suggested handling. Masking is applied once, before storage, so raw values never persist, and the policy ids that applied are recorded in the execution audit.

Dynamic variables (request signing). Some APIs — common in banking, payments and telco — require a value computed per request: an HMAC signature, a nonce, a timestamp, an idempotency key. A requester can't hand-compute those for a governed call, because the signature covers a body a reviewer approves minutes or hours later and the timestamp would already be stale. On the connector's Variables tab (admin) you declare named values that AccessFlow computes at execution time and substitutes into headers, the path, query parameters and the body wherever {{name}} appears. Kinds cover a constant, a random UUID, a timestamp, epoch milliseconds, random bytes, a hash (SHA-256/MD5), an HMAC signature (HMAC-SHA256/512 with an encrypted shared secret), or a re-encoding — output as hex, base64 or URL-safe base64. Expressions can reference the in-flight request ({{request.method}}, {{request.path}}, {{request.query}}, {{request.body}}, {{request.headers.Authorization}}) and each other; AccessFlow resolves them in dependency order and rejects circular references while you're editing, not at run time. Variables are evaluated after authentication, so a signature can cover the resolved Authorization header — including a freshly minted OAuth2 token. Instead of a placeholder, a variable can inject itself straight into a fixed header or query parameter. Evaluation is template substitution over a fixed function set only: there is no scripting engine and no user-supplied code. Shared secrets are encrypted at rest, never returned by the API, and computed values are never stored, snapshotted or logged.

Per-request overrides. An admin can mark a variable overridable, and grant selected teammates the Override variables permission on the connector. Those requesters can then supply their own value for that variable from the API editor's Variables tab — pinning a nonce for a replay test, say. Overrides are deny-by-default and deliberately narrow: a variable holding a secret can never be made overridable, an override is inserted literally and can never expand into another variable's value, and the values are saved with the request and shown to the reviewer, so an approval covers exactly what will be sent.

Use it. In the API editor (/api-editor) a user picks a connector, searches the operation catalog (or writes a free-form method + path), and composes the call like Postman — query parameters, custom headers (over the connector's read-only default headers), and a body that can be raw, x-www-form-urlencoded, multipart form-data, or a binary file upload. A user can schedule the call for later, sees a debounced AI risk preview, and submits. Plain-English text-to-API drafts a call for schema-backed connectors. Every call flows through AI risk scoring → routing → human review (no self-approval) → guarded execution that injects the connector's auth and a W3C traceparent, caps and field-masks the response, and stores an immutable response snapshot. The full stored response can be downloaded in its original format, and the request list is filterable by submitter, trace id, and span id. Break-glass and scheduled execution mirror the query path. Note: gRPC connectors register and review today; gRPC call execution is a follow-up — REST/SOAP/GraphQL execute fully.