From c25871a080b3b1e360cf119ffc02e3298787bd55 Mon Sep 17 00:00:00 2001
From: Char2s <Char2s@outlook.com>
Date: Thu, 19 May 2022 00:53:00 +0800
Subject: [PATCH] feat(orm): exclude function fields from `FieldName` type

---
 packages/orm/src/utils.ts        | 28 +++++++++++++++++++++-------
 packages/orm/tests/query.spec.ts |  3 ++-
 2 files changed, 23 insertions(+), 8 deletions(-)

diff --git a/packages/orm/src/utils.ts b/packages/orm/src/utils.ts
index 6842ee353..4f65569b2 100644
--- a/packages/orm/src/utils.ts
+++ b/packages/orm/src/utils.ts
@@ -16,13 +16,19 @@ import { getInstanceStateFromItem } from './identity-map';
 import { getClassTypeFromInstance } from '@deepkit/core';
 
 export type FlattenIfArray<T> = T extends Array<any> ? T[0] : T;
-export type FieldName<T> = keyof T & string;
+export type FieldName<T> = {
+    [Key in keyof T & string]: T[Key] extends Function ? never : Key;
+}[keyof T & string];
 
-export function getClassSchemaInstancePairs<T extends OrmEntity>(items: Iterable<T>): Map<ReflectionClass<any>, T[]> {
+export function getClassSchemaInstancePairs<T extends OrmEntity>(
+    items: Iterable<T>
+): Map<ReflectionClass<any>, T[]> {
     const map = new Map<ReflectionClass<any>, T[]>();
 
     for (const item of items) {
-        const classSchema = ReflectionClass.from(getClassTypeFromInstance(item));
+        const classSchema = ReflectionClass.from(
+            getClassTypeFromInstance(item)
+        );
         let items = map.get(classSchema);
         if (!items) {
             items = [];
@@ -34,13 +40,18 @@ export function getClassSchemaInstancePairs<T extends OrmEntity>(items: Iterable
     return map;
 }
 
-
-export function findQuerySatisfied<T extends { [index: string]: any }>(target: T, query: FilterQuery<T>): boolean {
+export function findQuerySatisfied<T extends { [index: string]: any }>(
+    target: T,
+    query: FilterQuery<T>
+): boolean {
     //get rid of "Excessive stack depth comparing types 'any' and 'SiftQuery<T[]>'."
     return (sift as any)(query as any, [target] as any[]).length > 0;
 }
 
-export function findQueryList<T extends { [index: string]: any }>(items: T[], query: FilterQuery<T>): T[] {
+export function findQueryList<T extends { [index: string]: any }>(
+    items: T[],
+    query: FilterQuery<T>
+): T[] {
     //get rid of "Excessive stack depth comparing types 'any' and 'SiftQuery<T[]>'."
     return (sift as any)(query as any, items as any[]);
 }
@@ -53,5 +64,8 @@ export function buildChangesFromInstance<T>(item: T): Changes<T> {
     const state = getInstanceStateFromItem(item);
     const lastSnapshot = state.getSnapshot();
     const currentSnapshot = state.classState.snapshot(item);
-    return state.classState.changeDetector(lastSnapshot, currentSnapshot, item) || new Changes;
+    return (
+        state.classState.changeDetector(lastSnapshot, currentSnapshot, item) ||
+        new Changes()
+    );
 }
diff --git a/packages/orm/tests/query.spec.ts b/packages/orm/tests/query.spec.ts
index 507fc1834..79f3bfdbe 100644
--- a/packages/orm/tests/query.spec.ts
+++ b/packages/orm/tests/query.spec.ts
@@ -4,6 +4,7 @@ import { assert, IsExact } from 'conditional-type-checks';
 import { Database } from '../src/database';
 import { MemoryDatabaseAdapter, MemoryQuery } from '../src/memory-db';
 import { Query } from '../src/query';
+import { FieldName } from "../src/utils";
 
 test('query select', async () => {
     class s {
@@ -54,7 +55,7 @@ test('query lift', async () => {
 
     class UserQuery<T extends { username: string }> extends MyBase<T> {
         findAllUserNames() {
-            return this.findField('username');
+            return this.findField('username' as FieldName<T>);
         }
 
         //query classes should be able to infer the actual used class