feat: add optional columns property to resource data request schema and implement column validation in AdminForthRestAPI

NoOne7135 · NoOne7135 · commit ea758cbdcc3e · 2026-05-06T13:00:06.000+03:00
diff --git a/adminforth/dataConnectors/baseConnector.ts b/adminforth/dataConnectors/baseConnector.ts
@@ -261,12 +261,13 @@ export default class AdminForthBaseConnector implements IAdminForthDataSourceCon
     }
   }
 
-  getDataWithOriginalTypes({ resource, limit, offset, sort, filters }: {
+  getDataWithOriginalTypes({ resource, limit, offset, sort, filters, columns }: {
     resource: AdminForthResource,
     limit: number,
     offset: number,
     sort: IAdminForthSort[],
     filters: IAdminForthAndOrFilter,
+    columns?: AdminForthResourceColumn[],
   }): Promise<any[]> {
     throw new Error('Method not implemented.');
   }
@@ -595,13 +596,14 @@ export default class AdminForthBaseConnector implements IAdminForthDataSourceCon
     throw new Error('Method not implemented.');
   }
 
-  async getData({ resource, limit, offset, sort, filters, getTotals }: { 
+  async getData({ resource, limit, offset, sort, filters, getTotals, columns }: { 
     resource: AdminForthResource, 
     limit: number, 
     offset: number, 
     sort: { field: string, direction: AdminForthSortDirections }[], 
     filters: IAdminForthAndOrFilter,
     getTotals: boolean,
+    columns?: AdminForthResourceColumn[],
   }): Promise<{ data: any[], total: number }> {
     let normalizedFilters = filters;
 
@@ -613,7 +615,8 @@ export default class AdminForthBaseConnector implements IAdminForthDataSourceCon
       normalizedFilters = filterValidation.normalizedFilters as IAdminForthAndOrFilter;
     }
 
-    const promises: Promise<any>[] = [this.getDataWithOriginalTypes({ resource, limit, offset, sort, filters: normalizedFilters })];
+    const dataSourceColumns = columns ?? resource.dataSourceColumns;
+    const promises: Promise<any>[] = [this.getDataWithOriginalTypes({ resource, limit, offset, sort, filters: normalizedFilters, columns: dataSourceColumns })];
     if (getTotals) {
       promises.push(this.getCount({ resource, filters }));
     } else {
@@ -624,7 +627,7 @@ export default class AdminForthBaseConnector implements IAdminForthDataSourceCon
 
     // call getFieldValue for each field
     data.map((record) => {
-      for (const col of resource.dataSourceColumns) {
+      for (const col of dataSourceColumns) {
         record[col.name] = this.getFieldValue(col, record[col.name]);
       }
     });
diff --git a/adminforth/dataConnectors/clickhouse.ts b/adminforth/dataConnectors/clickhouse.ts
@@ -510,14 +510,15 @@ class ClickhouseConnector extends AdminForthBaseConnector implements IAdminForth
       }));
     }
 
-    async getDataWithOriginalTypes({ resource, limit, offset, sort, filters }: { 
+    async getDataWithOriginalTypes({ resource, limit, offset, sort, filters, columns }: { 
         resource: AdminForthResource, 
         limit: number, 
         offset: number, 
         sort: { field: string, direction: AdminForthSortDirections }[], 
         filters: IAdminForthAndOrFilter,
+        columns?: AdminForthResourceColumn[],
     }): Promise<Array<{ group?: string, [key: string]: any }>> {
-      const columns = resource.dataSourceColumns.map((col) => {
+      const selectedColumns = (columns ?? resource.dataSourceColumns).map((col) => {
         // for decimal cast to string
         if (col.type == AdminForthDataTypes.DECIMAL) {
           return `toString(${col.name}) as ${col.name}`
@@ -532,7 +533,7 @@ class ClickhouseConnector extends AdminForthBaseConnector implements IAdminForth
       const orderBy = sort.length ? `ORDER BY ${sort.map((s) => `${s.field} ${this.SortDirectionsMap[s.direction]}`).join(', ')}` : '';
       
 
-      const q = `SELECT ${columns} FROM ${tableName} ${where} ${orderBy} LIMIT {limit:Int} OFFSET {offset:Int}`;
+      const q = `SELECT ${selectedColumns} FROM ${tableName} ${where} ${orderBy} LIMIT {limit:Int} OFFSET {offset:Int}`;
       const d = {
         ...params,
         limit,
diff --git a/adminforth/dataConnectors/mongo.ts b/adminforth/dataConnectors/mongo.ts
@@ -408,13 +408,14 @@ class MongoConnector extends AdminForthBaseConnector implements IAdminForthDataS
         });
     }
     
-    async getDataWithOriginalTypes({ resource, limit, offset, sort, filters }:
+    async getDataWithOriginalTypes({ resource, limit, offset, sort, filters, columns }:
         { 
             resource: AdminForthResource, 
             limit: number, 
             offset: number, 
             sort: { field: string, direction: AdminForthSortDirections }[], 
             filters: IAdminForthAndOrFilter,
+            columns?: Array<{ name: string }>,
         }
     ): Promise<any[]> {
 
@@ -429,7 +430,11 @@ class MongoConnector extends AdminForthBaseConnector implements IAdminForthDataS
             return [s.field, this.SortDirectionsMap[s.direction]];
         });
 
-        const result = await collection.find(query)
+        const projection = columns
+            ? Object.fromEntries(columns.map((col) => [col.name, 1]))
+            : undefined;
+
+        const result = await collection.find(query, projection ? { projection } : undefined)
             .sort(sortArray)
             .skip(offset)
             .limit(limit)
diff --git a/adminforth/dataConnectors/mysql.ts b/adminforth/dataConnectors/mysql.ts
@@ -453,14 +453,14 @@ class MysqlConnector extends AdminForthBaseConnector implements IAdminForthDataS
     return rows;
   }
 
-  async getDataWithOriginalTypes({ resource, limit, offset, sort, filters }): Promise<any[]> {
-    const columns = resource.dataSourceColumns.map((col: { name: string }) => `${col.name}`).join(', ');
+  async getDataWithOriginalTypes({ resource, limit, offset, sort, filters, columns }): Promise<any[]> {
+    const selectedColumns = (columns ?? resource.dataSourceColumns).map((col: { name: string }) => `${col.name}`).join(', ');
     const tableName = resource.table;
     
     const { sql: where, values: filterValues } = this.whereClauseAndValues(filters);
 
     const orderBy = sort.length ? `ORDER BY ${sort.map((s: { field: string; direction: AdminForthSortDirections }) => `${s.field} ${this.SortDirectionsMap[s.direction]}`).join(', ')}` : '';
-    let selectQuery = `SELECT ${columns} FROM ${tableName}`;
+    let selectQuery = `SELECT ${selectedColumns} FROM ${tableName}`;
     if (where) selectQuery += ` ${where}`;
     if (orderBy) selectQuery += ` ${orderBy}`;
     if (limit) selectQuery += ` LIMIT ${limit}`;
diff --git a/adminforth/dataConnectors/postgres.ts b/adminforth/dataConnectors/postgres.ts
@@ -428,16 +428,16 @@ class PostgresConnector extends AdminForthBaseConnector implements IAdminForthDa
         return stmt.rows;
     }
 
-    async getDataWithOriginalTypes({ resource, limit, offset, sort, filters }): Promise<any[]> {
-        const columns = resource.dataSourceColumns.map((col) => `"${col.name}"`).join(', ');
+    async getDataWithOriginalTypes({ resource, limit, offset, sort, filters, columns }): Promise<any[]> {
+        const selectedColumns = (columns ?? resource.dataSourceColumns).map((col) => `"${col.name}"`).join(', ');
         const tableName = resource.table;
 
         const { sql: where, paramsCount, values: filterValues } = this.whereClauseAndValues(resource, filters);
 
         const limitOffset = `LIMIT $${paramsCount} OFFSET $${paramsCount + 1}`;
         const d = [...filterValues, limit, offset];
         const orderBy = sort.length ? `ORDER BY ${sort.map((s) => `"${s.field}" ${this.SortDirectionsMap[s.direction]}`).join(', ')}` : '';
-        const selectQuery = `SELECT ${columns} FROM "${tableName}" ${where} ${orderBy} ${limitOffset}`;
+        const selectQuery = `SELECT ${selectedColumns} FROM "${tableName}" ${where} ${orderBy} ${limitOffset}`;
         dbLogger.trace(`🪲📜 PG Q: ${selectQuery}, params: ${JSON.stringify(d)}`);
         const stmt = await this.client.query(selectQuery, d);
         const rows = stmt.rows;
diff --git a/adminforth/dataConnectors/sqlite.ts b/adminforth/dataConnectors/sqlite.ts
@@ -430,8 +430,8 @@ class SQLiteConnector extends AdminForthBaseConnector implements IAdminForthData
       return results.sort((a, b) => a.group.localeCompare(b.group));
     }
 
-    async getDataWithOriginalTypes({ resource, limit, offset, sort, filters }): Promise<any[]> {
-      const columns = resource.dataSourceColumns.map((col) => col.name).join(', ');
+    async getDataWithOriginalTypes({ resource, limit, offset, sort, filters, columns }): Promise<any[]> {
+      const selectedColumns = (columns ?? resource.dataSourceColumns).map((col) => col.name).join(', ');
       const tableName = resource.table;
 
       const where = this.whereClause(filters);
@@ -440,7 +440,7 @@ class SQLiteConnector extends AdminForthBaseConnector implements IAdminForthData
 
       const orderBy = sort.length ? `ORDER BY ${sort.map((s) => `${s.field} ${this.SortDirectionsMap[s.direction]}`).join(', ')}` : '';
       
-      const q = `SELECT ${columns} FROM ${tableName} ${where} ${orderBy} LIMIT ? OFFSET ?`;
+      const q = `SELECT ${selectedColumns} FROM ${tableName} ${where} ${orderBy} LIMIT ? OFFSET ?`;
       const stmt = this.client.prepare(q);
       const d = [...filterValues, limit, offset];
 
diff --git a/adminforth/modules/restApi.ts b/adminforth/modules/restApi.ts
@@ -272,6 +272,13 @@ const getResourceDataRequestSchema: AnySchemaObject = {
     },
     sort: commonSortSchema,
     filters: commonFiltersSchema,
+    columns: {
+      type: 'array',
+      description: 'Optional list of resource column names to include in returned rows. Omit it to return all visible columns.',
+      minItems: 1,
+      uniqueItems: true,
+      items: { type: 'string' },
+    },
   },
   additionalProperties: true,
   allOf: [
@@ -1296,6 +1303,41 @@ export default class AdminForthRestAPI implements IAdminForthRestAPI {
           }
         }
         const { limit, offset, filters, sort } = body;
+        const selectedColumnNames = body.columns
+          ? [...new Set(body.columns as string[])]
+          : undefined;
+
+        if (selectedColumnNames) {
+          const resourceColumnNames = new Set(resource.columns.map((col) => col.name));
+          const invalidColumnName = selectedColumnNames.find((columnName) => !resourceColumnNames.has(columnName));
+
+          if (invalidColumnName) {
+            return { error: `Column ${invalidColumnName} not found in resource ${resourceId}` };
+          }
+        }
+        const selectedColumnNameSet = selectedColumnNames ? new Set(selectedColumnNames) : undefined;
+        const selectedDataSourceColumnNameSet = selectedColumnNames
+          ? new Set(selectedColumnNames.filter((columnName) => resource.dataSourceColumns.some((col) => col.name === columnName)))
+          : undefined;
+
+        if (selectedDataSourceColumnNameSet) {
+          for (const col of resource.columns) {
+            if (
+              selectedColumnNameSet.has(col.name) &&
+              col.foreignResource?.polymorphicOn
+            ) {
+              selectedDataSourceColumnNameSet.add(col.foreignResource.polymorphicOn);
+            }
+          }
+        }
+
+        const selectedDataSourceColumns = selectedDataSourceColumnNameSet
+          ? (
+              resource.dataSourceColumns.some((col) => selectedDataSourceColumnNameSet.has(col.name))
+                ? resource.dataSourceColumns.filter((col) => selectedDataSourceColumnNameSet.has(col.name))
+                : resource.dataSourceColumns.filter((col) => col.primaryKey || col.name === resource.dataSourceColumns[0]?.name)
+            )
+          : undefined;
 
         // remove virtual fields from sort if still presented after beforeDatasourceRequest hook
         const sortFiltered = sort.filter((sortItem: IAdminForthSort) => {
@@ -1334,11 +1376,14 @@ export default class AdminForthRestAPI implements IAdminForthRestAPI {
           filters: normalizedFilters as IAdminForthAndOrFilter,
           sort: sortFiltered,
           getTotals: source === 'list',
+          columns: selectedDataSourceColumns,
         });
 
         // for foreign keys, add references
         await Promise.all(
-          resource.columns.filter((col) => col.foreignResource).map(async (col) => {
+          resource.columns.filter((col) => (
+            col.foreignResource && (!selectedColumnNameSet || selectedColumnNameSet.has(col.name))
+          )).map(async (col) => {
             let targetDataMap = {};
 
             if (col.foreignResource.resourceId) {
@@ -1471,10 +1516,12 @@ export default class AdminForthRestAPI implements IAdminForthRestAPI {
                 delete item[key];
               }
             }
-            item._label = resource.recordLabel(item);
+            if (!selectedColumnNameSet) {
+              item._label = resource.recordLabel(item);
+            }
           }
         }
-        if (source === 'list' && resource.options.listTableClickUrl) {
+        if (!selectedColumnNameSet && source === 'list' && resource.options.listTableClickUrl) {
           await Promise.all(
             data.data.map(async (item) => {
                 item._clickUrl = await resource.options.listTableClickUrl(item, adminUser, resource);
@@ -1501,6 +1548,16 @@ export default class AdminForthRestAPI implements IAdminForthRestAPI {
           }
         }
 
+        if (selectedColumnNameSet) {
+          for (const item of data.data) {
+            for (const key of Object.keys(item)) {
+              if (!selectedColumnNameSet.has(key)) {
+                delete item[key];
+              }
+            }
+          }
+        }
+
         return data;
       },
     });
diff --git a/adminforth/types/Back.ts b/adminforth/types/Back.ts
@@ -334,12 +334,13 @@ export interface IAdminForthDataSourceConnector {
    * 
    * Fields are returned from db "as is" then {@link AdminForthBaseConnector.getData} will transform each field using {@link IAdminForthDataSourceConnector.getFieldValue}
    */
-  getDataWithOriginalTypes({ resource, limit, offset, sort, filters }: {
+  getDataWithOriginalTypes({ resource, limit, offset, sort, filters, columns }: {
     resource: AdminForthResource,
     limit: number,
     offset: number,
     sort: IAdminForthSort[], 
     filters: IAdminForthAndOrFilter,
+    columns?: AdminForthResourceColumn[],
   }): Promise<Array<any>>;
 
   /**
@@ -397,13 +398,14 @@ export interface IAdminForthDataSourceConnectorBase extends IAdminForthDataSourc
 
   getPrimaryKey(resource: AdminForthResource): string;
 
-  getData({ resource, limit, offset, sort, filters }: {
+  getData({ resource, limit, offset, sort, filters, columns }: {
     resource: AdminForthResource,
     limit: number,
     offset: number,
     sort: IAdminForthSort[],
     filters: IAdminForthAndOrFilter,
     getTotals?: boolean,
+    columns?: AdminForthResourceColumn[],
   }): Promise<{ data: Array<any>, total: number }>;
 
   getRecordByPrimaryKey(resource: AdminForthResource, recordId: string): Promise<any>;
