Skip to content

The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:

feat: split can-read from can-query in data model (#67815)

Edward Paget90ba3e39e770
diff --git a/e2e/test/scenarios/models/reproductions.cy.spec.js b/e2e/test/scenarios/models/reproductions.cy.spec.js
index 625c296d2d3..39952782db7 100644
--- a/e2e/test/scenarios/models/reproductions.cy.spec.js
+++ b/e2e/test/scenarios/models/reproductions.cy.spec.js
@@ -983,9 +983,10 @@ describe("issue 29517 - nested question based on native model with remapped valu
cy.signInAsAdmin();
H.createNativeQuestion(questionDetails).then(({ body: { id } }) => {
- cy.intercept("GET", `/api/database/${SAMPLE_DB_ID}/schema/PUBLIC`).as(
- "schema",
- );
+ cy.intercept(
+ "GET",
+ `/api/database/${SAMPLE_DB_ID}/schema/PUBLIC?can-query=true`,
+ ).as("schema");
cy.visit(`/model/${id}/columns`);
cy.wait("@schema");
@@ -1093,9 +1094,10 @@ describe("issue 53556 - nested question based on native model with remapped valu
cy.signInAsAdmin();
H.createNativeQuestion(questionDetails).then(({ body: { id } }) => {
- cy.intercept("GET", `/api/database/${SAMPLE_DB_ID}/schema/PUBLIC`).as(
- "schema",
- );
+ cy.intercept(
+ "GET",
+ `/api/database/${SAMPLE_DB_ID}/schema/PUBLIC?can-query=true`,
+ ).as("schema");
cy.visit(`/model/${id}/columns`);
cy.wait("@schema");
@@ -1292,9 +1294,10 @@ FROM
it("Create model, set metadata, distinct", () => {
H.createNativeQuestion(questionDetails).then(({ body: { id } }) => {
- cy.intercept("GET", `/api/database/${SAMPLE_DB_ID}/schema/PUBLIC`).as(
- "schema",
- );
+ cy.intercept(
+ "GET",
+ `/api/database/${SAMPLE_DB_ID}/schema/PUBLIC?can-query=true`,
+ ).as("schema");
cy.visit(`/model/${id}/columns`);
cy.wait("@schema");
diff --git a/enterprise/backend/test/metabase_enterprise/advanced_permissions/common_test.clj b/enterprise/backend/test/metabase_enterprise/advanced_permissions/common_test.clj
index 00799a67245..f3b79e56747 100644
--- a/enterprise/backend/test/metabase_enterprise/advanced_permissions/common_test.clj
+++ b/enterprise/backend/test/metabase_enterprise/advanced_permissions/common_test.clj
@@ -267,7 +267,8 @@
:get
200
(format "database/%d/metadata?include_editable_data_model=true" (mt/id)))]
- (is (= {:id (mt/id) :name (:name (mt/db))} (dissoc result :tables)))
+ (is (= (mt/id) (:id result)))
+ (is (= (:name (mt/db)) (:name result)))
(is (= [id-1] (map :id (:tables result))))))))))
(deftest fetch-id-fields-test
@@ -294,10 +295,10 @@
(mt/with-all-users-data-perms-graph! {db-id {:view-data :blocked
:create-queries :no
:data-model {:schemas :all}}}
- (testing "and if data permissions are revoked, it should be a 403"
- (is (= "You don't have permissions to do that."
- (mt/user-http-request :rasta :get 403 (format "database/%d/schema/%s" db-id "schema1")))))
- (testing "and if include_editable_data_model=true and data permissions are revoked, it should return values"
+ (testing "user can access schema due to data-model perms"
+ (is (= ["t1" "t3"]
+ (map :name (mt/user-http-request :rasta :get 200 (format "database/%d/schema/%s" db-id "schema1"))))))
+ (testing "include_editable_data_model=true also returns values"
(is (= ["t1" "t3"]
(map :name (mt/user-http-request :rasta :get 200 (format "database/%d/schema/%s" db-id "schema1")
:include_editable_data_model true)))))))
@@ -330,11 +331,10 @@
(mt/with-all-users-data-perms-graph! {db-id {:view-data :blocked
:create-queries :no
:data-model {:schemas :all}}}
- (testing "If data permissions are revoked, it should be a 403"
- (is (= "You don't have permissions to do that."
- (mt/user-http-request :rasta :get 403 (format "database/%d/schema/" db-id)))))
- (testing "If include_editable_data_model=true and data permissions are revoked, it should return tables with both
- `nil` and \"\" as its schema"
+ (testing "user can access schema due to data-model perms - returns tables with both nil and \"\" schema"
+ (is (= ["t1" "t3"]
+ (map :name (mt/user-http-request :rasta :get 200 (format "database/%d/schema/" db-id))))))
+ (testing "include_editable_data_model=true also returns tables with both `nil` and \"\" as schema"
(is (= ["t1" "t3"]
(map :name (mt/user-http-request :rasta :get 200 (format "database/%d/schema/" db-id)
:include_editable_data_model true))))))
@@ -368,10 +368,10 @@
(mt/with-all-users-data-perms-graph! {db-id {:view-data :blocked
:create-queries :no
:data-model {:schemas :all}}}
- (testing "if include_editable_data_model=nil, it should be a 403"
- (is (= "You don't have permissions to do that."
- (mt/user-http-request :rasta :get 403 (format "database/%d/schemas" db-id)))))
- (testing "and if include_editable_data_model=true, it should return values"
+ (testing "user can access schemas due to data-model perms"
+ (is (= ["schema1" "schema2"]
+ (mt/user-http-request :rasta :get 200 (format "database/%d/schemas" db-id)))))
+ (testing "include_editable_data_model=true also returns values"
(is (= ["schema1" "schema2"]
(mt/user-http-request :rasta :get 200 (format "database/%d/schemas" db-id)
:include_editable_data_model true))))
@@ -403,6 +403,69 @@
(mt/user-http-request :rasta :get 200 (format "database/%d/schemas" db-id)
:include_editable_data_model true))))))))
+;;; +----------------------------------------------------------------------------------------------------------------+
+;;; | can-query and can-write-metadata filter tests |
+;;; +----------------------------------------------------------------------------------------------------------------+
+
+(deftest list-databases-can-write-metadata-filter-test
+ (testing "GET /api/database with can-write-metadata=true filters to only databases with editable tables"
+ (mt/with-temp [:model/Database {db-1-id :id} {:name "Editable DB"}
+ :model/Database {db-2-id :id} {:name "Not Editable DB"}
+ :model/Table t1 {:db_id db-1-id :name "table1" :active true}
+ :model/Table _ {:db_id db-2-id :name "table2" :active true}]
+ (mt/with-all-users-data-perms-graph! {db-1-id {:view-data :unrestricted
+ :create-queries :query-builder
+ :data-model {:schemas {"" {(u/the-id t1) :all}}}}
+ db-2-id {:view-data :unrestricted
+ :create-queries :query-builder
+ :data-model {:schemas :none}}}
+ (let [response (->> (mt/user-http-request :rasta :get 200 "database" :can-write-metadata true)
+ :data
+ (filter #(#{db-1-id db-2-id} (:id %))))]
+ (is (= 1 (count response)))
+ (is (= "Editable DB" (-> response first :name))))))))
+
+(deftest list-databases-with-tables-can-write-metadata-filter-test
+ (testing "GET /api/database?include=tables&can-write-metadata=true filters tables within databases"
+ (mt/with-temp [:model/Database {db-id :id} {:name "Test DB"}
+ :model/Table t1 {:db_id db-id :name "editable_table" :active true}
+ :model/Table t2 {:db_id db-id :name "not_editable_table" :active true}]
+ (mt/with-all-users-data-perms-graph! {db-id {:view-data :unrestricted
+ :create-queries :query-builder
+ :data-model {:schemas {"" {(u/the-id t1) :all
+ (u/the-id t2) :none}}}}}
+ (let [response (->> (mt/user-http-request :rasta :get 200 "database" :include "tables" :can-write-metadata true)
+ :data
+ (filter #(= (:id %) db-id))
+ first)]
+ (is (= 1 (count (:tables response))))
+ (is (= "editable_table" (-> response :tables first :name))))))))
+
+(deftest list-schemas-can-write-metadata-filter-test
+ (testing "GET /api/database/:id/schemas with can-write-metadata=true filters to only schemas with editable tables"
+ (mt/with-temp [:model/Database {db-id :id} {}
+ :model/Table t1 {:db_id db-id :schema "editable_schema" :name "t1" :active true}
+ :model/Table _ {:db_id db-id :schema "not_editable_schema" :name "t2" :active true}]
+ (mt/with-all-users-data-perms-graph! {db-id {:view-data :unrestricted
+ :create-queries :query-builder
+ :data-model {:schemas {"editable_schema" {(u/the-id t1) :all}
+ "not_editable_schema" :none}}}}
+ (is (= ["editable_schema"]
+ (mt/user-http-request :rasta :get 200 (format "database/%d/schemas" db-id) :can-write-metadata true)))))))
+
+(deftest list-schema-tables-can-write-metadata-filter-test
+ (testing "GET /api/database/:id/schema/:schema with can-write-metadata=true filters to only editable tables"
+ (mt/with-temp [:model/Database {db-id :id} {}
+ :model/Table t1 {:db_id db-id :schema "test_schema" :name "editable_table" :active true}
+ :model/Table t2 {:db_id db-id :schema "test_schema" :name "not_editable_table" :active true}]
+ (mt/with-all-users-data-perms-graph! {db-id {:view-data :unrestricted
+ :create-queries :query-builder
+ :data-model {:schemas {"test_schema" {(u/the-id t1) :all
+ (u/the-id t2) :none}}}}}
+ (let [response (mt/user-http-request :rasta :get 200 (format "database/%d/schema/%s" db-id "test_schema") :can-write-metadata true)]
+ (is (= 1 (count response)))
+ (is (= "editable_table" (-> response first :name))))))))
+
(deftest get-field-hydrated-target-with-advanced-perms-test
(testing "GET /api/field/:id"
(mt/with-temp [:model/Database {db-id :id} {}
diff --git a/enterprise/backend/test/metabase_enterprise/data_studio/permissions/published_tables_test.clj b/enterprise/backend/test/metabase_enterprise/data_studio/permissions/published_tables_test.clj
new file mode 100644
index 00000000000..1fb36bccf01
--- /dev/null
+++ b/enterprise/backend/test/metabase_enterprise/data_studio/permissions/published_tables_test.clj
@@ -0,0 +1,60 @@
+(ns metabase-enterprise.data-studio.permissions.published-tables-test
+ "Tests for the can-access-via-collection? function in the published-tables namespace."
+ (:require
+ [clojure.test :refer :all]
+ [metabase.permissions.core :as perms]
+ [metabase.permissions.published-tables :as published-tables]
+ [metabase.test :as mt]
+ [metabase.test.fixtures :as fixtures]))
+
+(use-fixtures :once (fixtures/initialize :db))
+
+(deftest can-access-via-collection?-returns-false-for-non-published-tables-test
+ (testing "Returns false for non-published tables"
+ (mt/with-premium-features #{:data-studio}
+ (mt/with-temp [:model/Collection collection {}
+ :model/PermissionsGroup {group-id :id} {}
+ :model/User {user-id :id} {}
+ :model/PermissionsGroupMembership _ {:user_id user-id :group_id group-id}
+ :model/Table table {:is_published false :collection_id (:id collection)}]
+ (perms/grant-collection-read-permissions! group-id (:id collection))
+ (mt/with-current-user user-id
+ (is (false? (boolean (published-tables/can-access-via-collection? table)))))))))
+
+(deftest can-access-via-collection?-returns-true-with-collection-access-test
+ (testing "Returns true for published tables when user has collection access"
+ (mt/with-premium-features #{:data-studio}
+ (mt/with-temp [:model/Collection collection {}
+ :model/PermissionsGroup {group-id :id} {}
+ :model/User {user-id :id} {}
+ :model/PermissionsGroupMembership _ {:user_id user-id :group_id group-id}
+ :model/Table table {:is_published true :collection_id (:id collection)}]
+ (perms/grant-collection-read-permissions! group-id (:id collection))
+ (mt/with-current-user user-id
+ (is (true? (boolean (published-tables/can-access-via-collection? table)))))))))
+
+(deftest can-access-via-collection?-returns-false-without-collection-access-test
+ (testing "Returns false for published tables when user lacks collection access"
+ (mt/with-premium-features #{:data-studio}
+ (mt/with-temp [:model/Collection collection {}
+ :model/PermissionsGroup {group-id :id} {}
+ :model/User {user-id :id} {}
+ :model/PermissionsGroupMembership _ {:user_id user-id :group_id group-id}
+ :model/Table table {:is_published true :collection_id (:id collection)}]
+ ;; Don't grant collection permissions
+ (perms/revoke-collection-permissions! group-id (:id collection))
+ (perms/revoke-collection-permissions! (perms/all-users-group) (:id collection))
+ (mt/with-current-user user-id
+ (is (false? (boolean (published-tables/can-access-via-collection? table)))))))))
+
+(deftest can-access-via-collection?-returns-false-without-data-studio-feature-test
+ (testing "Returns false when data-studio feature is not enabled"
+ (mt/with-premium-features #{}
+ (mt/with-temp [:model/Collection collection {}
+ :model/PermissionsGroup {group-id :id} {}
+ :model/User {user-id :id} {}
+ :model/PermissionsGroupMembership _ {:user_id user-id :group_id group-id}
+ :model/Table table {:is_published true :collection_id (:id collection)}]
+ (perms/grant-collection-read-permissions! group-id (:id collection))
+ (mt/with-current-user user-id
+ (is (false? (boolean (published-tables/can-access-via-collection? table)))))))))
diff --git a/frontend/src/metabase-types/api/database.ts b/frontend/src/metabase-types/api/database.ts
index a19090aa6c8..3415abdb0b1 100644
--- a/frontend/src/metabase-types/api/database.ts
+++ b/frontend/src/metabase-types/api/database.ts
@@ -147,6 +147,8 @@ export interface ListDatabasesRequest {
include_only_uploadable?: boolean;
include_analytics?: boolean;
router_database_id?: DatabaseId;
+ "can-query"?: boolean;
+ "can-write-metadata"?: boolean;
}
export interface ListDatabasesResponse {
@@ -163,6 +165,8 @@ export interface ListDatabaseSchemasRequest {
id: DatabaseId;
include_hidden?: boolean;
include_editable_data_model?: boolean;
+ "can-query"?: boolean;
+ "can-write-metadata"?: boolean;
}
export interface ListDatabaseSchemaTablesRequest {
@@ -170,6 +174,8 @@ export interface ListDatabaseSchemaTablesRequest {
schema: string;
include_hidden?: boolean;
include_editable_data_model?: boolean;
+ "can-query"?: boolean;
+ "can-write-metadata"?: boolean;
}
export interface ListVirtualDatabaseTablesRequest {
diff --git a/frontend/src/metabase-types/api/table.ts b/frontend/src/metabase-types/api/table.ts
index 09f8edf99de..676d9e04d67 100644
--- a/frontend/src/metabase-types/api/table.ts
+++ b/frontend/src/metabase-types/api/table.ts
@@ -104,6 +104,7 @@ export interface TableListQuery {
include_editable_data_model?: boolean;
remove_inactive?: boolean;
skip_fields?: boolean;
+ "can-query"?: boolean;
term?: string;
"data-layer"?: TableDataLayer;
diff --git a/frontend/src/metabase/common/components/Pickers/MiniPicker/components/MiniPickerItemList.tsx b/frontend/src/metabase/common/components/Pickers/MiniPicker/components/MiniPickerItemList.tsx
index efe8f7192c7..171a71814a0 100644
--- a/frontend/src/metabase/common/components/Pickers/MiniPicker/components/MiniPickerItemList.tsx
+++ b/frontend/src/metabase/common/components/Pickers/MiniPicker/components/MiniPickerItemList.tsx
@@ -57,7 +57,7 @@ export function MiniPickerItemList() {
}
function RootItemList() {
- const { data: databases } = useListDatabasesQuery();
+ const { data: databases } = useListDatabasesQuery({ "can-query": true });
const { setPath, isHidden, models, shouldShowLibrary } =
useMiniPickerContext();
const { isLoading: isLoadingRootCollection, error: rootCollectionError } =
@@ -152,7 +152,9 @@ function DatabaseItemList({
const { setPath, onChange, isHidden } = useMiniPickerContext();
const { data: schemas, isLoading: isLoadingSchemas } =
useListDatabaseSchemasQuery(
- parent.model === "database" ? { id: parent.id } : skipToken,
+ parent.model === "database"
+ ? { id: parent.id, "can-query": true }
+ : skipToken,
);
const schemaName: SchemaName | null =
@@ -170,6 +172,7 @@ function DatabaseItemList({
? {
id: dbId,
schema: schemaName,
+ "can-query": true,
}
: skipToken,
);
diff --git a/frontend/src/metabase/common/components/Pickers/TablePicker/TablePicker.tsx b/frontend/src/metabase/common/components/Pickers/TablePicker/TablePicker.tsx
index ecc4e4c51e6..19ff4ee8d57 100644
--- a/frontend/src/metabase/common/components/Pickers/TablePicker/TablePicker.tsx
+++ b/frontend/src/metabase/common/components/Pickers/TablePicker/TablePicker.tsx
@@ -57,7 +57,7 @@ export const TablePicker = ({
data: databasesResponse,
error: errorDatabases,
isFetching: isLoadingDatabases,
- } = useListDatabasesQuery({ saved: false });
+ } = useListDatabasesQuery({ saved: false, "can-query": true });
const databases = isLoadingDatabases ? undefined : databasesResponse?.data;
@@ -65,7 +65,9 @@ export const TablePicker = ({
data: schemas,
error: errorSchemas,
isFetching: isLoadingSchemas,
- } = useListDatabaseSchemasQuery(isNotNull(dbId) ? { id: dbId } : skipToken);
+ } = useListDatabaseSchemasQuery(
+ isNotNull(dbId) ? { id: dbId, "can-query": true } : skipToken,
+ );
const {
data: tables,
@@ -73,7 +75,7 @@ export const TablePicker = ({
isFetching: isLoadingTables,
} = useListDatabaseSchemaTablesQuery(
isNotNull(dbId) && isNotNull(schemaName)
- ? { id: dbId, schema: schemaName }
+ ? { id: dbId, schema: schemaName, "can-query": true }
: skipToken,
);
diff --git a/frontend/src/metabase/metadata/pages/DataModelV1/DataModelV1.tsx b/frontend/src/metabase/metadata/pages/DataModelV1/DataModelV1.tsx
index b5fa2e4ab7d..e067eeb04ed 100644
--- a/frontend/src/metabase/metadata/pages/DataModelV1/DataModelV1.tsx
+++ b/frontend/src/metabase/metadata/pages/DataModelV1/DataModelV1.tsx
@@ -41,7 +41,7 @@ export const DataModelV1 = ({ children, location, params }: Props) => {
const parsedParams = parseRouteParams(params);
const { databaseId, fieldId, schemaName, tableId } = parsedParams;
const { data: databasesData, isLoading: isLoadingDatabases } =
- useListDatabasesQuery({ include_editable_data_model: true });
+ useListDatabasesQuery({ "can-write-metadata": true });
const databaseExists = databasesData?.data?.some(
(database) => database.id === databaseId,
);
diff --git a/frontend/src/metabase/metadata/pages/DataModelV1/components/TablePicker/hooks/useTableLoader.ts b/frontend/src/metabase/metadata/pages/DataModelV1/components/TablePicker/hooks/useTableLoader.ts
index 21441947568..e45ed38a58c 100644
--- a/frontend/src/metabase/metadata/pages/DataModelV1/components/TablePicker/hooks/useTableLoader.ts
+++ b/frontend/src/metabase/metadata/pages/DataModelV1/components/TablePicker/hooks/useTableLoader.ts
@@ -42,10 +42,7 @@ export function useTableLoader(path: TreePath) {
const [tree, setTree] = useState<TreeNode>(rootNode());
const getDatabases = useCallback(async () => {
- const response = await fetchDatabases(
- { include_editable_data_model: true },
- true,
- );
+ const response = await fetchDatabases({ "can-write-metadata": true }, true);
if (databasesRef.current.isError) {
// Do not refetch when this call failed previously.
@@ -77,7 +74,7 @@ export function useTableLoader(path: TreePath) {
id: databaseId,
schema: schemaName,
include_hidden: true,
- include_editable_data_model: true,
+ "can-write-metadata": true,
};
if (
@@ -115,7 +112,7 @@ export function useTableLoader(path: TreePath) {
const newArgs = {
id: databaseId,
include_hidden: true,
- include_editable_data_model: true,
+ "can-write-metadata": true,
};
if (
diff --git a/frontend/src/metabase/query_builder/components/DataSelector/DataSelector.jsx b/frontend/src/metabase/query_builder/components/DataSelector/DataSelector.jsx
index bf1073c5cb6..6d823a87229 100644
--- a/frontend/src/metabase/query_builder/components/DataSelector/DataSelector.jsx
+++ b/frontend/src/metabase/query_builder/components/DataSelector/DataSelector.jsx
@@ -1074,17 +1074,17 @@ const DataSelector = _.compose(
databases:
ownProps.databases ||
Databases.selectors.getList(state, {
- entityQuery: ownProps.databaseQuery,
+ entityQuery: { ...ownProps.databaseQuery, "can-query": true },
}) ||
[],
hasLoadedDatabasesWithTablesSaved: Databases.selectors.getLoaded(state, {
- entityQuery: { include: "tables", saved: true },
+ entityQuery: { include: "tables", saved: true, "can-query": true },
}),
hasLoadedDatabasesWithSaved: Databases.selectors.getLoaded(state, {
- entityQuery: { saved: true },
+ entityQuery: { saved: true, "can-query": true },
}),
hasLoadedDatabasesWithTables: Databases.selectors.getLoaded(state, {
- entityQuery: { include: "tables" },
+ entityQuery: { include: "tables", "can-query": true },
}),
hasDataAccess: canUserCreateQueries(state),
hasNestedQueriesEnabled: getSetting(state, "enable-nested-queries"),
@@ -1094,10 +1094,11 @@ const DataSelector = _.compose(
}),
{
fetchDatabases: (databaseQuery) =>
- Databases.actions.fetchList(databaseQuery),
+ Databases.actions.fetchList({ ...databaseQuery, "can-query": true }),
fetchSchemas: (databaseId) =>
- Schemas.actions.fetchList({ dbId: databaseId }),
- fetchSchemaTables: (schemaId) => Schemas.actions.fetch({ id: schemaId }),
+ Schemas.actions.fetchList({ dbId: databaseId, "can-query": true }),
+ fetchSchemaTables: (schemaId) =>
+ Schemas.actions.fetch({ id: schemaId, "can-query": true }),
fetchFields: (tableId) => Tables.actions.fetchMetadata({ id: tableId }),
fetchQuestion: (id) =>
Questions.actions.fetch({
diff --git a/frontend/src/metabase/query_builder/components/dataref/DatabasePane.tsx b/frontend/src/metabase/query_builder/components/dataref/DatabasePane.tsx
index d6a60e808eb..3b70e17b2e8 100644
--- a/frontend/src/metabase/query_builder/components/dataref/DatabasePane.tsx
+++ b/frontend/src/metabase/query_builder/components/dataref/DatabasePane.tsx
@@ -239,7 +239,7 @@ export const DatabasePane = ({
isLoading: isLoadingSchemas,
error: schemasError,
} = useListDatabaseSchemasQuery(
- databaseId != null ? { id: databaseId } : skipToken,
+ databaseId != null ? { id: databaseId, "can-query": true } : skipToken,
);
const {
diff --git a/src/metabase/api/common.clj b/src/metabase/api/common.clj
index f7a0d840875..98140f2847a 100644
--- a/src/metabase/api/common.clj
+++ b/src/metabase/api/common.clj
@@ -352,6 +352,25 @@
([entity id & other-conditions]
(write-check (apply t2/select-one entity :id id other-conditions))))
+(defn query-check
+ "Check whether we can query an existing `obj`, or `entity` with `id`. If the object doesn't exist, throw a 404; if we
+ don't have query permissions, throw a 403. This is separate from [[read-check]] - for data model entities like
+ Tables and Databases, `query-check` means 'can execute queries against' while `read-check` means 'can see metadata'.
+ This will fetch the object if it was not already fetched, and returns `obj` if the check is successful."
+ ([obj]
+ (check-404 obj)
+ (try
+ (check-403 (mi/can-query? obj))
+ (catch clojure.lang.ExceptionInfo e
+ (events/publish-event! :event/read-permission-failure {:user-id *current-user-id*
+ :object obj})
+ (throw e)))
+ obj)
+ ([entity id]
+ (query-check (t2/select-one entity :id id)))
+ ([entity id & other-conditions]
+ (query-check (apply t2/select-one entity :id id other-conditions))))
+
(defn create-check
"NEW! Check whether the current user has permissions to CREATE a new instance of an object with properties in map `m`.
diff --git a/src/metabase/models/interface.clj b/src/metabase/models/interface.clj
index c9ae08b0d8a..c0e3bac53f7 100644
--- a/src/metabase/models/interface.clj
+++ b/src/metabase/models/interface.clj
@@ -630,6 +630,25 @@
{:arglists '([instance] [model pk])}
dispatch-on-model)
+(defmulti can-query?
+ "Return whether [[metabase.api.common/*current-user*]] has *query* permissions for an object (i.e., can run
+ queries against it). This is separate from [[can-read?]] which determines if the user can see the object's
+ metadata.
+
+ For data model entities like Tables and Databases, `can-read?` means 'can see metadata' while `can-query?`
+ means 'can execute queries against'. For collection entities, `can-query?` typically falls back to `can-read?`.
+
+ The default implementation falls back to [[can-read?]] for backward compatibility."
+ {:arglists '([instance] [model pk])}
+ dispatch-on-model)
+
+(defmethod can-query? :default
+ ;; Default implementation: fall back to can-read? for backward compatibility
+ ([instance]
+ (can-read? instance))
+ ([model pk]
+ (can-read? model pk)))
+
#_{:clj-kondo/ignore [:unused-private-var]}
(define-simple-hydration-method ^:private hydrate-can-write
:can_write
@@ -637,6 +656,11 @@
[instance]
(can-write? instance))
+(methodical/defmethod t2/simple-hydrate [:default :can_query]
+ "Hydration method for `:can_query`. Returns whether the current user can execute queries against this object."
+ [_model k instance]
+ (assoc instance k (can-query? instance)))
+
(defmulti can-create?
"NEW! Check whether or not current user is allowed to CREATE a new instance of `model` with properties in map
`m`.
diff --git a/src/metabase/permissions/core.clj b/src/metabase/permissions/core.clj
index 0e0db076886..5b04bd36190 100644
--- a/src/metabase/permissions/core.clj
+++ b/src/metabase/permissions/core.clj
@@ -125,6 +125,7 @@
graph
update-graph!]
[metabase.permissions.published-tables
+ can-access-via-collection?
user-published-table-permission
user-has-any-published-table-permission?
user-has-published-table-permission-for-database?])
diff --git a/src/metabase/permissions/published_tables.clj b/src/metabase/permissions/published_tables.clj
index 4cab7dd8ab5..11fbadbdb5c 100644
--- a/src/metabase/permissions/published_tables.clj
+++ b/src/metabase/permissions/published_tables.clj
@@ -30,3 +30,10 @@
metabase-enterprise.data-studio.permissions.published-tables
[_database-id]
false)
+
+(defenterprise can-access-via-collection?
+ "Returns true if the user can access this published table via collection read permissions.
+ OSS implementation always returns false - published tables only grant access in EE."
+ metabase-enterprise.data-studio.permissions.published-tables
+ [_table]
+ false)
diff --git a/src/metabase/query_processor/api.clj b/src/metabase/query_processor/api.clj
index 3b92ca205a9..1639ca56c1d 100644
--- a/src/metabase/query_processor/api.clj
+++ b/src/metabase/query_processor/api.clj
@@ -62,8 +62,7 @@
(when-not database
(throw (ex-info (tru "`database` is required for all queries whose type is not `internal`.")
{:status-code 400, :query query})))
- (when-not (mi/can-read? :model/Database database)
- (api/throw-403)))
+ (api/query-check :model/Database database))
;; store table id trivially iff we get a query with simple source-table
(let [table-id (get-in query [:query :source-table])]
(when (int? table-id)
diff --git a/src/metabase/warehouse_schema/models/field.clj b/src/metabase/warehouse_schema/models/field.clj
index da9d37ff0e3..4f118de3643 100644
--- a/src/metabase/warehouse_schema/models/field.clj
+++ b/src/metabase/warehouse_schema/models/field.clj
@@ -4,7 +4,6 @@
[clojure.string :as str]
[honey.sql :as sql]
[medley.core :as m]
- [metabase.api.common :as api]
[metabase.app-db.core :as mdb]
[metabase.lib-be.core :as lib-be]
[metabase.lib.field :as lib.field]
@@ -12,7 +11,6 @@
[metabase.models.humanization :as humanization]
[metabase.models.interface :as mi]
[metabase.models.serialization :as serdes]
- [metabase.permissions.core :as perms]
[metabase.premium-features.core :refer [defenterprise]]
[metabase.util :as u]
[metabase.util.i18n :refer [tru]]
@@ -173,27 +171,26 @@
;; foreign key constraints in generated columns. #44866
(t2/delete! :model/Field :parent_id (:id field)))
-(defn- field->db-id
- [{table-id :table_id, {db-id :db_id} :table}]
- (or db-id (database/table-id->database-id table-id)))
+(defn- field->table
+ "Get the Table for a Field, either from hydration or by fetching."
+ [instance]
+ (or (:table instance)
+ (t2/select-one :model/Table :id (:table_id instance))))
(defmethod mi/can-read? :model/Field
+ ;; Field permissions delegate to the parent Table. User can read this field if they can read its table.
([instance]
- (and (perms/user-has-permission-for-table?
- api/*current-user-id*
- :perms/view-data
- :unrestricted
- (field->db-id instance)
- (:table_id instance))
- (perms/user-has-permission-for-table?
- api/*current-user-id*
- :perms/create-queries
- :query-builder
- (field->db-id instance)
- (:table_id instance))))
+ (mi/can-read? (field->table instance)))
([model pk]
(mi/can-read? (t2/select-one model pk))))
+(defmethod mi/can-query? :model/Field
+ ;; Field permissions delegate to the parent Table. User can query this field if they can query its table.
+ ([instance]
+ (mi/can-query? (field->table instance)))
+ ([model pk]
+ (mi/can-query? (t2/select-one model pk))))
+
(defenterprise current-user-can-write-field?
"OSS implementation. Returns a boolean whether the current user can write the given field."
metabase-enterprise.advanced-permissions.common
diff --git a/src/metabase/warehouse_schema/models/table.clj b/src/metabase/warehouse_schema/models/table.clj
index 985112936c8..b6d2cea1c3c 100644
--- a/src/metabase/warehouse_schema/models/table.clj
+++ b/src/metabase/warehouse_schema/models/table.clj
@@ -239,22 +239,63 @@
(set-new-table-permissions! table)))
(defmethod mi/can-read? :model/Table
+ ;; Check if user can see this table's metadata.
+ ;; True if user has:
+ ;; - Data access permissions (and (view-data :unrestricted) (create-queries :query-builder)), OR
+ ;; - Metadata management permission (manage-table-metadata :yes), OR
+ ;; - Access via published table in a collection (EE feature)
([instance]
- (and (perms/user-has-permission-for-table?
- api/*current-user-id*
- :perms/view-data
- :unrestricted
- (:db_id instance)
- (:id instance))
- (perms/user-has-permission-for-table?
- api/*current-user-id*
- :perms/create-queries
- :query-builder
- (:db_id instance)
- (:id instance))))
+ (or
+ ;; Has data access permissions
+ (and (perms/user-has-permission-for-table?
+ api/*current-user-id*
+ :perms/view-data
+ :unrestricted
+ (:db_id instance)
+ (:id instance))
+ (perms/user-has-permission-for-table?
+ api/*current-user-id*
+ :perms/create-queries
+ :query-builder
+ (:db_id instance)
+ (:id instance)))
+ ;; Has manage-table-metadata permission (allows viewing metadata without data access)
+ (perms/user-has-permission-for-table?
+ api/*current-user-id*
+ :perms/manage-table-metadata
+ :yes
+ (:db_id instance)
+ (:id instance))
+ ;; Can access via published collection (EE feature)
+ (perms/can-access-via-collection? instance)))
([_ pk]
(mi/can-read? (t2/select-one :model/Table pk))))
+(defmethod mi/can-query? :model/Table
+ ;; Check if user can execute queries against this table.
+ ;; True if user has:
+ ;; - Both view-data AND create-queries permissions, OR
+ ;; - Access via published table in a collection (EE feature)
+ ([instance]
+ (or
+ ;; Has both view-data and create-queries permissions
+ (and (perms/user-has-permission-for-table?
+ api/*current-user-id*
+ :perms/view-data
+ :unrestricted
+ (:db_id instance)
+ (:id instance))
+ (perms/user-has-permission-for-table?
+ api/*current-user-id*
+ :perms/create-queries
+ :query-builder
+ (:db_id instance)
+ (:id instance)))
+ ;; Can access via published collection (EE feature)
+ (perms/can-access-via-collection? instance)))
+ ([_ pk]
+ (mi/can-query? (t2/select-one :model/Table pk))))
+
(defenterprise current-user-can-write-table?
"OSS implementation. Returns a boolean whether the current user can write the given field."
metabase-enterprise.advanced-permissions.common
@@ -262,6 +303,8 @@
(mi/superuser?))
(defmethod mi/can-write? :model/Table
+ ;; Check if user can modify this table's metadata.
+ ;; Requires the manage-table-metadata permission
([instance]
(current-user-can-write-table? instance))
([_ pk]
diff --git a/src/metabase/warehouse_schema/table.clj b/src/metabase/warehouse_schema/table.clj
index ac5ab93691a..6f381a2f6e9 100644
--- a/src/metabase/warehouse_schema/table.clj
+++ b/src/metabase/warehouse_schema/table.clj
@@ -31,20 +31,12 @@
(update field :values field-values/field-values->pairs)
field)))))
-(defenterprise can-access-via-collection?
- "Returns true if the user can access this published table via collection read permissions.
- OSS returns false (published tables don't grant access).
- Enterprise checks collection permissions for published tables."
- metabase-enterprise.data-studio.permissions.published-tables
- [_table]
- false)
-
(defn- can-access-table-for-query-metadata?
"Returns true if the current user can access this table for query metadata.
- Checks collection permissions for published tables, data permissions for unpublished tables."
+ Uses can-read? which checks data permissions, metadata management permissions,
+ and collection permissions for published tables."
[table]
- (or (can-access-via-collection? table)
- (mi/can-read? table)))
+ (mi/can-read? table))
(defn fetch-query-metadata*
"Returns the query metadata used to power the Query Builder for the given `table`. `include-sensitive-fields?`,
diff --git a/src/metabase/warehouse_schema_rest/api/field.clj b/src/metabase/warehouse_schema_rest/api/field.clj
index 7cbcc5b0faa..4413965784c 100644
--- a/src/metabase/warehouse_schema_rest/api/field.clj
+++ b/src/metabase/warehouse_schema_rest/api/field.clj
@@ -258,7 +258,7 @@
`:list`, checks whether we should create FieldValues for this Field; if so, creates and returns them."
[{:keys [id]} :- [:map
[:id ms/PositiveInt]]]
- (let [field (api/read-check (t2/select-one :model/Field :id id))]
+ (let [field (api/query-check (t2/select-one :model/Field :id id))]
(parameters.field/field->values field)))
(defn- validate-human-readable-pairs
diff --git a/src/metabase/warehouse_schema_rest/api/table.clj b/src/metabase/warehouse_schema_rest/api/table.clj
index 0d859bad126..bfc3732e482 100644
--- a/src/metabase/warehouse_schema_rest/api/table.clj
+++ b/src/metabase/warehouse_schema_rest/api/table.clj
@@ -67,9 +67,14 @@
;;
#_{:clj-kondo/ignore [:metabase/validate-defendpoint-has-response-schema]}
(api.macros/defendpoint :get "/"
- "Get all `Tables`."
+ "Get all `Tables`.
+
+ Optional filters:
+ - `can-query=true` - filter to only tables the user can execute queries against
+ - `can-write=true` - filter to only tables the user can edit metadata for"
[_
- {:keys [term visibility-type data-layer data-source owner-user-id owner-email orphan-only unused-only]}
+ {:keys [term visibility-type data-layer data-source owner-user-id owner-email orphan-only unused-only
+ can-query can-write]}
:- [:map
[:term {:optional true} :string]
[:visibility-type {:optional true} :string]
@@ -78,7 +83,9 @@
[:owner-user-id {:optional true} [:maybe :int]]
[:owner-email {:optional true} :string]
[:orphan-only {:optional true} [:maybe ms/BooleanValue]]
- [:unused-only {:optional true} [:maybe ms/BooleanValue]]]]
+ [:unused-only {:optional true} [:maybe ms/BooleanValue]]
+ [:can-query {:optional true} [:maybe ms/BooleanValue]]
+ [:can-write {:optional true} [:maybe ms/BooleanValue]]]]
(let [like (fn [field pattern]
(case (app-db/db-type)
(:h2 :postgres) [:ilike field pattern]
@@ -113,6 +120,8 @@
(as-> (t2/select :model/Table query) tables
(apply t2/hydrate tables hydrations)
(into [] (comp (filter mi/can-read?)
+ (if can-query (filter mi/can-query?) identity)
+ (if can-write (filter mi/can-write?) identity)
(map schema.table/present-table))
tables))))
@@ -150,7 +159,7 @@
[{:keys [table-id]} :- [:map [:table-id ms/PositiveInt]]]
(let [table (t2/select-one :model/Table :id table-id)
db-id (:db_id table)]
- (api/read-check table)
+ (api/query-check table)
(qp.store/with-metadata-provider db-id
(let [mp (qp.store/metadata-provider)
query (-> (lib/query mp (lib.metadata/table mp table-id))
diff --git a/src/metabase/warehouses/models/database.clj b/src/metabase/warehouses/models/database.clj
index 4eba736e07f..7519fc5c57b 100644
--- a/src/metabase/warehouses/models/database.clj
+++ b/src/metabase/warehouses/models/database.clj
@@ -92,18 +92,58 @@
(t2/select-one-fn :router_database_id :model/Database :id db-id))))
(defmethod mi/can-read? :model/Database
+ ;; Check if user can see this database's metadata.
+ ;; True if user has:
+ ;; - Query builder access (create-queries permission), OR
+ ;; - Metadata management permissions (manage-table-metadata or manage-database), OR
+ ;; - Access to a published table in this database (EE feature)
([instance]
(mi/can-read? :model/Database (u/the-id instance)))
([_model database-id]
(cond
(should-read-audit-db? database-id) false
(db-id->router-db-id database-id) (mi/can-read? :model/Database (db-id->router-db-id database-id))
- :else (or (contains? #{:query-builder :query-builder-and-native}
- (perms/most-permissive-database-permission-for-user
- api/*current-user-id*
- :perms/create-queries
- database-id))
- (perms/user-has-published-table-permission-for-database? database-id)))))
+ :else (or
+ ;; Has query builder access
+ (contains? #{:query-builder :query-builder-and-native}
+ (perms/most-permissive-database-permission-for-user
+ api/*current-user-id*
+ :perms/create-queries
+ database-id))
+ ;; Has manage-database permission
+ (perms/user-has-permission-for-database?
+ api/*current-user-id*
+ :perms/manage-database
+ :yes
+ database-id)
+ ;; Has manage-table-metadata permission for any table in the database
+ (= :yes (perms/most-permissive-database-permission-for-user
+ api/*current-user-id*
+ :perms/manage-table-metadata
+ database-id))
+ ;; Has published table access
+ (perms/user-has-published-table-permission-for-database? database-id)))))
+
+(defmethod mi/can-query? :model/Database
+ ;; Check if user can execute queries against this database.
+ ;; True if user has:
+ ;; - Query builder access (create-queries permission), OR
+ ;; - Access to a published table in this database (EE feature)
+ ([instance]
+ (mi/can-query? :model/Database (u/the-id instance)))
+ ([_model database-id]
+ (cond
+ (should-read-audit-db? database-id) false
+ (db-id->router-db-id database-id) (mi/can-query? :model/Database (db-id->router-db-id database-id))
+ :else (or
+ ;; Has query builder access
+ (contains? #{:query-builder :query-builder-and-native}
+ (perms/most-permissive-database-permission-for-user
+ api/*current-user-id*
+ :perms/create-queries
+ database-id))
+ ;; Has published table access
+ (perms/user-has-published-table-permission-for-database? database-id)))))
(defenterprise current-user-can-write-db?
"OSS implementation. Returns a boolean whether the current user can write the given field."
diff --git a/src/metabase/warehouses_rest/api.clj b/src/metabase/warehouses_rest/api.clj
index 8bcdd6d18ae..34f74c6b728 100644
--- a/src/metabase/warehouses_rest/api.clj
+++ b/src/metabase/warehouses_rest/api.clj
@@ -60,13 +60,20 @@
;;; ----------------------------------------------- GET /api/database ------------------------------------------------
-(defn- add-tables [dbs]
- (let [db-id->tables (group-by :db_id (filter mi/can-read? (t2/select :model/Table
- :active true
- :db_id [:in (map :id dbs)]
- :visibility_type nil
- {:order-by [[:%lower.schema :asc]
- [:%lower.display_name :asc]]})))]
+(defn- add-tables
+ "Hydrate tables for each database. Optional `can-query?` and `can-write-metadata?` filters
+ can be applied to filter tables by permission level."
+ [dbs & {:keys [can-query? can-write-metadata?]}]
+ (let [all-tables (t2/select :model/Table
+ :active true
+ :db_id [:in (map :id dbs)]
+ :visibility_type nil
+ {:order-by [[:%lower.schema :asc]
+ [:%lower.display_name :asc]]})
+ filtered-tables (cond->> (filter mi/can-read? all-tables)
+ can-query? (filter mi/can-query?)
+ can-write-metadata? (filter mi/can-write?))
+ db-id->tables (group-by :db_id filtered-tables)]
(for [db dbs]
(assoc db :tables (get db-id->tables (:id db) [])))))
@@ -258,7 +265,9 @@
include-analytics?
exclude-uneditable-details?
include-only-uploadable?
- router-database-id]}]
+ router-database-id
+ can-query?
+ can-write-metadata?]}]
(let [filter-on-router-database-id (when (some->> router-database-id
(perms/user-has-permission-for-database? api/*current-user-id* :perms/manage-database :yes))
router-database-id)
@@ -266,7 +275,6 @@
exclude-uneditable-details?
filter-on-router-database-id))
user-info {:user-id api/*current-user-id* :is-superuser? (mi/superuser?)}
- permission-mapping {:perms/create-queries :query-builder}
base-where [:and
(when-not include-analytics?
[:= :is_audit false])
@@ -274,12 +282,15 @@
[:= :router_database_id router-database-id]
[:= :router_database_id nil])]
where-clause (if filter-by-data-access?
- [:and base-where (:clause (mi/visible-filter-clause :model/Database :id user-info permission-mapping))]
+ [:and base-where [:or (:clause (mi/visible-filter-clause :model/Database :id user-info {:perms/create-queries :query-builder}))
+ (:clause (mi/visible-filter-clause :model/Database :id user-info {:perms/manage-database :yes}))
+ (:clause (mi/visible-filter-clause :model/Database :id user-info {:perms/manage-table-metadata :yes}))]]
base-where)
dbs (t2/select :model/Database {:order-by [:%lower.name :%lower.engine]
:where where-clause})]
(cond-> (add-native-perms-info dbs)
- include-tables? add-tables
+ include-tables? (add-tables :can-query? can-query? :can-write-metadata? can-write-metadata?)
+ can-query? (#(filter mi/can-query? %))
true add-can-upload-to-dbs
true (t2/hydrate :router_user_attribute)
include-editable-data-model? filter-databases-by-data-model-perms
@@ -312,13 +323,18 @@
* `include_only_uploadable` will only include DBs into which Metabase can insert new data.
+ * `can-query` will only include DBs for which the current user has query permissions. Default: `false`.
+
+ * `can-write-metadata` will only include DBs for which the current user has data model editing permissions
+ for at least one table in the database. Default: `false`.
+
Independently of these flags, the implementation of [[metabase.models.interface/to-json]] for `:model/Database` in
[[metabase.warehouses.models.database]] uses the implementation of [[metabase.models.interface/can-write?]] for
`:model/Database` in [[metabase.warehouses.models.database]] to exclude the `details` field, if the requesting user
lacks permission to change the database details."
[_route-params
{:keys [include saved include_editable_data_model exclude_uneditable_details include_only_uploadable include_analytics
- router_database_id]}
+ router_database_id can-query can-write-metadata]}
:- [:map
[:include {:optional true} (mu/with-api-error-message
[:maybe [:= "tables"]]
@@ -328,19 +344,29 @@
[:include_editable_data_model {:default false} [:maybe :boolean]]
[:exclude_uneditable_details {:default false} [:maybe :boolean]]
[:include_only_uploadable {:default false} [:maybe :boolean]]
- [:router_database_id {:optional true} [:maybe ms/PositiveInt]]]]
+ [:router_database_id {:optional true} [:maybe ms/PositiveInt]]
+ [:can-query {:optional true} [:maybe :boolean]]
+ [:can-write-metadata {:optional true} [:maybe :boolean]]]]
(let [include-tables? (= include "tables")
include-saved-questions-tables? (and saved include-tables?)
only-editable? (or include_only_uploadable exclude_uneditable_details)
- db-list-res (or (dbs-list :include-tables? include-tables?
- :include-saved-questions-db? saved
- :include-saved-questions-tables? include-saved-questions-tables?
- :include-editable-data-model? include_editable_data_model
- :exclude-uneditable-details? only-editable?
- :include-analytics? include_analytics
- :include-only-uploadable? include_only_uploadable
- :router-database-id router_database_id)
- [])]
+ has-table-metadata-perms? (fn [{db-id :id}]
+ (= :yes (perms/most-permissive-database-permission-for-user
+ api/*current-user-id*
+ :perms/manage-table-metadata
+ db-id)))
+ db-list-res (cond->> (or (dbs-list :include-tables? include-tables?
+ :include-saved-questions-db? saved
+ :include-saved-questions-tables? include-saved-questions-tables?
+ :include-editable-data-model? include_editable_data_model
+ :exclude-uneditable-details? only-editable?
+ :include-analytics? include_analytics
+ :include-only-uploadable? include_only_uploadable
+ :router-database-id router_database_id
+ :can-query? can-query
+ :can-write-metadata? can-write-metadata)
+ [])
+ can-write-metadata (filter has-table-metadata-perms?))]
{:data db-list-res
:total (count db-list-res)}))
@@ -1272,7 +1298,7 @@
(defn database-schemas
"Returns a list of all the schemas with tables found for the database `id`. Excludes schemas with no tables."
- [id {:keys [include-editable-data-model? include-hidden?]}]
+ [id {:keys [include-editable-data-model? include-hidden? can-query? can-write-metadata?]}]
(let [filter-schemas (fn [schemas]
(if include-editable-data-model?
(if-let [f (u/ignore-exceptions
@@ -1280,7 +1306,17 @@
(resolve 'metabase-enterprise.advanced-permissions.common/filter-schema-by-data-model-perms))]
(map :schema (f (map (fn [s] {:db_id id :schema s}) schemas)))
schemas)
- (filter (partial can-read-schema? id) schemas)))]
+ (filter (partial can-read-schema? id) schemas)))
+ ;; For can-query? and can-write-metadata?, we need to filter based on tables in each schema
+ filter-schemas-by-tables (fn [schemas]
+ (if (or can-query? can-write-metadata?)
+ (let [tables (t2/select :model/Table :db_id id :active true)
+ filtered-tables (cond->> tables
+ can-query? (filter mi/can-query?)
+ can-write-metadata? (filter mi/can-write?))
+ allowed-schemas (set (map :schema filtered-tables))]
+ (filter #(contains? allowed-schemas %) schemas))
+ schemas))]
(get-database id {:include-editable-data-model? include-editable-data-model?})
(->> (t2/select-fn-set :schema :model/Table
:db_id id :active true
@@ -1291,6 +1327,7 @@
;; see [[metabase.warehouse-schema.models.table/visibility-types]]
{:where [:= :visibility_type nil]})))
filter-schemas
+ filter-schemas-by-tables
;; for `nil` schemas return the empty string
(map #(if (nil? %) "" %))
distinct
@@ -1299,20 +1336,24 @@
;; TODO (Cam 10/28/25) -- fix this endpoint so it uses kebab-case for query parameters for consistency with the rest
;; of the REST API
;;
-;; TODO (Cam 2025-11-25) please add a response schema to this API endpoint, it makes it easier for our customers to
-;; use our API + we will need it when we make auto-TypeScript-signature generation happen
-;;
-#_{:clj-kondo/ignore [:metabase/validate-defendpoint-query-params-use-kebab-case
- :metabase/validate-defendpoint-has-response-schema]}
-(api.macros/defendpoint :get "/:id/schemas"
- "Returns a list of all the schemas with tables found for the database `id`. Excludes schemas with no tables."
+#_{:clj-kondo/ignore [:metabase/validate-defendpoint-query-params-use-kebab-case]}
+(api.macros/defendpoint :get "/:id/schemas" :- [:sequential :string]
+ "Returns a list of all the schemas with tables found for the database `id`. Excludes schemas with no tables.
+
+ Optional filters:
+ - `can-query=true` - filter to only schemas containing tables the user can query
+ - `can-write-metadata=true` - filter to only schemas containing tables the user can edit metadata for"
[{:keys [id]} :- [:map
[:id ms/PositiveInt]]
- {:keys [include_editable_data_model include_hidden]} :- [:map
- [:include_editable_data_model {:default false} [:maybe ms/BooleanValue]]
- [:include_hidden {:default false} [:maybe ms/BooleanValue]]]]
+ {:keys [include_editable_data_model include_hidden can-query can-write-metadata]} :- [:map
+ [:include_editable_data_model {:default false} [:maybe ms/BooleanValue]]
+ [:include_hidden {:default false} [:maybe ms/BooleanValue]]
+ [:can-query {:optional true} [:maybe :boolean]]
+ [:can-write-metadata {:optional true} [:maybe :boolean]]]]
(database-schemas id {:include-editable-data-model? include_editable_data_model
- :include-hidden? include_hidden}))
+ :include-hidden? include_hidden
+ :can-query? can-query
+ :can-write-metadata? can-write-metadata}))
;; TODO (Cam 2025-11-25) please add a response schema to this API endpoint, it makes it easier for our customers to
;; use our API + we will need it when we make auto-TypeScript-signature generation happen
@@ -1346,12 +1387,12 @@
(defn- schema-tables-list
([db-id schema]
- (schema-tables-list db-id schema nil nil))
- ([db-id schema include_hidden include_editable_data_model]
- (when-not include_editable_data_model
+ (schema-tables-list db-id schema {}))
+ ([db-id schema {:keys [include-hidden? include-editable-data-model? can-query? can-write-metadata?]}]
+ (when-not include-editable-data-model?
(api/read-check :model/Database db-id)
(api/check-403 (can-read-schema? db-id schema)))
- (let [candidate-tables (if include_hidden
+ (let [candidate-tables (if include-hidden?
(t2/select :model/Table
:db_id db-id
:schema schema
@@ -1363,13 +1404,15 @@
:active true
:visibility_type nil
{:order-by [[:display_name :asc]]}))
- filtered-tables (if include_editable_data_model
- (if-let [f (when config/ee-available?
- (classloader/require 'metabase-enterprise.advanced-permissions.common)
- (resolve 'metabase-enterprise.advanced-permissions.common/filter-tables-by-data-model-perms))]
- (f candidate-tables)
- candidate-tables)
- (filter mi/can-read? candidate-tables))
+ filtered-tables (cond->> (if include-editable-data-model?
+ (if-let [f (when config/ee-available?
+ (classloader/require 'metabase-enterprise.advanced-permissions.common)
+ (resolve 'metabase-enterprise.advanced-permissions.common/filter-tables-by-data-model-perms))]
+ (f candidate-tables)
+ candidate-tables)
+ (filter mi/can-read? candidate-tables))
+ can-query? (filter mi/can-query?)
+ can-write-metadata? (filter mi/can-write?))
hydration-keys (cond-> []
(premium-features/has-feature? :transforms) (conj :transform))]
(if (seq hydration-keys)
@@ -1385,18 +1428,26 @@
#_{:clj-kondo/ignore [:metabase/validate-defendpoint-query-params-use-kebab-case
:metabase/validate-defendpoint-has-response-schema]}
(api.macros/defendpoint :get "/:id/schema/:schema"
- "Returns a list of Tables for the given Database `id` and `schema`"
+ "Returns a list of Tables for the given Database `id` and `schema`.
+
+ Optional filters:
+ - `can-query=true` - filter to only tables the user can query
+ - `can-write-metadata=true` - filter to only tables the user can edit metadata for"
[{:keys [id schema]} :- [:map
[:id ms/PositiveInt]
[:schema ms/NonBlankString]]
- {:keys [include_hidden include_editable_data_model]} :- [:map
- [:include_hidden {:default false} [:maybe ms/BooleanValue]]
- [:include_editable_data_model {:default false} [:maybe ms/BooleanValue]]]]
+ {:keys [include_hidden include_editable_data_model can-query can-write-metadata]} :- [:map
+ [:include_hidden {:default false} [:maybe ms/BooleanValue]]
+ [:include_editable_data_model {:default false} [:maybe ms/BooleanValue]]
+ [:can-query {:optional true} [:maybe :boolean]]
+ [:can-write-metadata {:optional true} [:maybe :boolean]]]]
(api/check-404 (seq (schema-tables-list
id
schema
- include_hidden
- include_editable_data_model))))
+ {:include-hidden? include_hidden
+ :include-editable-data-model? include_editable_data_model
+ :can-query? can-query
+ :can-write-metadata? can-write-metadata}))))
;; TODO (Cam 10/28/25) -- fix this endpoint so it uses kebab-case for query parameters for consistency with the rest
;; of the REST API
@@ -1407,14 +1458,24 @@
#_{:clj-kondo/ignore [:metabase/validate-defendpoint-query-params-use-kebab-case
:metabase/validate-defendpoint-has-response-schema]}
(api.macros/defendpoint :get "/:id/schema/"
- "Return a list of Tables for a Database whose `schema` is `nil` or an empty string."
+ "Return a list of Tables for a Database whose `schema` is `nil` or an empty string.
+
+ Optional filters:
+ - `can-query=true` - filter to only tables the user can query
+ - `can-write-metadata=true` - filter to only tables the user can edit metadata for"
[{:keys [id]} :- [:map
[:id ms/PositiveInt]]
- {:keys [include_hidden include_editable_data_model]} :- [:map
- [:include_hidden {:default false} [:maybe ms/BooleanValue]]
- [:include_editable_data_model {:default false} [:maybe ms/BooleanValue]]]]
- (api/check-404 (seq (concat (schema-tables-list id nil include_hidden include_editable_data_model)
- (schema-tables-list id "" include_hidden include_editable_data_model)))))
+ {:keys [include_hidden include_editable_data_model can-query can-write-metadata]} :- [:map
+ [:include_hidden {:default false} [:maybe ms/BooleanValue]]
+ [:include_editable_data_model {:default false} [:maybe ms/BooleanValue]]
+ [:can-query {:optional true} [:maybe :boolean]]
+ [:can-write-metadata {:optional true} [:maybe :boolean]]]]
+ (let [opts {:include-hidden? include_hidden
+ :include-editable-data-model? include_editable_data_model
+ :can-query? can-query
+ :can-write-metadata? can-write-metadata}]
+ (api/check-404 (seq (concat (schema-tables-list id nil opts)
+ (schema-tables-list id "" opts))))))
;; TODO (Cam 2025-11-25) please add a response schema to this API endpoint, it makes it easier for our customers to
;; use our API + we will need it when we make auto-TypeScript-signature generation happen
diff --git a/test/metabase/api/common_test.clj b/test/metabase/api/common_test.clj
index 3051dbbf118..0267b6bf05e 100644
--- a/test/metabase/api/common_test.clj
+++ b/test/metabase/api/common_test.clj
@@ -137,6 +137,26 @@
(underive :event/update-permission-failure ::permission-failure-event)
(underive :event/create-permission-failure ::permission-failure-event))))
+;;; ---------------------------------------- query-check tests ----------------------------------------
+
+(deftest query-check-returns-object-when-user-has-query-permissions-test
+ (testing "query-check returns object when user has query permissions"
+ (mt/with-temp [:model/Card card {}]
+ (with-redefs [mi/can-query? (constantly true)]
+ (is (= card (api/query-check card)))))))
+
+(deftest query-check-throws-403-when-user-lacks-query-permissions-test
+ (testing "query-check throws 403 when user lacks query permissions"
+ (mt/with-temp [:model/Card card {}]
+ (with-redefs [mi/can-query? (constantly false)]
+ (is (thrown-with-msg? ExceptionInfo #"permissions"
+ (api/query-check card)))))))
+
+(deftest query-check-throws-404-for-nil-object-test
+ (testing "query-check throws 404 for nil object"
+ (is (thrown-with-msg? ExceptionInfo #"Not found"
+ (api/query-check nil)))))
+
(deftest present-items-works
(testing "order is preserved"
(is (= [{:id 1 :model :foo} {:id 2 :model :foo} {:id 3 :model :foo}]
diff --git a/test/metabase/models/interface_test.clj b/test/metabase/models/interface_test.clj
index 6fe1bdcdc53..fb2aa394a64 100644
--- a/test/metabase/models/interface_test.clj
+++ b/test/metabase/models/interface_test.clj
@@ -219,3 +219,21 @@
(is (= cols
(#'mi/result-metadata-out (json/encode cols))))))
+
+;;; ---------------------------------------- can-query? tests ----------------------------------------
+
+(deftest can-query?-default-falls-back-to-can-read?-test
+ (testing "Default implementation falls back to can-read?"
+ ;; Use Card model which uses the default can-query? implementation
+ (mt/with-temp [:model/Card card {}]
+ (with-redefs [mi/can-read? (constantly true)]
+ (is (true? (mi/can-query? card))))
+ (with-redefs [mi/can-read? (constantly false)]
+ (is (false? (mi/can-query? card)))))))
+
+(deftest can-query-hydration-returns-boolean-test
+ (testing ":can_query hydration returns a boolean value"
+ (mt/with-temp [:model/Card card {}]
+ (let [hydrated (t2/hydrate card :can_query)]
+ (is (contains? hydrated :can_query))
+ (is (boolean? (:can_query hydrated)))))))
diff --git a/test/metabase/warehouse_schema/models/field_test.clj b/test/metabase/warehouse_schema/models/field_test.clj
index 1a451ca731f..b6caea0a42d 100644
--- a/test/metabase/warehouse_schema/models/field_test.clj
+++ b/test/metabase/warehouse_schema/models/field_test.clj
@@ -2,7 +2,10 @@
"Tests for specific behavior related to the Field model."
(:require
[clojure.test :refer :all]
+ [metabase.models.interface :as mi]
[metabase.models.serialization :as serdes]
+ [metabase.permissions.core :as perms]
+ [metabase.permissions.models.data-permissions :as data-perms]
[metabase.test :as mt]
[metabase.util :as u]
[metabase.warehouse-schema.models.field :as field]
@@ -95,3 +98,58 @@
(is (= "913269d5"
(serdes/raw-hash ["child" (serdes/identity-hash table) (serdes/identity-hash parent2)])
(serdes/identity-hash child2))))))
+
+;;; ---------------------------------------- Field permission delegation tests ----------------------------------------
+
+(deftest field-can-read?-delegates-to-parent-table-denied-test
+ (testing "Field can-read? delegates to parent table"
+ (mt/with-temp [:model/Database {db-id :id} {}
+ :model/Table {table-id :id} {:db_id db-id}
+ :model/Field {field-id :id} {:table_id table-id :name "test_field" :base_type :type/Integer}
+ :model/PermissionsGroup pg {}]
+ (perms/add-user-to-group! (mt/user->id :rasta) pg)
+ (t2/delete! :model/DataPermissions :db_id db-id)
+ ;; Start with blocked permissions
+ (data-perms/set-database-permission! pg db-id :perms/view-data :blocked)
+ (data-perms/set-database-permission! pg db-id :perms/create-queries :no)
+ (mt/with-test-user :rasta
+ (is (not (mi/can-read? (t2/select-one :model/Field field-id)))))
+ ;; Grant view-data permission - field should still not be readable
+ (data-perms/set-table-permission! pg table-id :perms/view-data :unrestricted)
+ (mt/with-test-user :rasta
+ (is (false? (boolean (mi/can-read? (t2/select-one :model/Field field-id)))))))))
+
+(deftest field-can-read?-delegates-to-parent-table-allowed-test
+ (testing "Field can-read? delegates to parent table"
+ (mt/with-temp [:model/Database {db-id :id} {}
+ :model/Table {table-id :id} {:db_id db-id}
+ :model/Field {field-id :id} {:table_id table-id :name "test_field" :base_type :type/Integer}
+ :model/PermissionsGroup pg {}]
+ (perms/add-user-to-group! (mt/user->id :rasta) pg)
+ (t2/delete! :model/DataPermissions :db_id db-id)
+ ;; Start with blocked permissions
+ (data-perms/set-database-permission! pg db-id :perms/view-data :blocked)
+ (data-perms/set-database-permission! pg db-id :perms/create-queries :no)
+ (mt/with-test-user :rasta
+ (is (not (mi/can-read? (t2/select-one :model/Field field-id)))))
+ ;; Grant view-data permission - now field should be readable
+ (data-perms/set-table-permission! pg table-id :perms/view-data :unrestricted)
+ (data-perms/set-table-permission! pg table-id :perms/create-queries :query-builder)
+ (mt/with-test-user :rasta
+ (is (true? (mi/can-read? (t2/select-one :model/Field field-id))))))))
+
+(deftest field-can-query?-delegates-to-parent-table-test
+ (testing "Field can-query? delegates to parent table"
+ (mt/with-temp [:model/Database {db-id :id} {}
+ :model/Table {table-id :id} {:db_id db-id}
+ :model/Field {field-id :id} {:table_id table-id :name "test_field" :base_type :type/Integer}
+ :model/PermissionsGroup pg {}]
+ (perms/add-user-to-group! (mt/user->id :rasta) pg)
+ (t2/delete! :model/DataPermissions :db_id db-id)
+ (data-perms/set-database-permission! pg db-id :perms/view-data :blocked)
+ (data-perms/set-database-permission! pg db-id :perms/create-queries :no)
+ ;; Grant both view-data and create-queries permissions to the table
+ (data-perms/set-table-permission! pg table-id :perms/view-data :unrestricted)
+ (data-perms/set-table-permission! pg table-id :perms/create-queries :query-builder)
+ (mt/with-test-user :rasta
+ (is (true? (mi/can-query? (t2/select-one :model/Field field-id))))))))
diff --git a/test/metabase/warehouse_schema/models/table_test.clj b/test/metabase/warehouse_schema/models/table_test.clj
index 8f2badd053a..1552e25bea9 100644
--- a/test/metabase/warehouse_schema/models/table_test.clj
+++ b/test/metabase/warehouse_schema/models/table_test.clj
@@ -562,3 +562,105 @@
(is (= coll1-id (-> hydrated first :collection :id)))
(is (= coll2-id (-> hydrated second :collection :id)))
(is (nil? (-> hydrated (nth 2) :collection)))))))
+
+;;; ---------------------------------------- can-read? permission tests ----------------------------------------
+
+(deftest table-can-read?-with-view-data-and-create-queries-permission-test
+ (testing "User with view-data and create-queries permission can read table"
+ (mt/with-temp [:model/Database {db-id :id} {}
+ :model/Table {table-id :id} {:db_id db-id}
+ :model/PermissionsGroup pg {}]
+ (perms/add-user-to-group! (mt/user->id :rasta) pg)
+ (t2/delete! :model/DataPermissions :db_id db-id)
+ (data-perms/set-database-permission! pg db-id :perms/view-data :blocked)
+ (data-perms/set-database-permission! pg db-id :perms/create-queries :query-builder)
+ (data-perms/set-table-permission! pg table-id :perms/view-data :unrestricted)
+ (mt/with-test-user :rasta
+ (is (true? (mi/can-read? (t2/select-one :model/Table table-id))))))))
+
+(deftest table-can-read?-with-view-data-permission-test
+ (testing "User with view-data and create-queries permission can read table"
+ (mt/with-temp [:model/Database {db-id :id} {}
+ :model/Table {table-id :id} {:db_id db-id}
+ :model/PermissionsGroup pg {}]
+ (perms/add-user-to-group! (mt/user->id :rasta) pg)
+ (t2/delete! :model/DataPermissions :db_id db-id)
+ (data-perms/set-database-permission! pg db-id :perms/view-data :blocked)
+ (data-perms/set-database-permission! pg db-id :perms/create-queries :no)
+ (data-perms/set-table-permission! pg table-id :perms/view-data :unrestricted)
+ (mt/with-test-user :rasta
+ (is (false? (boolean (mi/can-read? (t2/select-one :model/Table table-id)))))))))
+
+(deftest table-can-read?-with-manage-table-metadata-permission-test
+ (testing "User with manage-table-metadata permission can read table"
+ (mt/with-temp [:model/Database {db-id :id} {}
+ :model/Table {table-id :id} {:db_id db-id}
+ :model/PermissionsGroup pg {}]
+ (perms/add-user-to-group! (mt/user->id :rasta) pg)
+ (t2/delete! :model/DataPermissions :db_id db-id)
+ (data-perms/set-database-permission! pg db-id :perms/view-data :blocked)
+ (data-perms/set-database-permission! pg db-id :perms/create-queries :no)
+ (data-perms/set-table-permission! pg table-id :perms/manage-table-metadata :yes)
+ (mt/with-test-user :rasta
+ (is (true? (mi/can-read? (t2/select-one :model/Table table-id))))))))
+
+(deftest table-can-read?-without-permissions-test
+ (testing "User with neither permission cannot read table"
+ (mt/with-temp [:model/Database {db-id :id} {}
+ :model/Table {table-id :id} {:db_id db-id}
+ :model/PermissionsGroup pg {}]
+ (perms/add-user-to-group! (mt/user->id :rasta) pg)
+ (t2/delete! :model/DataPermissions :db_id db-id)
+ (data-perms/set-database-permission! pg db-id :perms/view-data :blocked)
+ (data-perms/set-database-permission! pg db-id :perms/create-queries :no)
+ (mt/with-test-user :rasta
+ (is (false? (mi/can-read? (t2/select-one :model/Table table-id))))))))
+
+;;; ---------------------------------------- can-query? permission tests ----------------------------------------
+
+(deftest table-can-query?-requires-both-view-data-and-create-queries-test
+ (testing "User needs BOTH view-data AND create-queries to query"
+ (mt/with-temp [:model/Database {db-id :id} {}
+ :model/Table {table-id :id} {:db_id db-id}
+ :model/PermissionsGroup pg {}]
+ (perms/add-user-to-group! (mt/user->id :rasta) pg)
+ (t2/delete! :model/DataPermissions :db_id db-id)
+ (data-perms/set-database-permission! pg db-id :perms/view-data :blocked)
+ (data-perms/set-database-permission! pg db-id :perms/create-queries :no)
+ ;; Only view-data - not enough
+ (data-perms/set-table-permission! pg table-id :perms/view-data :unrestricted)
+ (mt/with-test-user :rasta
+ (is (false? (mi/can-query? (t2/select-one :model/Table table-id)))))
+ ;; Add create-queries - now can query
+ (data-perms/set-table-permission! pg table-id :perms/create-queries :query-builder)
+ (mt/with-test-user :rasta
+ (is (true? (mi/can-query? (t2/select-one :model/Table table-id))))))))
+
+(deftest table-can-query?-manage-table-metadata-does-not-grant-query-access-test
+ (testing "manage-table-metadata alone does NOT grant query access"
+ (mt/with-temp [:model/Database {db-id :id} {}
+ :model/Table {table-id :id} {:db_id db-id}
+ :model/PermissionsGroup pg {}]
+ (perms/add-user-to-group! (mt/user->id :rasta) pg)
+ (t2/delete! :model/DataPermissions :db_id db-id)
+ (data-perms/set-database-permission! pg db-id :perms/view-data :blocked)
+ (data-perms/set-database-permission! pg db-id :perms/create-queries :no)
+ (data-perms/set-table-permission! pg table-id :perms/manage-table-metadata :yes)
+ (mt/with-test-user :rasta
+ (is (false? (mi/can-query? (t2/select-one :model/Table table-id))))))))
+
+;;; ---------------------------------------- can_query hydration test ----------------------------------------
+
+(deftest table-can-query-hydration-test
+ (testing ":can_query hydration works for tables"
+ (mt/with-temp [:model/Database {db-id :id} {}
+ :model/Table table {:db_id db-id}
+ :model/PermissionsGroup pg {}]
+ (perms/add-user-to-group! (mt/user->id :rasta) pg)
+ (t2/delete! :model/DataPermissions :db_id db-id)
+ (data-perms/set-database-permission! pg db-id :perms/view-data :unrestricted)
+ (data-perms/set-database-permission! pg db-id :perms/create-queries :query-builder)
+ (mt/with-test-user :rasta
+ (let [hydrated (t2/hydrate table :can_query)]
+ (is (contains? hydrated :can_query))
+ (is (boolean? (:can_query hydrated))))))))
diff --git a/test/metabase/warehouse_schema_rest/api/field_test.clj b/test/metabase/warehouse_schema_rest/api/field_test.clj
index e1869f904e1..bbe57115976 100644
--- a/test/metabase/warehouse_schema_rest/api/field_test.clj
+++ b/test/metabase/warehouse_schema_rest/api/field_test.clj
@@ -6,6 +6,7 @@
[metabase.driver :as driver]
[metabase.driver.mysql :as mysql]
[metabase.driver.util :as driver.u]
+ [metabase.permissions.models.data-permissions :as data-perms]
[metabase.sync.core :as sync]
[metabase.test :as mt]
[metabase.test.fixtures :as fixtures]
@@ -882,3 +883,21 @@
(is (= :Coercion/UNIXSeconds->DateTime (:coercion_strategy field)))
(is (isa? (:effective_type field) :type/DateTime))
(is (= "minutes" (-> field :settings :time_enabled)))))))
+
+(deftest field-values-requires-query-permission-test
+ (testing "GET /api/field/:id/values requires query permission (view-data + create-queries)"
+ (mt/with-temp-copy-of-db
+ (t2/update! :model/Field (mt/id :venues :price) {:has_field_values "list"})
+ (testing "User with only view-data permission (no create-queries) cannot access field values"
+ (mt/with-no-data-perms-for-all-users!
+ (is (= "You don't have permissions to do that."
+ (mt/user-http-request :rasta :get 403 (format "field/%d/values" (mt/id :venues :price)))))))
+ (testing "User with both view-data and create-queries can access field values"
+ (mt/with-temp [:model/PermissionsGroup {pg-id :id :as pg} {}
+ :model/PermissionsGroupMembership _ {:user_id (mt/user->id :rasta)
+ :group_id pg-id}]
+ (mt/with-no-data-perms-for-all-users!
+ (data-perms/set-database-permission! pg (mt/id) :perms/view-data :unrestricted)
+ (data-perms/set-database-permission! pg (mt/id) :perms/create-queries :query-builder)
+ (is (= {:values [[1] [2] [3] [4]], :field_id (mt/id :venues :price), :has_more_values false}
+ (mt/user-http-request :rasta :get 200 (format "field/%d/values" (mt/id :venues :price)))))))))))
diff --git a/test/metabase/warehouse_schema_rest/api/table_test.clj b/test/metabase/warehouse_schema_rest/api/table_test.clj
index f6f1fb4b7e3..7642b12b5b5 100644
--- a/test/metabase/warehouse_schema_rest/api/table_test.clj
+++ b/test/metabase/warehouse_schema_rest/api/table_test.clj
@@ -242,150 +242,152 @@
(table-defaults))
(deftest ^:parallel sensitive-fields-included-test
- (testing "GET api/table/:id/query_metadata?include_sensitive_fields"
- (testing "Sensitive fields are included"
- (is (= (merge
- (query-metadata-defaults)
- (t2/hydrate (t2/select-one [:model/Table :created_at :updated_at :initial_sync_status :view_count]
- :id (mt/id :users))
- :collection)
- {:schema "PUBLIC"
- :name "USERS"
- :display_name "Users"
- :entity_type "entity/UserTable"
- :fields [(assoc (field-details (t2/select-one :model/Field :id (mt/id :users :id)))
- :semantic_type "type/PK"
- :table_id (mt/id :users)
- :name "ID"
- :display_name "ID"
- :database_type "BIGINT"
- :base_type "type/BigInteger"
- :effective_type "type/BigInteger"
- :visibility_type "normal"
- :has_field_values "none"
- :database_required false
+ (mt/with-premium-features #{}
+ (testing "GET api/table/:id/query_metadata?include_sensitive_fields"
+ (testing "Sensitive fields are included"
+ (is (= (merge
+ (query-metadata-defaults)
+ (t2/hydrate (t2/select-one [:model/Table :created_at :updated_at :initial_sync_status :view_count]
+ :id (mt/id :users))
+ :collection)
+ {:schema "PUBLIC"
+ :name "USERS"
+ :display_name "Users"
+ :entity_type "entity/UserTable"
+ :fields [(assoc (field-details (t2/select-one :model/Field :id (mt/id :users :id)))
+ :semantic_type "type/PK"
+ :table_id (mt/id :users)
+ :name "ID"
+ :display_name "ID"
+ :database_type "BIGINT"
+ :base_type "type/BigInteger"
+ :effective_type "type/BigInteger"
+ :visibility_type "normal"
+ :has_field_values "none"
+ :database_required false
;; Index sync is turned off across the application as it is not used ATM.
- #_#_:database_indexed true
- :database_is_auto_increment true
- :name_field {:base_type "type/Text",
- :display_name "Name",
- :fk_target_field_id nil,
- :has_field_values "list",
- :id (mt/id :users :name),
- :name "NAME",
- :semantic_type "type/Name",
- :table_id (mt/id :users)})
- (assoc (field-details (t2/select-one :model/Field :id (mt/id :users :name)))
- :semantic_type "type/Name"
- :table_id (mt/id :users)
- :name "NAME"
- :display_name "Name"
- :database_type "CHARACTER VARYING"
- :base_type "type/Text"
- :effective_type "type/Text"
- :visibility_type "normal"
- :has_field_values "list"
- :position 1
- :database_position 1
- :database_required false
- :database_is_auto_increment false
- :name_field nil)
- (assoc (field-details (t2/select-one :model/Field :id (mt/id :users :last_login)))
- :table_id (mt/id :users)
- :name "LAST_LOGIN"
- :display_name "Last Login"
- :database_type "TIMESTAMP"
- :base_type "type/DateTime"
- :effective_type "type/DateTime"
- :visibility_type "normal"
- :has_field_values "none"
- :position 2
- :database_position 2
- :database_required false
- :database_is_auto_increment false
- :name_field nil)
- (assoc (field-details (t2/select-one :model/Field :table_id (mt/id :users), :name "PASSWORD"))
- :semantic_type "type/Category"
- :table_id (mt/id :users)
- :name "PASSWORD"
- :display_name "Password"
- :database_type "CHARACTER VARYING"
- :base_type "type/Text"
- :effective_type "type/Text"
- :visibility_type "sensitive"
- :has_field_values "list"
- :position 3
- :database_position 3
- :database_required false
- :database_is_auto_increment false
- :name_field nil)]
- :id (mt/id :users)})
- (mt/user-http-request :rasta :get 200 (format "table/%d/query_metadata?include_sensitive_fields=true" (mt/id :users))))
- "Make sure that getting the User table *does* include info about the password field, but not actual values themselves"))))
+ #_#_:database_indexed true
+ :database_is_auto_increment true
+ :name_field {:base_type "type/Text",
+ :display_name "Name",
+ :fk_target_field_id nil,
+ :has_field_values "list",
+ :id (mt/id :users :name),
+ :name "NAME",
+ :semantic_type "type/Name",
+ :table_id (mt/id :users)})
+ (assoc (field-details (t2/select-one :model/Field :id (mt/id :users :name)))
+ :semantic_type "type/Name"
+ :table_id (mt/id :users)
+ :name "NAME"
+ :display_name "Name"
+ :database_type "CHARACTER VARYING"
+ :base_type "type/Text"
+ :effective_type "type/Text"
+ :visibility_type "normal"
+ :has_field_values "list"
+ :position 1
+ :database_position 1
+ :database_required false
+ :database_is_auto_increment false
+ :name_field nil)
+ (assoc (field-details (t2/select-one :model/Field :id (mt/id :users :last_login)))
+ :table_id (mt/id :users)
+ :name "LAST_LOGIN"
+ :display_name "Last Login"
+ :database_type "TIMESTAMP"
+ :base_type "type/DateTime"
+ :effective_type "type/DateTime"
+ :visibility_type "normal"
+ :has_field_values "none"
+ :position 2
+ :database_position 2
+ :database_required false
+ :database_is_auto_increment false
+ :name_field nil)
+ (assoc (field-details (t2/select-one :model/Field :table_id (mt/id :users), :name "PASSWORD"))
+ :semantic_type "type/Category"
+ :table_id (mt/id :users)
+ :name "PASSWORD"
+ :display_name "Password"
+ :database_type "CHARACTER VARYING"
+ :base_type "type/Text"
+ :effective_type "type/Text"
+ :visibility_type "sensitive"
+ :has_field_values "list"
+ :position 3
+ :database_position 3
+ :database_required false
+ :database_is_auto_increment false
+ :name_field nil)]
+ :id (mt/id :users)})
+ (mt/user-http-request :rasta :get 200 (format "table/%d/query_metadata?include_sensitive_fields=true" (mt/id :users))))
+ "Make sure that getting the User table *does* include info about the password field, but not actual values themselves")))))
(deftest ^:parallel sensitive-fields-not-included-test
- (testing "GET api/table/:id/query_metadata"
- (testing "Sensitive fields should not be included"
- (is (= (merge
- (query-metadata-defaults)
- (t2/hydrate (t2/select-one [:model/Table :created_at :updated_at :initial_sync_status :view_count]
- :id (mt/id :users))
- :collection)
- {:schema "PUBLIC"
- :name "USERS"
- :display_name "Users"
- :entity_type "entity/UserTable"
- :fields [(assoc (field-details (t2/select-one :model/Field :id (mt/id :users :id)))
- :table_id (mt/id :users)
- :semantic_type "type/PK"
- :name "ID"
- :display_name "ID"
- :database_type "BIGINT"
- :base_type "type/BigInteger"
- :effective_type "type/BigInteger"
- :has_field_values "none"
+ (mt/with-premium-features #{}
+ (testing "GET api/table/:id/query_metadata"
+ (testing "Sensitive fields should not be included"
+ (is (= (merge
+ (query-metadata-defaults)
+ (t2/hydrate (t2/select-one [:model/Table :created_at :updated_at :initial_sync_status :view_count]
+ :id (mt/id :users))
+ :collection)
+ {:schema "PUBLIC"
+ :name "USERS"
+ :display_name "Users"
+ :entity_type "entity/UserTable"
+ :fields [(assoc (field-details (t2/select-one :model/Field :id (mt/id :users :id)))
+ :table_id (mt/id :users)
+ :semantic_type "type/PK"
+ :name "ID"
+ :display_name "ID"
+ :database_type "BIGINT"
+ :base_type "type/BigInteger"
+ :effective_type "type/BigInteger"
+ :has_field_values "none"
;; Index sync is turned off across the application as it is not used ATM.
- #_#_:database_indexed true
- :database_required false
- :database_is_auto_increment true
- :name_field {:base_type "type/Text",
- :display_name "Name",
- :fk_target_field_id nil,
- :has_field_values "list",
- :id (mt/id :users :name),
- :name "NAME",
- :semantic_type "type/Name",
- :table_id (mt/id :users)})
- (assoc (field-details (t2/select-one :model/Field :id (mt/id :users :name)))
- :table_id (mt/id :users)
- :semantic_type "type/Name"
- :name "NAME"
- :display_name "Name"
- :database_type "CHARACTER VARYING"
- :base_type "type/Text"
- :effective_type "type/Text"
- :has_field_values "list"
- :position 1
- :database_position 1
- :database_required false
- :database_is_auto_increment false
- :name_field nil)
- (assoc (field-details (t2/select-one :model/Field :id (mt/id :users :last_login)))
- :table_id (mt/id :users)
- :name "LAST_LOGIN"
- :display_name "Last Login"
- :database_type "TIMESTAMP"
- :base_type "type/DateTime"
- :effective_type "type/DateTime"
- :has_field_values "none"
- :position 2
- :database_position 2
- :database_required false
- :database_is_auto_increment false
- :name_field nil)]
- :id (mt/id :users)})
- (mt/user-http-request :rasta :get 200 (format "table/%d/query_metadata" (mt/id :users))))
- "Make sure that getting the User table does *not* include password info"))))
+ #_#_:database_indexed true
+ :database_required false
+ :database_is_auto_increment true
+ :name_field {:base_type "type/Text",
+ :display_name "Name",
+ :fk_target_field_id nil,
+ :has_field_values "list",
+ :id (mt/id :users :name),
+ :name "NAME",
+ :semantic_type "type/Name",
+ :table_id (mt/id :users)})
+ (assoc (field-details (t2/select-one :model/Field :id (mt/id :users :name)))
+ :table_id (mt/id :users)
+ :semantic_type "type/Name"
+ :name "NAME"
+ :display_name "Name"
+ :database_type "CHARACTER VARYING"
+ :base_type "type/Text"
+ :effective_type "type/Text"
+ :has_field_values "list"
+ :position 1
+ :database_position 1
+ :database_required false
+ :database_is_auto_increment false
+ :name_field nil)
+ (assoc (field-details (t2/select-one :model/Field :id (mt/id :users :last_login)))
+ :table_id (mt/id :users)
+ :name "LAST_LOGIN"
+ :display_name "Last Login"
+ :database_type "TIMESTAMP"
+ :base_type "type/DateTime"
+ :effective_type "type/DateTime"
+ :has_field_values "none"
+ :position 2
+ :database_position 2
+ :database_required false
+ :database_is_auto_increment false
+ :name_field nil)]
+ :id (mt/id :users)})
+ (mt/user-http-request :rasta :get 200 (format "table/%d/query_metadata" (mt/id :users))))
+ "Make sure that getting the User table does *not* include password info")))))
(deftest fk-target-permissions-test
(testing "GET /api/table/:id/query_metadata"
@@ -399,7 +401,7 @@
:model/Field _table-2-id {:table_id (u/the-id table-2), :name "id", :base_type :type/Integer, :semantic_type :type/PK}
:model/Field _table-2-fk {:table_id (u/the-id table-2), :name "fk", :base_type :type/Integer, :semantic_type :type/FK, :fk_target_field_id (u/the-id table-1-id)}]
(mt/with-no-data-perms-for-all-users!
- ;; grant permissions only to table-2
+ ;; grant create-queries to table-2 only
(data-perms/set-table-permission! (perms-group/all-users) table-2 :perms/create-queries :query-builder)
(data-perms/set-database-permission! (perms-group/all-users) db :perms/view-data :unrestricted)
;; metadata for table-2 should show all fields for table-2, but the FK target info shouldn't be hydrated
@@ -646,53 +648,54 @@
(mt/user-http-request :crowberto :get 200 "table/card__1000/fks"))))))
(deftest ^:parallel basic-query-metadata-test
- (testing "GET /api/table/:id/query_metadata"
- (is (= (merge
- (query-metadata-defaults)
- (t2/hydrate (t2/select-one [:model/Table :created_at :updated_at :initial_sync_status] :id (mt/id :categories))
- :collection)
- {:schema "PUBLIC"
- :name "CATEGORIES"
- :display_name "Categories"
- :fields [(merge
- (field-details (t2/select-one :model/Field :id (mt/id :categories :id)))
- {:table_id (mt/id :categories)
- :semantic_type "type/PK"
- :name "ID"
- :display_name "ID"
- :database_type "BIGINT"
- :base_type "type/BigInteger"
- :effective_type "type/BigInteger"
- :has_field_values "none"
- :database_required false
+ (mt/with-premium-features #{}
+ (testing "GET /api/table/:id/query_metadata"
+ (is (= (merge
+ (query-metadata-defaults)
+ (t2/hydrate (t2/select-one [:model/Table :created_at :updated_at :initial_sync_status] :id (mt/id :categories))
+ :collection)
+ {:schema "PUBLIC"
+ :name "CATEGORIES"
+ :display_name "Categories"
+ :fields [(merge
+ (field-details (t2/select-one :model/Field :id (mt/id :categories :id)))
+ {:table_id (mt/id :categories)
+ :semantic_type "type/PK"
+ :name "ID"
+ :display_name "ID"
+ :database_type "BIGINT"
+ :base_type "type/BigInteger"
+ :effective_type "type/BigInteger"
+ :has_field_values "none"
+ :database_required false
;; Index sync is turned off across the application as it is not used ATM.
- #_#_:database_indexed true
- :database_is_auto_increment true
- :name_field {:base_type "type/Text",
- :display_name "Name",
- :fk_target_field_id nil,
- :has_field_values "list",
- :id (mt/id :categories :name),
- :name "NAME",
- :semantic_type "type/Name",
- :table_id (mt/id :categories)}})
- (merge
- (field-details (t2/select-one :model/Field :id (mt/id :categories :name)))
- {:table_id (mt/id :categories)
- :semantic_type "type/Name"
- :name "NAME"
- :display_name "Name"
- :database_type "CHARACTER VARYING"
- :base_type "type/Text"
- :effective_type "type/Text"
- :has_field_values "list"
- :database_position 1
- :position 1
- :database_required true
- :database_is_auto_increment false
- :name_field nil})]
- :id (mt/id :categories)})
- (mt/user-http-request :rasta :get 200 (format "table/%d/query_metadata" (mt/id :categories)))))))
+ #_#_:database_indexed true
+ :database_is_auto_increment true
+ :name_field {:base_type "type/Text",
+ :display_name "Name",
+ :fk_target_field_id nil,
+ :has_field_values "list",
+ :id (mt/id :categories :name),
+ :name "NAME",
+ :semantic_type "type/Name",
+ :table_id (mt/id :categories)}})
+ (merge
+ (field-details (t2/select-one :model/Field :id (mt/id :categories :name)))
+ {:table_id (mt/id :categories)
+ :semantic_type "type/Name"
+ :name "NAME"
+ :display_name "Name"
+ :database_type "CHARACTER VARYING"
+ :base_type "type/Text"
+ :effective_type "type/Text"
+ :has_field_values "list"
+ :database_position 1
+ :position 1
+ :database_required true
+ :database_is_auto_increment false
+ :name_field nil})]
+ :id (mt/id :categories)})
+ (mt/user-http-request :rasta :get 200 (format "table/%d/query_metadata" (mt/id :categories))))))))
(deftest ^:parallel table-metric-query-metadata-test
(testing "GET /api/table/:id/query_metadata"
@@ -1366,3 +1369,71 @@
(sync/sync-database! db {:scan :schema})
(is (= () (mt/user-http-request :rasta :get 200 (format "table/%d/fks" (mt/id :continent)))))))))
+
+;;; ---------------------------------------- can-query and can-write filter tests ----------------------------------------
+
+(deftest list-tables-can-query-filter-returns-only-queryable-tables-test
+ (testing "can-query=true filters to only queryable tables"
+ (mt/with-temp [:model/Database {db-id :id} {}
+ :model/Table {table-1-id :id} {:db_id db-id :name "queryable_table" :active true}
+ :model/Table {table-2-id :id} {:db_id db-id :name "not_queryable_table" :active true}
+ :model/PermissionsGroup {pg-id :id :as pg} {}
+ :model/PermissionsGroupMembership _ {:user_id (mt/user->id :rasta) :group_id pg-id}]
+ (t2/delete! :model/DataPermissions :db_id db-id)
+ ;; Block database-level access
+ (data-perms/set-database-permission! pg db-id :perms/view-data :blocked)
+ (data-perms/set-database-permission! pg db-id :perms/create-queries :no)
+ ;; Grant both view-data and create-queries to table-1 (queryable)
+ (data-perms/set-table-permission! pg table-1-id :perms/view-data :unrestricted)
+ (data-perms/set-table-permission! pg table-1-id :perms/create-queries :query-builder)
+ ;; Grant only view-data to table-2 (not queryable)
+ (data-perms/set-table-permission! pg table-2-id :perms/view-data :unrestricted)
+
+ (let [response (->> (mt/user-http-request :rasta :get 200 "table" :can-query true)
+ (filter #(= (:db_id %) db-id)))]
+ (is (= 1 (count response)))
+ (is (= "queryable_table" (-> response first :name)))))))
+
+(deftest list-tables-can-write-filter-returns-only-editable-tables-test
+ (testing "can-write=true filters to only editable tables"
+ (mt/with-temp [:model/Database {db-id :id} {}
+ :model/Table {table-1-id :id} {:db_id db-id :name "editable_table" :active true}
+ :model/Table _ {:db_id db-id :name "not_editable_table" :active true}
+ :model/PermissionsGroup {pg-id :id :as pg} {}
+ :model/PermissionsGroupMembership _ {:user_id (mt/user->id :crowberto) :group_id pg-id}]
+ (t2/delete! :model/DataPermissions :db_id db-id)
+ ;; Block database-level access
+ (data-perms/set-database-permission! pg db-id :perms/view-data :unrestricted)
+ (data-perms/set-database-permission! pg db-id :perms/create-queries :query-builder)
+ ;; Grant manage-table-metadata to table-1 only (editable)
+ (data-perms/set-table-permission! pg table-1-id :perms/manage-table-metadata :yes)
+ ;; table-2 gets no manage-table-metadata (not editable)
+
+ (let [response (->> (mt/user-http-request :crowberto :get 200 "table" :can-write true)
+ (filter #(= (:db_id %) db-id)))]
+ ;; crowberto is an admin, so should see all tables when they have manage-table-metadata
+ (is (>= (count response) 1))
+ (is (contains? (set (map :name response)) "editable_table"))))))
+
+;;; ---------------------------------------- /data endpoint permission tests ----------------------------------------
+
+(deftest get-table-data-endpoint-denies-when-cannot-query-test
+ (testing "GET /api/table/:id/data returns 403 when user cannot query the table"
+ (mt/dataset test-data
+ (let [table-id (mt/id :orders)]
+ (mt/with-no-data-perms-for-all-users!
+ ;; Grant view-data but NOT create-queries (so can-query is false)
+ (data-perms/set-database-permission! (perms-group/all-users) (mt/id) :perms/view-data :unrestricted)
+ (is (= "You don't have permissions to do that."
+ (mt/user-http-request :rasta :get 403 (format "table/%d/data" table-id)))))))))
+
+(deftest get-table-data-endpoint-allows-when-can-query-test
+ (testing "GET /api/table/:id/data returns 202 when user can query the table"
+ (mt/dataset test-data
+ (let [table-id (mt/id :orders)]
+ (mt/with-no-data-perms-for-all-users!
+ ;; Grant both view-data and create-queries (so can-query is true)
+ (data-perms/set-database-permission! (perms-group/all-users) (mt/id) :perms/view-data :unrestricted)
+ (data-perms/set-table-permission! (perms-group/all-users) table-id :perms/create-queries :query-builder)
+ (let [response (mt/user-http-request :rasta :get 202 (format "table/%d/data" table-id))]
+ (is (map? response))))))))
diff --git a/test/metabase/warehouses/models/database_test.clj b/test/metabase/warehouses/models/database_test.clj
index 44034658745..dbae0438322 100644
--- a/test/metabase/warehouses/models/database_test.clj
+++ b/test/metabase/warehouses/models/database_test.clj
@@ -848,3 +848,73 @@
default-permission-mapping
:id)
db-id))))))
+
+;;; ---------------------------------------- can-read? permission tests ----------------------------------------
+
+(deftest database-can-read?-with-create-queries-permission-test
+ (testing "User with create-queries permission can read database"
+ (mt/with-temp [:model/Database {db-id :id} {}
+ :model/Table _ {:db_id db-id :name "Table1"}
+ :model/PermissionsGroup pg {}]
+ (perms/add-user-to-group! (mt/user->id :rasta) pg)
+ (t2/delete! :model/DataPermissions :db_id db-id)
+ (data-perms/set-database-permission! pg db-id :perms/view-data :unrestricted)
+ (data-perms/set-database-permission! pg db-id :perms/create-queries :query-builder)
+ (mt/with-test-user :rasta
+ (is (true? (mi/can-read? :model/Database db-id)))))))
+
+(deftest database-can-read?-with-manage-database-permission-test
+ (testing "User with manage-database permission can read database"
+ (mt/with-temp [:model/Database {db-id :id} {}
+ :model/Table _ {:db_id db-id :name "Table1"}
+ :model/PermissionsGroup pg {}]
+ (perms/add-user-to-group! (mt/user->id :rasta) pg)
+ (t2/delete! :model/DataPermissions :db_id db-id)
+ (data-perms/set-database-permission! pg db-id :perms/view-data :blocked)
+ (data-perms/set-database-permission! pg db-id :perms/create-queries :no)
+ (data-perms/set-database-permission! pg db-id :perms/manage-database :yes)
+ (mt/with-test-user :rasta
+ (is (true? (mi/can-read? :model/Database db-id)))))))
+
+(deftest database-can-read?-with-manage-table-metadata-on-any-table-test
+ (testing "User with manage-table-metadata on any table can read database"
+ (mt/with-temp [:model/Database {db-id :id} {}
+ :model/Table {table-id :id} {:db_id db-id :name "Table1"}
+ :model/PermissionsGroup pg {}]
+ (perms/add-user-to-group! (mt/user->id :rasta) pg)
+ (t2/delete! :model/DataPermissions :db_id db-id)
+ (data-perms/set-database-permission! pg db-id :perms/view-data :blocked)
+ (data-perms/set-database-permission! pg db-id :perms/create-queries :no)
+ (data-perms/set-table-permission! pg table-id :perms/manage-table-metadata :yes)
+ (mt/with-test-user :rasta
+ (is (true? (mi/can-read? :model/Database db-id)))))))
+
+;;; ---------------------------------------- can-query? permission tests ----------------------------------------
+
+(deftest database-can-query?-requires-create-queries-permission-test
+ (testing "User needs create-queries to query database"
+ (mt/with-temp [:model/Database {db-id :id} {}
+ :model/Table _ {:db_id db-id :name "Table1"}
+ :model/PermissionsGroup pg {}]
+ (perms/add-user-to-group! (mt/user->id :rasta) pg)
+ (t2/delete! :model/DataPermissions :db_id db-id)
+ (data-perms/set-database-permission! pg db-id :perms/view-data :unrestricted)
+ (data-perms/set-database-permission! pg db-id :perms/create-queries :no)
+ (mt/with-test-user :rasta
+ (is (false? (mi/can-query? :model/Database db-id))))
+ (data-perms/set-database-permission! pg db-id :perms/create-queries :query-builder)
+ (mt/with-test-user :rasta
+ (is (true? (mi/can-query? :model/Database db-id)))))))
+
+(deftest database-can-query?-manage-database-does-not-grant-query-access-test
+ (testing "manage-database alone does NOT grant query access"
+ (mt/with-temp [:model/Database {db-id :id} {}
+ :model/Table _ {:db_id db-id :name "Table1"}
+ :model/PermissionsGroup pg {}]
+ (perms/add-user-to-group! (mt/user->id :rasta) pg)
+ (t2/delete! :model/DataPermissions :db_id db-id)
+ (data-perms/set-database-permission! pg db-id :perms/view-data :blocked)
+ (data-perms/set-database-permission! pg db-id :perms/create-queries :no)
+ (data-perms/set-database-permission! pg db-id :perms/manage-database :yes)
+ (mt/with-test-user :rasta
+ (is (false? (mi/can-query? :model/Database db-id)))))))
diff --git a/test/metabase/warehouses_rest/api_test.clj b/test/metabase/warehouses_rest/api_test.clj
index 43cf2865cd5..57da6fc0ca6 100644
--- a/test/metabase/warehouses_rest/api_test.clj
+++ b/test/metabase/warehouses_rest/api_test.clj
@@ -1742,13 +1742,14 @@
(is (= "You don't have permissions to do that."
(mt/user-http-request :rasta :get 403 (format "database/%s/schemas" db-id))))))
- (testing "should return a 403 if there are no perms for any schema"
+ (testing "returns empty list when user has no create-queries perms for any schema"
(mt/with-full-data-perms-for-all-users!
(data-perms/set-database-permission! (perms-group/all-users) db-id :perms/view-data :unrestricted)
(data-perms/set-table-permission! (perms-group/all-users) (u/the-id t1) :perms/create-queries :no)
(data-perms/set-table-permission! (perms-group/all-users) (u/the-id t2) :perms/create-queries :no)
- (is (= "You don't have permissions to do that."
- (mt/user-http-request :rasta :get 403 (format "database/%s/schemas" db-id)))))))
+ ;; User can access the endpoint but sees no schemas since they have no query perms
+ (is (= []
+ (mt/user-http-request :rasta :get 200 (format "database/%s/schemas" db-id)))))))
(testing "should exclude schemas for which the user has no perms"
(mt/with-temp [:model/Database {database-id :id} {}
@@ -2450,3 +2451,91 @@
:api-test-disabled-for-database
:api-test-disabled-for-custom-reasons
:api-test-disabled-for-multiple-reasons])))))))))
+
+;;; +----------------------------------------------------------------------------------------------------------------+
+;;; | can-query filter tests |
+;;; +----------------------------------------------------------------------------------------------------------------+
+;; Note: can-write-metadata tests are in metabase-enterprise.advanced-permissions.common-test since they require
+;; enterprise features (:perms/manage-table-metadata permission)
+
+(deftest list-databases-can-query-filter-test
+ (testing "GET /api/database with can-query=true filters to only queryable databases"
+ (mt/with-temp [:model/Database {db-1-id :id} {:name "Queryable DB"}
+ :model/Database {db-2-id :id} {:name "Not Queryable DB"}
+ :model/Table _ {:db_id db-1-id :name "table1" :active true}
+ :model/Table _ {:db_id db-2-id :name "table2" :active true}
+ :model/PermissionsGroup {pg-id :id :as pg} {}
+ :model/PermissionsGroupMembership _ {:user_id (mt/user->id :rasta) :group_id pg-id}]
+ (t2/delete! :model/DataPermissions :db_id db-1-id)
+ (t2/delete! :model/DataPermissions :db_id db-2-id)
+ ;; Grant full permissions to db-1 (queryable)
+ (data-perms/set-database-permission! pg db-1-id :perms/view-data :unrestricted)
+ (data-perms/set-database-permission! pg db-1-id :perms/create-queries :query-builder)
+ ;; Grant only view-data to db-2 (not queryable)
+ (data-perms/set-database-permission! pg db-2-id :perms/view-data :unrestricted)
+
+ (let [response (->> (mt/user-http-request :rasta :get 200 "database" :can-query true)
+ :data
+ (filter #(#{db-1-id db-2-id} (:id %))))]
+ (is (= 1 (count response)))
+ (is (= "Queryable DB" (-> response first :name)))))))
+
+(deftest list-schemas-can-query-filter-test
+ (testing "GET /api/database/:id/schemas with can-query=true filters to only schemas with queryable tables"
+ (mt/with-temp [:model/Database {db-id :id} {}
+ :model/Table t1 {:db_id db-id :schema "queryable_schema" :name "t1" :active true}
+ :model/Table _ {:db_id db-id :schema "not_queryable_schema" :name "t2" :active true}]
+ (mt/with-no-data-perms-for-all-users!
+ ;; Grant view-data at database level (required for accessing the endpoint)
+ (data-perms/set-database-permission! (perms-group/all-users) db-id :perms/view-data :unrestricted)
+ ;; Grant create-queries only to t1 (queryable)
+ (data-perms/set-table-permission! (perms-group/all-users) t1 :perms/create-queries :query-builder)
+
+ (let [response (mt/user-http-request :rasta :get 200 (format "database/%d/schemas" db-id) :can-query true)]
+ (is (= ["queryable_schema"] response)))))))
+
+(deftest list-schema-tables-can-query-filter-test
+ (testing "GET /api/database/:id/schema/:schema with can-query=true filters to only queryable tables"
+ (mt/with-temp [:model/Database {db-id :id} {}
+ :model/Table t1 {:db_id db-id :schema "test_schema" :name "queryable_table" :active true}
+ :model/Table _ {:db_id db-id :schema "test_schema" :name "not_queryable_table" :active true}]
+ (mt/with-no-data-perms-for-all-users!
+ ;; Grant view-data at database level (required for accessing the endpoint)
+ (data-perms/set-database-permission! (perms-group/all-users) db-id :perms/view-data :unrestricted)
+ ;; Grant create-queries only to t1 (queryable)
+ (data-perms/set-table-permission! (perms-group/all-users) t1 :perms/create-queries :query-builder)
+
+ (let [response (mt/user-http-request :rasta :get 200 (format "database/%d/schema/%s" db-id "test_schema") :can-query true)]
+ (is (= 1 (count response)))
+ (is (= "queryable_table" (-> response first :name))))))))
+
+(deftest list-databases-includes-manage-permissions-test
+ (testing "GET /api/database includes databases where user has manage-database permission (details :yes)"
+ (mt/with-temp [:model/Database {db-1-id :id} {:name "Query DB"}
+ :model/Database {db-2-id :id} {:name "Manage DB"}
+ :model/Database {db-3-id :id} {:name "No Access DB"}
+ :model/Table _ {:db_id db-1-id :name "table1" :active true}
+ :model/Table _ {:db_id db-2-id :name "table2" :active true}
+ :model/Table _ {:db_id db-3-id :name "table3" :active true}
+ :model/PermissionsGroup {pg-id :id :as pg} {}
+ :model/PermissionsGroupMembership _ {:user_id (mt/user->id :rasta) :group_id pg-id}]
+ (t2/delete! :model/DataPermissions :db_id db-1-id)
+ (t2/delete! :model/DataPermissions :db_id db-2-id)
+ (t2/delete! :model/DataPermissions :db_id db-3-id)
+ ;; Grant query permissions to db-1 (queryable)
+ (data-perms/set-database-permission! pg db-1-id :perms/view-data :unrestricted)
+ (data-perms/set-database-permission! pg db-1-id :perms/create-queries :query-builder)
+ ;; Grant only manage-database (details) permission to db-2 (no query access)
+ (data-perms/set-database-permission! pg db-2-id :perms/manage-database :yes)
+ ;; No permissions for db-3
+
+ (let [response (->> (mt/user-http-request :rasta :get 200 "database")
+ :data
+ (filter #(#{db-1-id db-2-id db-3-id} (:id %)))
+ (map :name)
+ set)]
+ (testing "Both query-accessible and manage-accessible databases should be included"
+ (is (contains? response "Query DB"))
+ (is (contains? response "Manage DB")))
+ (testing "Database with no permissions should not be included"
+ (is (not (contains? response "No Access DB"))))))))