diff --git a/packages/orm/src/memory-db.ts b/packages/orm/src/memory-db.ts
index 872b056d4..809cc01dd 100644
--- a/packages/orm/src/memory-db.ts
+++ b/packages/orm/src/memory-db.ts
@@ -98,7 +98,7 @@ const find = <T extends OrmEntity>(adapter: MemoryDatabaseAdapter, classSchema:
     let filtered = model.filter ? findQueryList<T>(items, model.filter) : items;
 
     if (model.hasJoins()) {
-        throw new Error('MemoryDatabaseAdapter does not support joins. Please use another lightweight adapter like SQLite.');
+        console.log('MemoryDatabaseAdapter does not support joins. Please use another lightweight adapter like SQLite.');
     }
 
     if (model.sort) {
diff --git a/packages/orm/src/query.ts b/packages/orm/src/query.ts
index 32bf42ed3..7396cfb37 100644
--- a/packages/orm/src/query.ts
+++ b/packages/orm/src/query.ts
@@ -222,9 +222,11 @@ export class BaseQuery<T extends OrmEntity> {
      *
      * This allows to use more dynamic query composition functions.
      *
+     * To support joins queries `AnyQuery` is necessary as query type.
+     *
      * @example
      * ```typescript
-     * function joinFrontendData(query: Query<Product>) {
+     * function joinFrontendData(query: AnyQuery<Product>) {
      *     return query
      *         .useJoinWith('images').select('sort').end()
      *         .useJoinWith('brand').select('id', 'name', 'website').end()
@@ -232,13 +234,15 @@ export class BaseQuery<T extends OrmEntity> {
      *
      * const products = await database.query(Product).use(joinFrontendData).find();
      * ```
+     * @reflection never
      */
-    use<Q, R, A extends any[]>(modifier: (query: Q, ...args: A) => R, ...args: A): R {
-        return modifier(this as any, ...args);
+    use<Q, R, A extends any[]>(modifier: (query: Q, ...args: A) => R, ...args: A): this extends JoinDatabaseQuery<any, any> ? this : Exclude<R, JoinDatabaseQuery<any, any>> {
+        return modifier(this as any, ...args) as any;
     }
 
     /**
      * Same as `use`, but the method indicates it is terminating the query.
+     * @reflection never
      */
     fetch<Q, R>(modifier: (query: Q) => R): R {
         return modifier(this as any);
@@ -275,7 +279,7 @@ export class BaseQuery<T extends OrmEntity> {
     }
 
     withGroupConcat<K extends FieldName<T>, AS extends string>(field: K, as?: AS): Replace<this, Resolve<this> & { [C in [AS] as `${AS}`]: T[K][] }> {
-        return this.aggregateField(field, 'group_concat', as);
+        return this.aggregateField(field, 'group_concat', as) as any;
     }
 
     withCount<K extends FieldName<T>, AS extends string>(field: K, as?: AS): Replace<this, Resolve<this> & { [K in [AS] as `${AS}`]: number }> {
@@ -494,7 +498,7 @@ export class BaseQuery<T extends OrmEntity> {
     join<K extends keyof ReferenceFields<T>, ENTITY extends OrmEntity = FindEntity<T[K]>>(field: K, type: 'left' | 'inner' = 'left', populate: boolean = false): this {
         const propertySchema = this.classSchema.getProperty(field as string);
         if (!propertySchema.isReference() && !propertySchema.isBackReference()) {
-            throw new Error(`Field ${String(field)} is not marked as reference. Use @t.reference()`);
+            throw new Error(`Field ${String(field)} is not marked as reference. Use Reference type`);
         }
         const c = this.clone();
 
@@ -963,3 +967,5 @@ export class JoinDatabaseQuery<T extends OrmEntity, PARENT extends BaseQuery<any
         return this.parentQuery;
     }
 }
+
+export type AnyQuery<T extends OrmEntity> = JoinDatabaseQuery<T, any> | Query<T>;
diff --git a/packages/orm/tests/query.spec.ts b/packages/orm/tests/query.spec.ts
index ff6f78dee..f6a4f74fd 100644
--- a/packages/orm/tests/query.spec.ts
+++ b/packages/orm/tests/query.spec.ts
@@ -1,9 +1,9 @@
-import { BackReference, deserialize, PrimaryKey } from '@deepkit/type';
+import { BackReference, deserialize, PrimaryKey, Reference } from '@deepkit/type';
 import { expect, test } from '@jest/globals';
 import { assert, IsExact } from 'conditional-type-checks';
 import { Database } from '../src/database.js';
 import { MemoryDatabaseAdapter, MemoryQuery } from '../src/memory-db.js';
-import { Query } from '../src/query.js';
+import { AnyQuery, BaseQuery, Query } from '../src/query.js';
 import { OrmEntity } from '../src/type.js';
 
 test('query select', async () => {
@@ -70,10 +70,17 @@ test('query filter', async () => {
 });
 
 test('query lift', async () => {
+    class UserImage {
+        id!: number & PrimaryKey;
+        path!: string;
+        size!: number;
+    }
+
     class User {
         id!: number & PrimaryKey;
         username!: string;
         openBillings: number = 0;
+        image?: UserImage & Reference;
     }
 
     const database = new Database(new MemoryDatabaseAdapter());
@@ -108,11 +115,11 @@ test('query lift', async () => {
         }
     }
 
-    function filterBillingDue(q: Query<User>) {
+    function filterBillingDue(q: AnyQuery<User>) {
         return q.filterField('openBillings', { $gt: 0 });
     }
 
-    function filterMinBilling(q: Query<User>, min: number) {
+    function filterMinBilling(q: AnyQuery<User>, min: number) {
         return q.filterField('openBillings', { $gt: min });
     }
 
@@ -120,6 +127,10 @@ test('query lift', async () => {
         return q.findField('username');
     }
 
+    function filterImageSize(q: AnyQuery<UserImage>) {
+        return q.filterField('size', { $gt: 0 });
+    }
+
     class OverwriteHello<T extends OrmEntity> extends Query<T> {
         hello() {
             return 'nope';
@@ -144,12 +155,12 @@ test('query lift', async () => {
 
     {
         const items = await q.lift(UserQuery).find();
-        assert<IsExact<{ username: string, openBillings: number, id: number & PrimaryKey }[], typeof items>>(true);
+        assert<IsExact<{ username: string, openBillings: number, id: number & PrimaryKey, image?: UserImage & Reference }[], typeof items>>(true);
     }
 
     {
         const items = await q.lift(UserQuery).find();
-        assert<IsExact<{ username: string, openBillings: number, id: number & PrimaryKey }[], typeof items>>(true);
+        assert<IsExact<{ username: string, openBillings: number, id: number & PrimaryKey, image?: UserImage & Reference }[], typeof items>>(true);
     }
 
     {
@@ -159,7 +170,7 @@ test('query lift', async () => {
 
     {
         const items = await UserQuery.from(q).find();
-        assert<IsExact<{ username: string, openBillings: number, id: number & PrimaryKey }[], typeof items>>(true);
+        assert<IsExact<{ username: string, openBillings: number, id: number & PrimaryKey, image?: UserImage & Reference }[], typeof items>>(true);
     }
 
     {
@@ -228,6 +239,12 @@ test('query lift', async () => {
         expect(items).toEqual(['bar']);
         assert<IsExact<string[], typeof items>>(true);
     }
+
+    {
+        const items = await q.useJoinWith('image').use(filterImageSize).end().fetch(allUserNames);
+        expect(items).toEqual(['foo', 'bar']);
+        assert<IsExact<string[], typeof items>>(true);
+    }
 });