diff --git a/packages/datasource-toolkit/src/interfaces/query/projection/factory.ts b/packages/datasource-toolkit/src/interfaces/query/projection/factory.ts
index de4d5ccd93..d14832aeea 100644
--- a/packages/datasource-toolkit/src/interfaces/query/projection/factory.ts
+++ b/packages/datasource-toolkit/src/interfaces/query/projection/factory.ts
@@ -26,4 +26,12 @@ export default class ProjectionFactory {
 
     return new Projection(...projectionFields);
   }
+
+  static columns(collection: Collection): Projection {
+    return new Projection(
+      ...Object.keys(collection.schema.fields).filter(
+        f => collection.schema.fields[f].type === 'Column',
+      ),
+    );
+  }
 }
diff --git a/packages/datasource-toolkit/test/interfaces/projection-factory.test.ts b/packages/datasource-toolkit/test/interfaces/projection-factory.test.ts
index 1c5a4692f6..0bfa402bce 100644
--- a/packages/datasource-toolkit/test/interfaces/projection-factory.test.ts
+++ b/packages/datasource-toolkit/test/interfaces/projection-factory.test.ts
@@ -2,103 +2,115 @@ import * as factories from '../__factories__';
 import { Projection, ProjectionFactory } from '../../src';
 
 describe('ProjectionFactory', () => {
-  describe('all', () => {
-    describe('with one to one and many to one relations', () => {
-      const setupWithManyToOneAndOneToOneRelation = () => {
-        const dataSource = factories.dataSource.buildWithCollections([
-          factories.collection.build({
-            name: 'books',
-            schema: factories.collectionSchema.build({
-              fields: {
-                id: factories.columnSchema.isPrimaryKey().build(),
-                myAuthor: factories.oneToOneSchema.build({
-                  foreignCollection: 'authors',
-                  originKey: 'bookId',
-                }),
-                formatId: factories.columnSchema.build(),
-                myFormat: factories.manyToOneSchema.build({
-                  foreignCollection: 'formats',
-                  foreignKey: 'formatId',
-                }),
-                title: factories.columnSchema.build(),
-              },
-            }),
+  describe('with one to one and many to one relations', () => {
+    const setupWithManyToOneAndOneToOneRelation = () => {
+      const dataSource = factories.dataSource.buildWithCollections([
+        factories.collection.build({
+          name: 'books',
+          schema: factories.collectionSchema.build({
+            fields: {
+              id: factories.columnSchema.isPrimaryKey().build(),
+              myAuthor: factories.oneToOneSchema.build({
+                foreignCollection: 'authors',
+                originKey: 'bookId',
+              }),
+              formatId: factories.columnSchema.build(),
+              myFormat: factories.manyToOneSchema.build({
+                foreignCollection: 'formats',
+                foreignKey: 'formatId',
+              }),
+              title: factories.columnSchema.build(),
+            },
           }),
-          factories.collection.build({
-            name: 'authors',
-            schema: factories.collectionSchema.build({
-              fields: {
-                id: factories.columnSchema.isPrimaryKey().build(),
-                bookId: factories.columnSchema.build(),
-                name: factories.columnSchema.build(),
-              },
-            }),
+        }),
+        factories.collection.build({
+          name: 'authors',
+          schema: factories.collectionSchema.build({
+            fields: {
+              id: factories.columnSchema.isPrimaryKey().build(),
+              bookId: factories.columnSchema.build(),
+              name: factories.columnSchema.build(),
+            },
           }),
-          factories.collection.build({
-            name: 'formats',
-            schema: factories.collectionSchema.build({
-              fields: {
-                id: factories.columnSchema.isPrimaryKey().build(),
-                name: factories.columnSchema.build(),
-              },
-            }),
+        }),
+        factories.collection.build({
+          name: 'formats',
+          schema: factories.collectionSchema.build({
+            fields: {
+              id: factories.columnSchema.isPrimaryKey().build(),
+              name: factories.columnSchema.build(),
+            },
           }),
-        ]);
+        }),
+      ]);
 
-        return { collection: dataSource.getCollection('books') };
-      };
+      return { collection: dataSource.getCollection('books') };
+    };
 
-      it('should return all the collection fields and the relation fields', () => {
-        const { collection } = setupWithManyToOneAndOneToOneRelation();
+    it('columns() should return the columns', () => {
+      const { collection } = setupWithManyToOneAndOneToOneRelation();
 
-        expect(ProjectionFactory.all(collection)).toEqual(
-          new Projection(
-            'id',
-            'myAuthor:id',
-            'myAuthor:bookId',
-            'myAuthor:name',
-            'formatId',
-            'myFormat:id',
-            'myFormat:name',
-            'title',
-          ),
-        );
-      });
+      expect(ProjectionFactory.columns(collection)).toEqual(
+        new Projection('id', 'formatId', 'title'),
+      );
     });
 
-    describe('with other relation', () => {
-      const setupWithOneToManyRelation = () => {
-        const dataSource = factories.dataSource.buildWithCollections([
-          factories.collection.build({
-            name: 'bookPersons',
-            schema: factories.collectionSchema.build({
-              fields: {
-                id: factories.columnSchema.isPrimaryKey().build(),
-              },
-            }),
+    it('all() should return all the collection fields and the relation fields', () => {
+      const { collection } = setupWithManyToOneAndOneToOneRelation();
+
+      expect(ProjectionFactory.all(collection)).toEqual(
+        new Projection(
+          'id',
+          'myAuthor:id',
+          'myAuthor:bookId',
+          'myAuthor:name',
+          'formatId',
+          'myFormat:id',
+          'myFormat:name',
+          'title',
+        ),
+      );
+    });
+  });
+
+  describe('with other relation', () => {
+    const setupWithOneToManyRelation = () => {
+      const dataSource = factories.dataSource.buildWithCollections([
+        factories.collection.build({
+          name: 'bookPersons',
+          schema: factories.collectionSchema.build({
+            fields: {
+              id: factories.columnSchema.isPrimaryKey().build(),
+            },
           }),
-          factories.collection.build({
-            name: 'books',
-            schema: factories.collectionSchema.build({
-              fields: {
-                id: factories.columnSchema.isPrimaryKey().build(),
-                name: factories.columnSchema.build(),
-                myBookPersons: factories.oneToManySchema.build({
-                  foreignCollection: 'bookPersons',
-                }),
-              },
-            }),
+        }),
+        factories.collection.build({
+          name: 'books',
+          schema: factories.collectionSchema.build({
+            fields: {
+              id: factories.columnSchema.isPrimaryKey().build(),
+              name: factories.columnSchema.build(),
+              myBookPersons: factories.oneToManySchema.build({
+                foreignCollection: 'bookPersons',
+              }),
+            },
           }),
-        ]);
+        }),
+      ]);
 
-        return { collection: dataSource.getCollection('books') };
-      };
+      return { collection: dataSource.getCollection('books') };
+    };
+
+    it('columns() should return the columns', () => {
+      const { collection } = setupWithOneToManyRelation();
+
+      expect(ProjectionFactory.columns(collection)).toEqual(new Projection('id', 'name'));
+    });
 
-      it('should return all the collection fields without the relations', () => {
-        const { collection } = setupWithOneToManyRelation();
+    it('all() should return all the collection fields without the relations', () => {
+      const { collection } = setupWithOneToManyRelation();
 
-        expect(ProjectionFactory.all(collection)).toEqual(new Projection('id', 'name'));
-      });
+      expect(ProjectionFactory.all(collection)).toEqual(new Projection('id', 'name'));
     });
   });
 });