diff --git a/.eslintrc b/.eslintrc
index c471e81..4e74490 100644
--- a/.eslintrc
+++ b/.eslintrc
@@ -5,8 +5,10 @@
     "project": "./tsconfig.eslint.json"
   },
   "rules": {
+    "@typescript-eslint/ban-types": "off",
+    "@typescript-eslint/no-namespace": "off",
     "@typescript-eslint/no-explicit-any": "off",
-    "@typescript-eslint/no-floating-promises": ["error"],
+    "@typescript-eslint/no-floating-promises": "error",
     "no-constant-binary-expression": "error",
     "no-console": ["error", { "allow": ["info", "warn", "error", "trace", "time", "timeEnd"] }]
   }
diff --git a/.gqmrc.json b/.gqmrc.json
index 734d96e..3307971 100644
--- a/.gqmrc.json
+++ b/.gqmrc.json
@@ -2,7 +2,7 @@
   "modelsPath": "tests/utils/models.ts",
   "generatedFolderPath": "tests/generated",
   "graphqlQueriesPath": "tests",
-  "gqlModule": "../../../src",
+  "gqmModule": "../../../src",
   "knexfilePath": "knexfile.ts",
   "dateLibrary": "luxon"
-}
\ No newline at end of file
+}
diff --git a/docs/docs/1-tutorial.md b/docs/docs/1-tutorial.md
index 7bae569..a23cf20 100644
--- a/docs/docs/1-tutorial.md
+++ b/docs/docs/1-tutorial.md
@@ -21,47 +21,52 @@ Replace `src/app/globals.css`:
 @tailwind utilities;
 
 main {
-    @apply w-96 mx-auto
+  @apply w-96 mx-auto;
 }
 
 nav {
-    @apply flex items-center
+  @apply flex items-center;
 }
 
-h1, h2, h3, h4 {
-    @apply font-bold
+h1,
+h2,
+h3,
+h4 {
+  @apply font-bold;
 }
 
 h1 {
-    @apply text-4xl mb-4 flex-grow
+  @apply text-4xl mb-4 flex-grow;
 }
 
 h2 {
-    @apply text-3xl mb-3
+  @apply text-3xl mb-3;
 }
 
 h3 {
-    @apply text-2xl mb-2
+  @apply text-2xl mb-2;
 }
 
 h4 {
-    @apply text-xl mb-1
+  @apply text-xl mb-1;
 }
 
 a {
-    @apply text-blue-500
+  @apply text-blue-500;
 }
 
-article, form {
-    @apply mb-4 p-3 rounded-lg shadow-md border border-gray-100
+article,
+form {
+  @apply mb-4 p-3 rounded-lg shadow-md border border-gray-100;
 }
 
-input, textarea {
-    @apply border border-gray-300 w-full rounded-md p-1
+input,
+textarea {
+  @apply border border-gray-300 w-full rounded-md p-1;
 }
 
 label span {
-    @apply font-bold
+  @apply font-bold;
 }
 ```
 
@@ -69,11 +74,13 @@ Replace `src/app/page.tsx`:
 
 ```tsx
 export default async function Home() {
-    return <main>
+  return (
+    <main>
       <nav>
         <h1>Magic Blog</h1>
       </nav>
     </main>
+  );
 }
 ```
 
@@ -89,9 +96,9 @@ Add this setting to `next.config.mjs`:
 
 ```ts
 const nextConfig = {
-    experimental: {
-        serverComponentsExternalPackages: ['knex'],
-    }
+  experimental: {
+    serverComponentsExternalPackages: ['knex'],
+  },
 };
 ```
 
@@ -137,7 +144,6 @@ npx gqm generate-migration
 
 Enter a migration name, e.g. "setup".
 
-
 Run the migration
 
 ```bash
@@ -157,36 +163,38 @@ import { getSession } from '@auth0/nextjs-auth0';
 export default async function Page() {
   const session = await getSession();
 
-  return <main>
-    <nav>
-      <h1>Welcome to my Blog</h1>
-      {session ? <a href="/api/auth/logout">Logout</a> : <a href="/api/auth/login">Login</a>}
-    </nav>
-  </main>
+  return (
+    <main>
+      <nav>
+        <h1>Welcome to my Blog</h1>
+        {session ? <a href="/api/auth/logout">Logout</a> : <a href="/api/auth/login">Login</a>}
+      </nav>
+    </main>
+  );
 }
 ```
 
 It should now be possible for you to log in and out again.
 
-### Account setup 
+### Account setup
 
 Now, we need to ensure that the user is stored in the database.
 
 First extend the user model in `src/config/models.ts` with the following fields:
 
 ```tsx
-    fields: [
-      {
-        name: 'authId',
-        type: 'String',
-        nonNull: true,
-      },
-      {
-        name: 'username',
-        type: 'String',
-        nonNull: true
-      }
-    ]
+fields: [
+  {
+    name: 'authId',
+    type: 'String',
+    nonNull: true,
+  },
+  {
+    name: 'username',
+    type: 'String',
+    nonNull: true,
+  },
+];
 ```
 
 The models have changed, generate the new types:
@@ -210,28 +218,28 @@ npx env-cmd knex migrate:latest
 Now let's implement the `// TODO: get user` part in the `src/graphql/execute.ts` file
 
 ```ts
-  const session = await getSession();
-  if (session) {
-    let dbUser = await db('User').where({ authId: session.user.sub }).first();
-    if (!user) {
-      await db('User').insert({
-        id: randomUUID(),
-        authId: session.user.sub,
-        username: session.user.nickname
-      })
-      dbUser = await db('User').where({ authId: session.user.sub }).first();
-    }
-    user = {
-      ...dbUser!,
-      role: 'ADMIN'
-    }
+const session = await getSession();
+if (session) {
+  let dbUser = await db('User').where({ authId: session.user.sub }).first();
+  if (!user) {
+    await db('User').insert({
+      id: randomUUID(),
+      authId: session.user.sub,
+      username: session.user.nickname,
+    });
+    dbUser = await db('User').where({ authId: session.user.sub }).first();
   }
+  user = {
+    ...dbUser!,
+    role: 'ADMIN',
+  };
+}
 ```
 
 Extend `src/graphql/client/queries/get-me.ts` to also fetch the user's username:
 
 ```ts
-import { gql } from '@smartive/graphql-magic';
+import { gql } from 'graphql-request';
 
 export const GET_ME = gql`
   query GetMe {
@@ -252,18 +260,26 @@ npx gqm generate
 Now, let's modify `src/app/page.tsx` so that it fetches the user from the database:
 
 ```tsx
-import { GetMeQuery } from "@/generated/client";
-import { GET_ME } from "@/graphql/client/queries/get-me";
-import { executeGraphql } from "@/graphql/execute";
+import { GetMeQuery } from '@/generated/client';
+import { GET_ME } from '@/graphql/client/queries/get-me';
+import { executeGraphql } from '@/graphql/execute';
 
 export default async function Home() {
-  const { data: { me } } = await executeGraphql<GetMeQuery>({ query: GET_ME });
+  const {
+    data: { me },
+  } = await executeGraphql<GetMeQuery>({ query: GET_ME });
 
   return (
     <main>
       <nav>
         <h1>Blog</h1>
-        {me ? <span>Hello, {me.username}! <a href="/api/auth/logout"> Logout</a></span> : <a href="/api/auth/login">Login</a>}
+        {me ? (
+          <span>
+            Hello, {me.username}! <a href="/api/auth/logout"> Logout</a>
+          </span>
+        ) : (
+          <a href="/api/auth/login">Login</a>
+        )}
       </nav>
     </main>
   );
@@ -334,24 +350,24 @@ npx env-cmd knex migrate:latest
 Create a new query `src/graphql/client/queries/get-posts.ts`:
 
 ```ts
-import { gql } from '@smartive/graphql-magic';
+import { gql } from 'graphql-request';
 
 export const GET_POSTS = gql`
   query GetPosts {
     posts {
+      id
+      title
+      content
+      createdBy {
+        username
+      }
+      comments {
         id
-        title
-        content
         createdBy {
-            username
-        }
-        comments {
-            id
-            createdBy {
-                username
-            }
-            content
+          username
         }
+        content
+      }
     }
   }
 `;
@@ -365,23 +381,37 @@ npx gqm generate
 
 Now add all the logic to create and display posts and comments to `src/app/page.tsx`
 
-
 ```tsx
-import { CreateCommentMutationMutation, CreateCommentMutationMutationVariables, CreatePostMutationMutation, CreatePostMutationMutationVariables, GetMeQuery, GetPostsQuery } from "@/generated/client";
-import { CREATE_COMMENT, CREATE_POST } from "@/generated/client/mutations";
-import { GET_ME } from "@/graphql/client/queries/get-me";
-import { GET_POSTS } from "@/graphql/client/queries/get-posts";
-import { executeGraphql } from "@/graphql/execute";
-import { revalidatePath } from "next/cache";
+import {
+  CreateCommentMutationMutation,
+  CreateCommentMutationMutationVariables,
+  CreatePostMutationMutation,
+  CreatePostMutationMutationVariables,
+  GetMeQuery,
+  GetPostsQuery,
+} from '@/generated/client';
+import { CREATE_COMMENT, CREATE_POST } from '@/generated/client/mutations';
+import { GET_ME } from '@/graphql/client/queries/get-me';
+import { GET_POSTS } from '@/graphql/client/queries/get-posts';
+import { executeGraphql } from '@/graphql/execute';
+import { revalidatePath } from 'next/cache';
 
 export default async function Home() {
-  const { data: { me } } = await executeGraphql<GetMeQuery>({ query: GET_ME });
+  const {
+    data: { me },
+  } = await executeGraphql<GetMeQuery>({ query: GET_ME });
 
   return (
     <main>
       <nav>
         <h1>Blog</h1>
-        {me ? <span>Hello, {me.username}! <a href="/api/auth/logout"> Logout</a></span> : <a href="/api/auth/login">Login</a>}
+        {me ? (
+          <span>
+            Hello, {me.username}! <a href="/api/auth/logout"> Logout</a>
+          </span>
+        ) : (
+          <a href="/api/auth/login">Login</a>
+        )}
       </nav>
       {me && <CreatePost />}
       <Posts me={me} />
@@ -390,81 +420,92 @@ export default async function Home() {
 }
 
 async function Posts({ me }: { me: GetMeQuery['me'] }) {
-  const { data: { posts } } = await executeGraphql<GetPostsQuery>({ query: GET_POSTS })
-
-  return <div>
-    {posts.map(post => <div key={post.id}>
-      <article>
-        <h2>{post.title}</h2>
-        <div>by {post.createdBy.username}</div>
-        <p>{post.content}</p>
-        <h4>Comments</h4>
-        {post.comments.map(comment => (<div key={comment.id}>
-          <div>{comment.createdBy.username}</div>
-          <p>{comment.content}</p> by {comment.createdBy.username}
-        </div>)
-        )}
-        {me && <CreateComment postId={post.id} />}
-      </article>
-    </div>)}
-  </div>
+  const {
+    data: { posts },
+  } = await executeGraphql<GetPostsQuery>({ query: GET_POSTS });
+
+  return (
+    <div>
+      {posts.map((post) => (
+        <div key={post.id}>
+          <article>
+            <h2>{post.title}</h2>
+            <div>by {post.createdBy.username}</div>
+            <p>{post.content}</p>
+            <h4>Comments</h4>
+            {post.comments.map((comment) => (
+              <div key={comment.id}>
+                <div>{comment.createdBy.username}</div>
+                <p>{comment.content}</p> by {comment.createdBy.username}
+              </div>
+            ))}
+            {me && <CreateComment postId={post.id} />}
+          </article>
+        </div>
+      ))}
+    </div>
+  );
 }
 
 async function CreatePost() {
   async function createPost(formData: FormData) {
-    'use server'
+    'use server';
     await executeGraphql<CreatePostMutationMutation, CreatePostMutationMutationVariables>({
       query: CREATE_POST,
       variables: {
         data: {
           title: formData.get('title') as string,
-          content: formData.get('content') as string
-        }
-      }
-    })
-    revalidatePath('/')
+          content: formData.get('content') as string,
+        },
+      },
+    });
+    revalidatePath('/');
   }
 
-  return <form action={createPost}>
-    <h2>New Post</h2>
-    <label>
-      <span>Title</span>
-      <input name="title" />
-    </label>
-    <label>
-      <span>Content</span>
-      <textarea rows={5} name="content" />
-    </label>
-    <div>
-      <button type="submit">Create</button>
-    </div>
-  </form>
+  return (
+    <form action={createPost}>
+      <h2>New Post</h2>
+      <label>
+        <span>Title</span>
+        <input name="title" />
+      </label>
+      <label>
+        <span>Content</span>
+        <textarea rows={5} name="content" />
+      </label>
+      <div>
+        <button type="submit">Create</button>
+      </div>
+    </form>
+  );
 }
 
 function CreateComment({ postId }: { postId: string }) {
   async function createComment(formData: FormData) {
-    'use server'
+    'use server';
 
     const res = await executeGraphql<CreateCommentMutationMutation, CreateCommentMutationMutationVariables>({
       query: CREATE_COMMENT,
       variables: {
         data: {
           postId,
-          content: formData.get('content') as string
-        }
-      }
-    })
-    console.log(res)
-    revalidatePath('/')
+          content: formData.get('content') as string,
+        },
+      },
+    });
+    console.log(res);
+    revalidatePath('/');
   }
-  return <form action={createComment}>
-    <div>
-      <textarea name="content" placeholder="Leave a comment..." />
-    </div>
-    <div>
-      <button type="submit">Send</button>
-    </div>
-  </form>
+  return (
+    <form action={createComment}>
+      <div>
+        <textarea name="content" placeholder="Leave a comment..." />
+      </div>
+      <div>
+        <button type="submit">Send</button>
+      </div>
+    </form>
+  );
 }
 ```
 
diff --git a/docs/docs/7-graphql-client.md b/docs/docs/7-graphql-client.md
index e56d9fe..5ace0a5 100644
--- a/docs/docs/7-graphql-client.md
+++ b/docs/docs/7-graphql-client.md
@@ -21,28 +21,35 @@ module.exports = {
 On the server side, and with `next.js` server actions, a graphql api becomes unnecessary, and you can execute queries directly using `executeGraphql`:
 
 ```tsx
-import { GetMeQuery, GetPostsQuery } from "@/generated/client";
-import { GET_POSTS } from "@/graphql/client/queries/get-posts";
-import { executeGraphql } from "@/graphql/execute";
+import { GetMeQuery, GetPostsQuery } from '@/generated/client';
+import { GET_POSTS } from '@/graphql/client/queries/get-posts';
+import { executeGraphql } from '@/graphql/execute';
 
 async function Posts({ me }: { me: GetMeQuery['me'] }) {
-  const { data: { posts } } = await executeGraphql<GetPostsQuery>({ query: GET_POSTS })
-
-  return <div>
-    {posts.map(post => <div key={post.id}>
-      <article>
-        <h2>{post.title}</h2>
-        <div>by {post.createdBy.username}</div>
-        <p>{post.content}</p>
-        <h4>Comments</h4>
-        {post.comments.map(comment => (<div key={comment.id}>
-          <div>{comment.createdBy.username}</div>
-          <p>{comment.content}</p> by {comment.createdBy.username}
-        </div>)
-        )}
-      </article>
-    </div>)}
-  </div>
+  const {
+    data: { posts },
+  } = await executeGraphql<GetPostsQuery>({ query: GET_POSTS });
+
+  return (
+    <div>
+      {posts.map((post) => (
+        <div key={post.id}>
+          <article>
+            <h2>{post.title}</h2>
+            <div>by {post.createdBy.username}</div>
+            <p>{post.content}</p>
+            <h4>Comments</h4>
+            {post.comments.map((comment) => (
+              <div key={comment.id}>
+                <div>{comment.createdBy.username}</div>
+                <p>{comment.content}</p> by {comment.createdBy.username}
+              </div>
+            ))}
+          </article>
+        </div>
+      ))}
+    </div>
+  );
 }
 ```
 
@@ -51,13 +58,13 @@ async function Posts({ me }: { me: GetMeQuery['me'] }) {
 On the client, you'd need to set up a graphql endpoint and then query it like any other graphql api, such as with [`@apollo/client`](https://www.apollographql.com/docs/react/get-started).
 
 ```tsx
-import { GetMeQuery, GetPostsQuery } from "@/generated/client";
-import { GET_POSTS } from "@/graphql/client/queries/get-posts";
-import { executeGraphql } from "@/graphql/execute";
+import { GetMeQuery, GetPostsQuery } from '@/generated/client';
+import { GET_POSTS } from '@/graphql/client/queries/get-posts';
+import { executeGraphql } from '@/graphql/execute';
 import { gql, useQuery } from '@apollo/client';
 
 function Posts({ me }: { me: GetMeQuery['me'] }) {
-  const { loading, error, data } = useQuery<GetPostsQuery>({ query: GET_POSTS })
+  const { loading, error, data } = useQuery<GetPostsQuery>({ query: GET_POSTS });
 
   if (loading) {
     return 'Loading...';
@@ -66,21 +73,26 @@ function Posts({ me }: { me: GetMeQuery['me'] }) {
     return `Error! ${error.message}`;
   }
 
-  return <div>
-    {res?.data?.posts.map(post => <div key={post.id}>
-      <article>
-        <h2>{post.title}</h2>
-        <div>by {post.createdBy.username}</div>
-        <p>{post.content}</p>
-        <h4>Comments</h4>
-        {post.comments.map(comment => (<div key={comment.id}>
-          <div>{comment.createdBy.username}</div>
-          <p>{comment.content}</p> by {comment.createdBy.username}
-        </div>)
-        )}
-      </article>
-    </div>)}
-  </div>
+  return (
+    <div>
+      {res?.data?.posts.map((post) => (
+        <div key={post.id}>
+          <article>
+            <h2>{post.title}</h2>
+            <div>by {post.createdBy.username}</div>
+            <p>{post.content}</p>
+            <h4>Comments</h4>
+            {post.comments.map((comment) => (
+              <div key={comment.id}>
+                <div>{comment.createdBy.username}</div>
+                <p>{comment.content}</p> by {comment.createdBy.username}
+              </div>
+            ))}
+          </article>
+        </div>
+      ))}
+    </div>
+  );
 }
 ```
 
@@ -91,13 +103,17 @@ Mutation queries are generated by `graphql-magic` directly so you don't need to
 ```ts
 export const CREATE_POST = gql`
   mutation CreatePostMutation($data: CreatePost!) {
-    createPost(data: $data) { id }
+    createPost(data: $data) {
+      id
+    }
   }
 `;
 
 export const UPDATE_POST = gql`
   mutation UpdatePostMutation($id: ID!, $data: UpdatePost!) {
-    updatePost(where: { id: $id }, data: $data) { id }
+    updatePost(where: { id: $id }, data: $data) {
+      id
+    }
   }
 `;
 
@@ -111,40 +127,42 @@ export const DELETE_POST = gql`
 Use like this:
 
 ```tsx
-import { CreatePostMutationMutation, CreatePostMutationMutationVariables } from "@/generated/client";
-import { CREATE_POST } from "@/generated/client/mutations";
-import { executeGraphql } from "@/graphql/execute";
-import { revalidatePath } from "next/cache";
+import { CreatePostMutationMutation, CreatePostMutationMutationVariables } from '@/generated/client';
+import { CREATE_POST } from '@/generated/client/mutations';
+import { executeGraphql } from '@/graphql/execute';
+import { revalidatePath } from 'next/cache';
 
 async function CreatePost() {
   async function createPost(formData: FormData) {
-    'use server'
+    'use server';
     await executeGraphql<CreatePostMutationMutation, CreatePostMutationMutationVariables>({
       query: CREATE_POST,
       variables: {
         data: {
           title: formData.get('title') as string,
-          content: formData.get('content') as string
-        }
-      }
-    })
-    revalidatePath('/')
+          content: formData.get('content') as string,
+        },
+      },
+    });
+    revalidatePath('/');
   }
 
-  return <form action={createPost}>
-    <h2>New Post</h2>
-    <label>
-      <span>Title</span>
-      <input name="title" />
-    </label>
-    <label>
-      <span>Content</span>
-      <textarea rows={5} name="content" />
-    </label>
-    <div>
-      <button type="submit">Create</button>
-    </div>
-  </form>
+  return (
+    <form action={createPost}>
+      <h2>New Post</h2>
+      <label>
+        <span>Title</span>
+        <input name="title" />
+      </label>
+      <label>
+        <span>Content</span>
+        <textarea rows={5} name="content" />
+      </label>
+      <div>
+        <button type="submit">Create</button>
+      </div>
+    </form>
+  );
 }
 ```
 
diff --git a/package.json b/package.json
index 825ae6e..9ca5deb 100644
--- a/package.json
+++ b/package.json
@@ -15,7 +15,7 @@
     "bootstrap": "npm ci && npm run generate",
     "generate": "npm run generate:index-files && npm run build:bin && npm run generate:gqm-stuff && npm run generate:setup-migration",
     "generate:index-files": "cti create ./src --excludes bin --withoutbackup",
-    "generate:gqm-stuff": "npx gqm generate",
+    "generate:gqm-stuff": "npx gqm generate && eslint tests/generated --fix",
     "generate:setup-migration": "npm run build:bin && npx gqm generate-migration setup 20230912185644",
     "lint": "eslint src",
     "lint:fix": "eslint src --fix",
diff --git a/src/api/execute.ts b/src/api/execute.ts
deleted file mode 100644
index a997162..0000000
--- a/src/api/execute.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-import { makeExecutableSchema } from '@graphql-tools/schema';
-import { IResolvers } from '@graphql-tools/utils';
-import { GraphQLResolveInfo, Source, execute as graphqlExecute, parse } from 'graphql';
-import { merge } from 'lodash';
-import { Context, generate, get, getResolvers } from '..';
-
-export const execute = async ({
-  additionalResolvers,
-  body,
-  ...ctx
-}: {
-  additionalResolvers?: IResolvers<any, any>;
-  body: any;
-} & Omit<Context, 'document'>) => {
-  const document = generate(ctx.models);
-
-  const generatedResolvers = getResolvers(ctx.models);
-
-  const schema = makeExecutableSchema({
-    typeDefs: document,
-    resolvers: merge(generatedResolvers, additionalResolvers),
-  });
-
-  const contextValue: Context = {
-    document,
-    ...ctx,
-  };
-
-  const result = await graphqlExecute({
-    schema,
-    document: parse(new Source(body.query, 'GraphQL request')),
-    contextValue,
-    variableValues: body.variables,
-    operationName: body.operationName,
-    fieldResolver: (parent, _args, _ctx, info: GraphQLResolveInfo) => {
-      const node = get(info.fieldNodes, 0);
-      const alias = node.alias;
-      return parent[alias ? alias.value : node.name.value];
-    },
-  });
-
-  return result;
-};
diff --git a/src/api/index.ts b/src/api/index.ts
deleted file mode 100644
index 1c85459..0000000
--- a/src/api/index.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-// created from 'create-ts-index'
-
-export * from './execute';
diff --git a/src/bin/gqm/gqm.ts b/src/bin/gqm/gqm.ts
index 1c57972..abe52eb 100644
--- a/src/bin/gqm/gqm.ts
+++ b/src/bin/gqm/gqm.ts
@@ -10,8 +10,10 @@ import {
   generateKnexTables,
   generateMutations,
   getMigrationDate,
+  printSchemaAsVariables as printSchemaAsVariable,
   printSchemaFromModels,
 } from '../..';
+import { generateResolvers } from '../../resolvers/generate';
 import { DateLibrary } from '../../utils/dates';
 import { generateGraphqlApiTypes, generateGraphqlClientTypes } from './codegen';
 import { parseKnexfile } from './parse-knexfile';
@@ -35,14 +37,16 @@ program
     await getSetting('knexfilePath');
     const models = await parseModels();
     const generatedFolderPath = await getSetting('generatedFolderPath');
-    const gqlModule = await getSetting('gqlModule');
+    const gqmModule = await getSetting('gqmModule');
     writeToFile(`${generatedFolderPath}/schema.graphql`, printSchemaFromModels(models));
-    writeToFile(`${generatedFolderPath}/client/mutations.ts`, generateMutations(models, gqlModule));
+    writeToFile(`${generatedFolderPath}/schema/index.ts`, printSchemaAsVariable(models));
+    writeToFile(`${generatedFolderPath}/client/mutations.ts`, generateMutations(models));
     const dateLibrary = (await getSetting('dateLibrary')) as DateLibrary;
     writeToFile(`${generatedFolderPath}/db/index.ts`, generateDBModels(models, dateLibrary));
     writeToFile(`${generatedFolderPath}/db/knex.ts`, generateKnexTables(models));
     await generateGraphqlApiTypes(dateLibrary);
     await generateGraphqlClientTypes();
+    writeToFile(`${generatedFolderPath}/resolvers/index.ts`, generateResolvers(models, { dateLibrary, gqmModule }));
   });
 
 program
diff --git a/src/bin/gqm/settings.ts b/src/bin/gqm/settings.ts
index 013c7b3..984668f 100644
--- a/src/bin/gqm/settings.ts
+++ b/src/bin/gqm/settings.ts
@@ -58,7 +58,7 @@ const DEFAULTS = {
       ensureFileExists(`${path}/execute.ts`, EXECUTE);
     },
   },
-  gqlModule: {
+  gqmModule: {
     defaultValue: '@smartive/graphql-magic',
   },
   dateLibrary: {
diff --git a/src/bin/gqm/templates.ts b/src/bin/gqm/templates.ts
index b7f7d7b..49476b1 100644
--- a/src/bin/gqm/templates.ts
+++ b/src/bin/gqm/templates.ts
@@ -63,7 +63,7 @@ for (const oid of Object.values(dateOids)) {
 }
 `;
 
-export const GET_ME = `import { gql } from '@smartive/graphql-magic';
+export const GET_ME = `import { gql } from 'graphql-request';
 
 export const GET_ME = gql\`
   query GetMe {
diff --git a/src/client/gql.ts b/src/client/gql.ts
deleted file mode 100644
index c2b4592..0000000
--- a/src/client/gql.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-// This tag does nothing (just generates a string) - it is here for the tooling (syntax highlighting, formatting and type generation)
-export const gql = (chunks: TemplateStringsArray, ...variables: (string | number | boolean)[]): string => {
-  return chunks.reduce(
-    (accumulator, chunk, index) => `${accumulator}${chunk}${index in variables ? variables[index] : ''}`,
-    ''
-  );
-};
diff --git a/src/client/index.ts b/src/client/index.ts
index 8bd6833..bce2bf0 100644
--- a/src/client/index.ts
+++ b/src/client/index.ts
@@ -1,6 +1,3 @@
 // created from 'create-ts-index'
 
-export * from './gql';
-export * from './models';
 export * from './mutations';
-export * from './queries';
diff --git a/src/client/models.ts b/src/client/models.ts
deleted file mode 100644
index 6fb03f6..0000000
--- a/src/client/models.ts
+++ /dev/null
@@ -1 +0,0 @@
-export type ClientEntity = Record<string, unknown>;
diff --git a/src/client/mutations.ts b/src/client/mutations.ts
index 06e8aef..d9659c9 100644
--- a/src/client/mutations.ts
+++ b/src/client/mutations.ts
@@ -1,42 +1,85 @@
+import CodeBlockWriter from 'code-block-writer';
 import upperCase from 'lodash/upperCase';
 import { isRootModel, not } from '..';
 import { Models } from '../models/models';
 
-const constantCase = (str: string) => upperCase(str).replace(/ /g, '_');
+export const constantCase = (str: string) => upperCase(str).replace(/ /g, '_');
+
+export const generateMutations = (models: Models) => {
+  const writer: CodeBlockWriter = new CodeBlockWriter['default']({
+    useSingleQuote: true,
+    indentNumberOfSpaces: 2,
+  });
+
+  writer.writeLine(`import { gql } from "graphql-request";`).blankLine();
 
-export const generateMutations = (models: Models, gqmModule = '@smartive/graphql-magic') => {
-  const parts: string[] = [];
   for (const { name, creatable, updatable, deletable } of models.entities.filter(not(isRootModel))) {
     if (creatable) {
-      parts.push(
-        `export const CREATE_${constantCase(
-          name
-        )} = gql\`\n  mutation Create${name}Mutation($data: Create${name}!) {\n    create${name}(data: $data) { id }\n  }\n\`;`
-      );
+      writer
+        .writeLine(
+          `export const CREATE_${constantCase(
+            name
+          )} = gql\`\n  mutation Create${name}Mutation($data: Create${name}!) {\n    mutated: create${name}(data: $data) { id }\n  }\n\`;`
+        )
+        .blankLine();
     }
 
     if (updatable) {
-      parts.push(
-        `export const UPDATE_${constantCase(
-          name
-        )} = gql\`\n  mutation Update${name}Mutation($id: ID!, $data: Update${name}!) {\n    update${name}(where: { id: $id }, data: $data) { id }\n  }\n\`;`
-      );
+      writer
+        .writeLine(
+          `export const UPDATE_${constantCase(
+            name
+          )} = gql\`\n  mutation Update${name}Mutation($id: ID!, $data: Update${name}!) {\n    mutated: update${name}(where: { id: $id }, data: $data) { id }\n  }\n\`;`
+        )
+        .blankLine();
     }
 
     if (deletable) {
-      parts.push(
-        `export const DELETE_${constantCase(
-          name
-        )} = gql\`\n  mutation Delete${name}Mutation($id: ID!) {\n    delete${name}(where: { id: $id })\n  }\n\`;`
-      );
-
-      parts.push(
-        `export const RESTORE_${constantCase(
-          name
-        )} = gql\`\n  mutation Restore${name}Mutation($id: ID!) {\n    restore${name}(where: { id: $id })\n  }\n\`;`
-      );
+      writer
+        .writeLine(
+          `export const DELETE_${constantCase(
+            name
+          )} = gql\`\n  mutation Delete${name}Mutation($id: ID!) {\n    mutated: delete${name}(where: { id: $id })\n  }\n\`;`
+        )
+        .blankLine();
+
+      writer
+        .writeLine(
+          `export const RESTORE_${constantCase(
+            name
+          )} = gql\`\n  mutation Restore${name}Mutation($id: ID!) {\n    mutated: restore${name}(where: { id: $id })\n  }\n\`;`
+        )
+        .blankLine();
     }
   }
 
-  return `import { gql } from "${gqmModule}";\n\n${parts.join('\n\n')}`;
+  writer
+    .blankLine()
+    .write(`export const MUTATIONS = `)
+    .inlineBlock(() => {
+      for (const model of models.entities.filter(not(isRootModel))) {
+        writer
+          .write(`${model.name}: `)
+          .inlineBlock(() => {
+            if (model.creatable) {
+              writer.writeLine(`create: CREATE_${constantCase(model.name)},`);
+            }
+
+            if (model.updatable) {
+              writer.writeLine(`update: UPDATE_${constantCase(model.name)},`);
+            }
+
+            if (model.deletable) {
+              writer.writeLine(`delete: DELETE_${constantCase(model.name)},`);
+              writer.writeLine(`restore: RESTORE_${constantCase(model.name)},`);
+            }
+          })
+          .write(',')
+          .blankLine();
+      }
+    })
+    .write(';')
+    .blankLine();
+
+  return writer.toString();
 };
diff --git a/src/client/queries.ts b/src/client/queries.ts
deleted file mode 100644
index 1942500..0000000
--- a/src/client/queries.ts
+++ /dev/null
@@ -1,225 +0,0 @@
-import { ManyToManyRelation, ReverseRelation } from '..';
-import { EntityModel, Model, Models, Relation } from '../models/models';
-import {
-  and,
-  getActionableRelations,
-  isQueriableBy,
-  isRelation,
-  isSimpleField,
-  isToOneRelation,
-  isUpdatableBy,
-  not,
-  typeToField,
-} from '../models/utils';
-
-export const getUpdateEntityQuery = (
-  model: EntityModel,
-  role: string,
-  fields?: string[] | undefined,
-  additionalFields = ''
-) => `query Update${model.name}Fields ($id: ID!) {
-  data: ${typeToField(model.name)}(where: { id: $id }) {
-    id
-    ${model.fields
-      .filter(({ name }) => !fields || fields.includes(name))
-      .filter(not(isRelation))
-      .filter(isUpdatableBy(role))
-      .map(({ name }) => name)
-      .join(' ')}
-    ${getActionableRelations(model, 'update')
-      .filter((name) => !fields || fields.includes(name))
-      .map((name) => `${name} { id, display: ${model.getRelation(name).targetModel.displayField || 'id'} }`)}
-    ${additionalFields}
-  }
-}`;
-
-export type RelationConstraints = Record<string, (source: any) => any>;
-
-export const fieldIsSearchable = (model: EntityModel, fieldName: string) => {
-  const relation = model.getRelation(fieldName);
-  const targetModel = relation.targetModel;
-  const displayField = targetModel.getField(targetModel.displayField || 'id');
-  return displayField.searchable;
-};
-
-export const getSelectEntityRelationsQuery = (model: EntityModel, relationNames: string[]) => {
-  const relations = relationNames.map((name) => model.getRelation(name));
-
-  return (
-    !!relations.length &&
-    `query Select${model.name}Relations(${relations
-      .map(
-        (relation) =>
-          `$${relation.name}Where: ${relation.targetModel.name}Where, $${relation.name}Limit: Int${
-            fieldIsSearchable(model, relation.name) ? `, $${relation.name}Search: String` : ''
-          }`
-      )
-      .join(', ')}) {
-      ${relations
-        .map((relation) => {
-          let filters = '';
-
-          if (relation.targetModel.displayField) {
-            const displayField = relation.targetModel.fieldsByName[relation.targetModel.displayField];
-            if ('orderable' in displayField && displayField.orderable) {
-              filters += `, orderBy: [{ ${relation.targetModel.displayField}: ASC }]`;
-            }
-          }
-
-          if (fieldIsSearchable(model, relation.name)) {
-            filters += `, search: $${relation.name}Search`;
-          }
-
-          return `${relation.name}: ${relation.targetModel.pluralField}(where: $${relation.name}Where, limit: $${
-            relation.name
-          }Limit${filters}) {
-            id
-            display: ${relation.targetModel.displayField || 'id'}
-          }`;
-        })
-        .join(' ')}
-    }`
-  );
-};
-
-export const getManyToManyRelationsQuery = (
-  model: Model,
-  action: 'create' | 'update',
-  manyToManyRelations: ManyToManyRelation[]
-) =>
-  !!manyToManyRelations.length &&
-  (action === 'update'
-    ? `query Update${model.name}ManyToManyRelations($id: ID!) {
-            ${typeToField(model.name)}(where: { id: $id }) {
-              ${manyToManyRelations
-                .map((relation) => {
-                  return `${relation.name} {
-                    id
-                    ${relation.relationToTarget.name} {
-                      id
-                    }
-                  }`;
-                })
-                .join(' ')}
-            }
-            ${manyToManyRelations
-              .map((relation) => {
-                return `${relation.name}: ${relation.targetModel.pluralField} {
-                  id
-                  ${relation.targetModel.displayField || ''}
-                }`;
-              })
-              .join(' ')}
-          }`
-    : `query Create${model.name}ManyToManyRelations {
-            ${manyToManyRelations
-              .map((relation) => {
-                return `${relation.name}: ${relation.targetModel.pluralField} {
-                  id
-                  ${relation.targetModel.displayField || ''}
-                }`;
-              })
-              .join(' ')}
-          }`);
-
-export type MutationQuery = {
-  mutated: {
-    id: string;
-  };
-};
-
-export const getMutationQuery = (model: Model, action: 'create' | 'update' | 'delete') =>
-  action === 'create'
-    ? `
-        mutation Create${model.name} ($data: Create${model.name}!) {
-          mutated: create${model.name}(data: $data) {
-            id
-          }
-        }
-        `
-    : action === 'update'
-    ? `
-        mutation Update${model.name} ($id: ID!, $data: Update${model.name}!) {
-          mutated: update${model.name}(where: { id: $id } data: $data) {
-            id
-          }
-        }
-        `
-    : `
-        mutation Delete${model.name} ($id: ID!) {
-          mutated: delete${model.name}(where: { id: $id }) {
-            id
-          }
-        }
-        `;
-
-export const displayField = (model: EntityModel) => `
-${model.displayField ? `display: ${model.displayField}` : ''}
-`;
-
-export const getEntityListQuery = (
-  model: EntityModel,
-  role: string,
-  relations?: string[],
-  fragment = '',
-  reverseRelation?: ReverseRelation
-) => `query ${model.plural}List(
-  ${reverseRelation ? '$id: ID!,' : ''}
-  $limit: Int!,
-  $where: ${model.name}Where!,
-  ${model.fields.some(({ searchable }) => searchable) ? '$search: String,' : ''}
-) {
-  ${reverseRelation ? `root: ${typeToField(reverseRelation.sourceModel.name)}(where: { id: $id }) {` : ''}
-    data: ${reverseRelation ? reverseRelation.name : model.pluralField}(limit: $limit, where: $where, ${
-  model.fields.some(({ searchable }) => searchable) ? ', search: $search' : ''
-}) {
-      ${displayField(model)}
-      ${model.fields.filter(and(isSimpleField, isQueriableBy(role))).map(({ name }) => name)}
-      ${fragment}
-      ${queryRelations(
-        model.models,
-        model.relations.filter((relation) => !relations || relations.includes(relation.name))
-      )}
-      ${fragment}
-    }
-  ${reverseRelation ? '}' : ''}
-}`;
-
-export const getEntityQuery = (model: EntityModel, role: string, relations?: string[], fragment = '') => `query Get${
-  model.name
-}Entity ($id: ID!) {
-  data: ${typeToField(model.name)}(where: { id: $id }) {
-    ${displayField(model)}
-    ${model.fields.filter(and(isSimpleField, isQueriableBy(role))).map(({ name }) => name)}
-    ${queryRelations(
-      model.models,
-      model.relations.filter((relation) => !relations || relations.includes(relation.name))
-    )}
-    ${queryRelations(
-      model.models,
-      model.reverseRelations.filter(
-        (reverseRelation) =>
-          isToOneRelation(reverseRelation.field) && (!relations || relations.includes(reverseRelation.name))
-      )
-    )}
-    ${fragment}
-  }
-}`;
-
-export const getFindEntityQuery = (model: EntityModel, role: string) => `query Find${model.name}($where: ${
-  model.name
-}Where!, $orderBy: [${model.name}OrderBy!]) {
-  data: ${model.pluralField}(limit: 1, where: $where, orderBy: $orderBy) {
-    ${model.fields.filter(and(isSimpleField, isQueriableBy(role))).map(({ name }) => name)}
-  }
-}`;
-
-export const queryRelations = (models: Models, relations: Relation[]) =>
-  relations
-    .map(
-      (relation): string => `${relation.name} {
-          id
-          ${displayField(relation.targetModel)}
-        }`
-    )
-    .join('\n');
diff --git a/src/context.ts b/src/context.ts
index 6f85bb5..5f2025d 100644
--- a/src/context.ts
+++ b/src/context.ts
@@ -1,8 +1,8 @@
-import { DocumentNode, GraphQLResolveInfo } from 'graphql';
+import { GraphQLResolveInfo } from 'graphql';
 import { IncomingMessage } from 'http';
 import { Knex } from 'knex';
 import { Models } from './models/models';
-import { Entity, MutationHook } from './models/mutation-hook';
+import { MutationHook } from './models/mutation-hook';
 import { Permissions } from './permissions/generate';
 import { AliasGenerator } from './resolvers/utils';
 import { AnyDateType } from './utils';
@@ -15,17 +15,15 @@ export type Context<DateType extends AnyDateType = AnyDateType> = {
   now: DateType;
   timeZone?: string;
   knex: Knex;
-  document: DocumentNode;
   locale: string;
   locales: string[];
   user?: User;
   models: Models;
   permissions: Permissions;
   mutationHook?: MutationHook<DateType>;
-  handleUploads?: (data: Entity) => Promise<void>;
 };
 
-export type FullContext = Context & {
+export type FullContext<DateType extends AnyDateType = AnyDateType> = Context<DateType> & {
   info: GraphQLResolveInfo;
   aliases: AliasGenerator;
 };
diff --git a/src/db/generate.ts b/src/db/generate.ts
index 16449ce..fc73ffc 100644
--- a/src/db/generate.ts
+++ b/src/db/generate.ts
@@ -1,7 +1,8 @@
 import CodeBlockWriter from 'code-block-writer';
-import { EntityField, get, getColumnName, isCustomField, isInTable, isRootModel, not } from '..';
+import { EntityField, getColumnName, isCustomField, isInTable, isRootModel, not } from '..';
 import { Models } from '../models/models';
 import { DATE_CLASS, DATE_CLASS_IMPORT, DateLibrary } from '../utils/dates';
+import { get } from '../utils/getters';
 
 const PRIMITIVE_TYPES = {
   ID: 'string',
@@ -43,6 +44,14 @@ export const generateDBModels = (models: Models, dateLibrary: DateLibrary) => {
       })
       .blankLine();
 
+    writer
+      .writeLine(
+        `export type Full${model.name} = ${
+          model.rootModel === model ? model.name : `${model.name} & ${model.rootModel.name}`
+        }`
+      )
+      .blankLine();
+
     writer
       .write(`export type ${model.name}Initializer = `)
       .inlineBlock(() => {
@@ -53,7 +62,7 @@ export const generateDBModels = (models: Models, dateLibrary: DateLibrary) => {
                 field,
                 dateLibrary,
                 true
-              )}${field.list ? ' | string' : ''}${field.nonNull ? '' : ' | null'};`
+              )}${field.list ? ' | string' : ''}${field.nonNull ? '  | null' : ' | null'};` // TODO?
             )
             .newLine();
         }
@@ -67,7 +76,7 @@ export const generateDBModels = (models: Models, dateLibrary: DateLibrary) => {
           writer
             .write(
               `'${getColumnName(field)}'?: ${getFieldType(field, dateLibrary, true)}${field.list ? ' | string' : ''}${
-                field.nonNull ? '' : ' | null'
+                field.nonNull ? ' | null' : ' | null' // TODO null input in not nullable fields just doesn't update???
               };`
             )
             .newLine();
diff --git a/src/index.ts b/src/index.ts
index 6727d45..dc084b6 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,6 +1,5 @@
 // created from 'create-ts-index'
 
-export * from './api';
 export * from './client';
 export * from './db';
 export * from './migrations';
diff --git a/src/migrations/generate.ts b/src/migrations/generate.ts
index e6849ea..cfe165a 100644
--- a/src/migrations/generate.ts
+++ b/src/migrations/generate.ts
@@ -7,16 +7,15 @@ import lowerFirst from 'lodash/lowerFirst';
 import { EntityField, EntityModel, EnumModel, Models } from '../models/models';
 import {
   and,
-  get,
   isCreatableModel,
   isInherited,
   isUpdatableField,
   isUpdatableModel,
   modelNeedsTable,
   not,
-  summonByName,
   typeToField,
 } from '../models/utils';
+import { get, summonByName } from '../utils/getters';
 import { Value } from '../values';
 
 type Callbacks = (() => void)[];
@@ -94,13 +93,13 @@ export class MigrationGenerator {
           up.push(() => {
             this.renameTable(`${model.oldName}Revision`, `${model.name}Revision`);
             this.alterTable(`${model.name}Revision`, () => {
-              this.renameColumn(`${typeToField(get(model, 'oldName'))}Id`, `${typeToField(model.name)}Id`);
+              this.renameColumn(`${typeToField(get(model, 'oldName'))}Id`, `${model.asField}Id`);
             });
           });
           down.push(() => {
             this.renameTable(`${model.name}Revision`, `${model.oldName}Revision`);
             this.alterTable(`${model.oldName}Revision`, () => {
-              this.renameColumn(`${typeToField(model.name)}Id`, `${typeToField(get(model, 'oldName'))}Id`);
+              this.renameColumn(`${model.asField}Id`, `${typeToField(get(model, 'oldName'))}Id`);
             });
           });
           tables[tables.indexOf(`${model.oldName}Revision`)] = `${model.name}Revision`;
@@ -183,7 +182,7 @@ export class MigrationGenerator {
                         .write(`await knex.batchInsert('${model.name}Revision', data.map((row) => (`)
                         .inlineBlock(() => {
                           writer.writeLine(`id: uuid(),`);
-                          writer.writeLine(`${typeToField(model.name)}Id: row.id,`);
+                          writer.writeLine(`${model.asField}Id: row.id,`);
                           this.nowUsed = true;
                           writer.writeLine(`createdAt: row.updatedAt || row.createdAt || now,`);
                           writer.writeLine(`createdById: row.updatedById || row.createdById,`);
@@ -441,7 +440,7 @@ export class MigrationGenerator {
     this.createTable(`${model.name}Revision`, () => {
       writer.writeLine(`table.uuid('id').notNullable().primary();`);
       if (!model.parent) {
-        writer.writeLine(`table.uuid('${typeToField(model.name)}Id').notNullable();`);
+        writer.writeLine(`table.uuid('${model.asField}Id').notNullable();`);
         writer.writeLine(`table.uuid('createdById').notNullable();`);
         writer.writeLine(`table.timestamp('createdAt').notNullable().defaultTo(knex.fn.now(0));`);
         if (model.deletable) {
@@ -474,9 +473,7 @@ export class MigrationGenerator {
               const col = type === 'relation' ? `${name}Id` : name;
               this.writer
                 .write(
-                  `${col}: knex.raw('(select "${col}" from "${model.name}" where "${model.name}".id = "${
-                    model.name
-                  }Revision"."${typeToField(model.name)}Id")'),`
+                  `${col}: knex.raw('(select "${col}" from "${model.name}" where "${model.name}".id = "${model.name}Revision"."${model.asField}Id")'),`
                 )
                 .newLine();
             }
diff --git a/src/models/models.ts b/src/models/models.ts
index 53933e2..0414dac 100644
--- a/src/models/models.ts
+++ b/src/models/models.ts
@@ -2,6 +2,7 @@ import { pluralize } from 'inflection';
 import { cloneDeep, kebabCase, omit, pick } from 'lodash';
 import { isRelation } from '.';
 import {
+  Action,
   CustomFieldDefinition,
   EnumFieldDefinition,
   FloatFieldDefinition,
@@ -17,6 +18,7 @@ import {
   StringFieldDefinition,
   UploadFieldDefinition,
 } from '..';
+import { get, summonByName } from '../utils/getters';
 import {
   BooleanFieldDefinition,
   DateTimeFieldDefinition,
@@ -28,7 +30,7 @@ import {
   ObjectFieldDefinition,
   RelationFieldDefinition,
 } from './model-definitions';
-import { get, getLabel, summonByName, typeToField } from './utils';
+import { getLabel, typeToField } from './utils';
 
 // These might one day become classes
 
@@ -330,6 +332,7 @@ export class EntityModel extends Model {
   private _reverseRelationsByName: Record<string, ReverseRelation>;
   private _manyToManyRelations: ManyToManyRelation[];
   private _manyToManyRelationsByName: Record<string, ManyToManyRelation>;
+  public asField: string;
   public pluralField: string;
   public slug: string;
   public labelPlural: string;
@@ -339,6 +342,7 @@ export class EntityModel extends Model {
   constructor(models: Models, definition: EntityModelDefinition) {
     super(models, definition);
     Object.assign(this, omit(definition, 'name', 'plural', 'description'));
+    this.asField = typeToField(this.name);
     this.pluralField = typeToField(this.plural);
     this.slug = kebabCase(this.plural);
     this.labelPlural = getLabel(this.plural);
@@ -375,6 +379,15 @@ export class EntityModel extends Model {
     return get(this.relationsByName, name);
   }
 
+  public getActionableRelations(action: Action | 'filter') {
+    return this.relations.filter(
+      (relation) =>
+        relation.field[
+          `${action === 'filter' ? action : action.slice(0, -1)}able` as 'filterable' | 'creatable' | 'updatable'
+        ]
+    );
+  }
+
   public get reverseRelations() {
     if (!this._reverseRelations) {
       this._reverseRelations = this.models.entities.flatMap((model) =>
@@ -488,8 +501,7 @@ export class NormalRelation extends Relation {
 export class ReverseRelation extends Relation {
   constructor(public reverse: NormalRelation) {
     super(
-      reverse.field.reverse ||
-        (reverse.field.toOne ? typeToField(reverse.sourceModel.name) : reverse.sourceModel.pluralField),
+      reverse.field.reverse || (reverse.field.toOne ? reverse.sourceModel.asField : reverse.sourceModel.pluralField),
       reverse.targetModel,
       reverse.field,
       reverse.sourceModel
diff --git a/src/models/utils.ts b/src/models/utils.ts
index 47a1e32..6fb1150 100644
--- a/src/models/utils.ts
+++ b/src/models/utils.ts
@@ -1,6 +1,4 @@
-import assert from 'assert';
-import { camelCase, startCase } from 'lodash';
-import lodashGet from 'lodash/get';
+import { camelCase, lowerFirst, startCase } from 'lodash';
 import {
   CustomField,
   EntityField,
@@ -22,8 +20,7 @@ const isNotFalsy = <T>(v: T | null | undefined | false): v is T => typeof v !==
 export const merge = <T>(objects: ({ [name: string]: T } | undefined | false)[] | undefined): { [name: string]: T } =>
   (objects || []).filter(isNotFalsy).reduce((i, acc) => ({ ...acc, ...i }), {});
 
-// Target -> target
-export const typeToField = (type: string) => type.substr(0, 1).toLowerCase() + type.substr(1);
+export const typeToField = (type: string) => lowerFirst(type);
 
 export const getLabel = (s: string) => startCase(camelCase(s));
 
@@ -108,60 +105,6 @@ export const isUpdatableBy = (role: string) => (field: EntityField) =>
 export const isCreatableBy = (role: string) => (field: EntityField) =>
   field.creatable && (field.creatable === true || !field.creatable.roles || field.creatable.roles.includes(role));
 
-export const getActionableRelations = (model: EntityModel, action: 'create' | 'update' | 'filter') =>
-  model.relations
-    .filter(
-      (relation) =>
-        relation.field[
-          `${action === 'filter' ? action : action.slice(0, -1)}able` as 'filterable' | 'creatable' | 'updatable'
-        ]
-    )
-    .map(({ name }) => name);
-
-export const summonByName = <T extends { name: string }>(array: T[], value: string) => summonByKey(array, 'name', value);
-
-export const summonByKey = <T>(array: readonly T[] | undefined, key: string, value: unknown) =>
-  summon(array, (element: T) => lodashGet(element, key) === value, `No element found with ${key} ${value}`);
-
-export const summon = <T>(array: readonly T[] | undefined, cb: Parameters<T[]['find']>[1], errorMessage?: string) => {
-  if (array === undefined) {
-    console.trace();
-    throw new Error('Base array is not defined.');
-  }
-  const result = array.find(cb);
-  if (result === undefined) {
-    console.trace();
-    throw new Error(errorMessage || 'Element not found.');
-  }
-  return result;
-};
-
-type ForSure<T> = T extends undefined | null ? never : T;
-
-export const it = <T>(object: T | null | undefined): ForSure<T> => {
-  if (object === undefined || object === null) {
-    console.trace();
-    throw new Error('Base object is not defined.');
-  }
-
-  return object as ForSure<T>;
-};
-
-export const get = <T, U extends keyof ForSure<T>>(object: T | null | undefined, key: U): ForSure<ForSure<T>[U]> => {
-  const value = it(object)[key];
-  if (value === undefined || value === null) {
-    const error = new Error(`Object doesn't have ${String(key)}`);
-    console.warn(error);
-    throw error;
-  }
-  return value as ForSure<ForSure<T>[U]>;
-};
-
-export const getString = (v: unknown) => {
-  assert(typeof v === 'string');
-  return v;
-};
-
 export const retry = async <T>(cb: () => Promise<T>, condition: (e: any) => boolean) => {
   try {
     return await cb();
@@ -173,23 +116,3 @@ export const retry = async <T>(cb: () => Promise<T>, condition: (e: any) => bool
     }
   }
 };
-
-type Typeof = {
-  string: string;
-  number: number;
-  bigint: bigint;
-  boolean: boolean;
-  symbol: symbol;
-  undefined: undefined;
-  object: object;
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  function: Function;
-};
-
-export const as = <T extends keyof Typeof>(value: unknown, type: T): Typeof[T] => {
-  if (typeof value !== type) {
-    throw new Error(`No string`);
-  }
-
-  return value as Typeof[T];
-};
diff --git a/src/permissions/check.ts b/src/permissions/check.ts
index 726f20f..b5b3572 100644
--- a/src/permissions/check.ts
+++ b/src/permissions/check.ts
@@ -2,8 +2,9 @@ import { Knex } from 'knex';
 import { FullContext } from '../context';
 import { NotFoundError, PermissionError } from '../errors';
 import { EntityModel } from '../models/models';
-import { get, isRelation } from '../models/utils';
+import { isRelation } from '../models/utils';
 import { AliasGenerator, hash, ors } from '../resolvers/utils';
+import { get } from '../utils/getters';
 import { PermissionAction, PermissionLink, PermissionStack } from './generate';
 
 export const getRole = (ctx: Pick<FullContext, 'user'>) => ctx.user?.role ?? 'UNAUTHENTICATED';
diff --git a/src/resolvers/arguments.ts b/src/resolvers/arguments.ts
index b02a371..fca5d11 100644
--- a/src/resolvers/arguments.ts
+++ b/src/resolvers/arguments.ts
@@ -1,6 +1,6 @@
 import type { GraphQLObjectType, GraphQLSchema, TypeDefinitionNode, TypeNode, ValueNode } from 'graphql';
 import { Kind } from 'graphql';
-import { summonByKey } from '../models/utils';
+import { summonByKey } from '../utils/getters';
 import { Value } from '../values';
 import { FieldResolverNode } from './node';
 import { Maybe, VariableValues } from './utils';
diff --git a/src/resolvers/generate.ts b/src/resolvers/generate.ts
new file mode 100644
index 0000000..1df520d
--- /dev/null
+++ b/src/resolvers/generate.ts
@@ -0,0 +1,740 @@
+import CodeBlockWriter from 'code-block-writer';
+import { DATE_CLASS, DATE_CLASS_IMPORT, isRootModel, Models, not } from '..';
+import { EntityField } from '../models/models';
+import { isPrimitive } from '../models/utils';
+
+export const isEndOfDay = (field?: EntityField) =>
+  isPrimitive(field) && field.type === 'DateTime' && field?.endOfDay === true && field?.dateTimeType === 'date';
+
+export const generateResolvers = (
+  models: Models,
+  { dateLibrary, gqmModule }: { dateLibrary: string; gqmModule: string }
+) => {
+  const importWriter: CodeBlockWriter = new CodeBlockWriter['default']({
+    useSingleQuote: true,
+    indentNumberOfSpaces: 2,
+  });
+  const imported = new Set<string>();
+  const writeImport = (string: string) => {
+    if (!imported.has(string)) {
+      imported.add(string);
+      importWriter.writeLine(string);
+    }
+  };
+
+  importWriter.write(`
+    import { GraphQLResolveInfo } from 'graphql';
+    import { IncomingMessage } from 'http';
+    import { v4 as uuid } from 'uuid';
+    import { Knex } from 'knex';
+    import * as db from '../db';
+    import * as api from '../api';
+  `);
+  importWriter.writeLine(DATE_CLASS_IMPORT[dateLibrary]);
+  importWriter.writeLine(
+    `import { Models, Permissions, AliasGenerator, applyPermissions, queryResolver, getEntityToMutate, resolve, checkCanWrite, GraphQLError, ForbiddenError, anyDateToLuxon, EntityModel, get } from '${gqmModule}';`
+  );
+
+  const writer: CodeBlockWriter = new CodeBlockWriter['default']({
+    useSingleQuote: true,
+    indentNumberOfSpaces: 2,
+  });
+
+  writer.write(`
+    export type Entity = Record<string, unknown>;
+
+    export type Action = 'create' | 'update' | 'delete' | 'restore';
+
+    export type MutationHook = (
+      model: EntityModel,
+      action: Action,
+      when: 'before' | 'after',
+      data: { prev: Entity; input: Entity; normalizedInput: Entity; next: Entity },
+      ctx: Context
+    ) => Promise<void>;
+
+    export type User = { id: string; role: string };
+
+    export type Context = {
+      req: IncomingMessage;
+      now: ${DATE_CLASS[dateLibrary]};
+      timeZone?: string;
+      knex: Knex;
+      locale: string;
+      locales: string[];
+      user?: User;
+      models: Models;
+      permissions: Permissions;
+      mutationHook?: MutationHook;
+    };
+
+    export type FullContext = Context & {
+      info: GraphQLResolveInfo;
+      aliases: AliasGenerator;
+    };
+
+    type Callbacks = (() => Promise<void>)[];
+
+    type DeleteContext = {
+      model: EntityModel;
+      toDelete: { [type: string]: { [id: string]: string } };
+      toUnlink: {
+        [type: string]: {
+          [id: string]: {
+            display: string;
+            fields: string[];
+          };
+        };
+      };
+      dryRun: boolean;
+      beforeHooks: Callbacks;
+      mutations: Callbacks;
+      afterHooks: Callbacks;
+    };
+
+    type RestoreContext = {
+      entity: any;
+      model: EntityModel;
+      beforeHooks: Callbacks;
+      mutations: Callbacks;
+      afterHooks: Callbacks;
+    };
+  `);
+
+  importWriter.blankLine();
+
+  writer
+    .write(`export const resolvers = `)
+    .inlineBlock(() => {
+      writer
+        .write('Query: ')
+        .inlineBlock(() => {
+          writer.writeLine('me: queryResolver,');
+          for (const model of models.entities.filter(({ queriable }) => queriable)) {
+            writer.writeLine(`${model.asField}: queryResolver,`);
+          }
+          for (const model of models.entities.filter(({ listQueriable }) => listQueriable)) {
+            writer.writeLine(`${model.pluralField}: queryResolver,`);
+          }
+        })
+        .write(',')
+        .newLine();
+
+      const mutations = [
+        ...models.entities
+          .filter(not(isRootModel))
+          .filter(({ creatable }) => creatable)
+          .map((model) => () => {
+            writer
+              .writeLine(
+                `create${model.name}: async (_parent: unknown, { data: input }: api.MutationCreate${model.name}Args, partialCtx: Context, info: GraphQLResolveInfo) => `
+              )
+              .inlineBlock(() => {
+                writer
+                  .write(`return await partialCtx.knex.transaction(async (knex) => `)
+                  .inlineBlock(() => {
+                    writer.writeLine(
+                      `const ctx: FullContext = { ...partialCtx, knex, info, aliases: new AliasGenerator() };`
+                    );
+                    writer.writeLine(`const model = ctx.models.getModel('${model.name}', 'entity');`);
+                    writer.writeLine(
+                      `const normalizedInput: Partial<${
+                        model.rootModel
+                          ? `db.${model.rootModel.name}Initializer & db.${model.name}Initializer`
+                          : `db.${model.name}Initializer`
+                      }> = { ...input };`
+                    );
+                    writer.writeLine(`normalizedInput.id = uuid();`);
+                    writer.writeLine(`normalizedInput.createdAt = ctx.now;`);
+                    writer.writeLine(`normalizedInput.createdById = ctx.user?.id;`);
+                    if (model.parent) {
+                      writer.writeLine(`normalizedInput.type = '${model.name}';`);
+                    }
+                    if (model.updatable) {
+                      writer.writeLine(`normalizedInput.updatedAt = ctx.now;`);
+                      writer.writeLine(`normalizedInput.updatedById = ctx.user?.id;`);
+                    }
+
+                    for (const field of model.fields.filter((field) => field.creatable)) {
+                      if (isEndOfDay(field)) {
+                        writer
+                          .write(`if (normalizedInput.${field.name}) `)
+                          .inlineBlock(() => {
+                            writer.writeLine(
+                              `normalizedInput.${field.name} = anyDateToLuxon(normalizedInput.${field.name}, ctx.timeZone).endOf('day');`
+                            );
+                          })
+                          .blankLine();
+                      }
+
+                      if (field.list && field.kind === 'enum') {
+                        writer
+                          .write(`if (Array.isArray(normalizedInput.${field.name})) `)
+                          .inlineBlock(() => {
+                            writer.writeLine(
+                              `normalizedInput.${field.name} = \`{\${(normalizedInput.${field.name} as string[]).join(',')}}\`;`
+                            );
+                          })
+                          .blankLine();
+                        continue;
+                      }
+                    }
+
+                    writer.writeLine(`await checkCanWrite(ctx, model, normalizedInput, 'CREATE');`);
+
+                    writer.writeLine(`const data = { prev: {}, input, normalizedInput, next: normalizedInput }`);
+                    writer.writeLine(`await ctx.mutationHook?.(model, 'create', 'before', data, ctx);`);
+                    if (model.parent) {
+                      writeImport(`import { pick } from 'lodash';`);
+
+                      writer.writeLine(
+                        `const rootInput: Partial<db.${
+                          model.rootModel.name
+                        }Initializer> = pick(normalizedInput, ${model.fields
+                          .filter((field) => field.inherited)
+                          .map((field) => `'${field.kind === 'relation' ? `${field.name}Id` : field.name}'`)
+                          .join(', ')});`
+                      );
+                      writer.writeLine(
+                        `const childInput: Partial<db.${model.name}Initializer> = pick(normalizedInput, 'id', ${model.fields
+                          .filter((field) => !field.inherited)
+                          .map((field) => `'${field.kind === 'relation' ? `${field.name}Id` : field.name}'`)
+                          .join(', ')});`
+                      );
+                      writer.writeLine(`await knex(model.parent).insert(rootInput);`);
+                      writer.writeLine(`await knex(model.name).insert(childInput);`);
+                    } else {
+                      writer.writeLine(`await knex(model.name).insert(normalizedInput);`);
+                    }
+                    writer.writeLine(`await create${model.name}Revision(normalizedInput as db.Full${model.name}, ctx);`);
+                    writer.writeLine(`await ctx.mutationHook?.(model, 'create', 'after', data, ctx);`);
+
+                    writer.writeLine(`return await resolve(ctx, normalizedInput.id);`);
+                  })
+                  .write(');')
+                  .newLine();
+              })
+              .write(',')
+              .blankLine();
+          }),
+        ...models.entities
+          .filter(not(isRootModel))
+          .filter(({ updatable }) => updatable)
+          .map((model) => () => {
+            writer
+              .writeLine(
+                `update${model.name}: async (_parent: unknown, { where, data: input }: api.MutationUpdate${model.name}Args, partialCtx: Context, info: GraphQLResolveInfo) => `
+              )
+              .inlineBlock(() => {
+                writer
+                  .write(`return await partialCtx.knex.transaction(async (knex) => `)
+                  .inlineBlock(() => {
+                    writer.writeLine(
+                      `const ctx: FullContext = { ...partialCtx, knex, info, aliases: new AliasGenerator() };`
+                    );
+                    writer.writeLine(`const model = ctx.models.getModel('${model.name}', 'entity');`);
+                    writer.write(`if (Object.keys(where).length === 0) `).inlineBlock(() => {
+                      writer.writeLine(`throw new Error(\`No ${model.name} specified.\`);`);
+                    });
+
+                    writer.writeLine(
+                      `const normalizedInput: Partial<${
+                        model.rootModel
+                          ? `db.${model.rootModel.name}Mutator & db.${model.name}Mutator`
+                          : `db.${model.name}Mutator`
+                      }> = { ...input };`
+                    );
+                    if (model.updatable) {
+                      writer.writeLine(`normalizedInput.updatedAt = ctx.now;`);
+                      writer.writeLine(`normalizedInput.updatedById = ctx.user?.id;`);
+                    }
+
+                    for (const field of model.fields.filter((field) => field.updatable)) {
+                      if (isEndOfDay(field)) {
+                        writer
+                          .write(`if (normalizedInput.${field.name}) `)
+                          .inlineBlock(() => {
+                            writer.writeLine(
+                              `normalizedInput.${field.name} = anyDateToLuxon(normalizedInput.${field.name}, ctx.timeZone).endOf('day');`
+                            );
+                          })
+                          .blankLine();
+                      }
+
+                      if (field.list && field.kind === 'enum') {
+                        writer
+                          .write(`if (Array.isArray(normalizedInput.${field.name})) `)
+                          .inlineBlock(() => {
+                            writer.writeLine(
+                              `normalizedInput.${field.name} = \`{\${(normalizedInput.${field.name} as string[]).join(',')}}\`;`
+                            );
+                          })
+                          .blankLine();
+                        continue;
+                      }
+                    }
+
+                    writer.writeLine(`const prev = await getEntityToMutate(ctx, model, where, 'UPDATE');`);
+
+                    // Remove data that wouldn't mutate given that it's irrelevant for permissions
+                    writer
+                      .write(`for (const key of Object.keys(normalizedInput)) `)
+                      .inlineBlock(() => {
+                        writer.write(`if (normalizedInput[key] === prev[key]) `).inlineBlock(() => {
+                          writer.writeLine(`delete normalizedInput[key];`);
+                        });
+                      })
+                      .blankLine();
+
+                    writer
+                      .write(`if (Object.keys(normalizedInput).length > 0) `)
+                      .inlineBlock(() => {
+                        writer.writeLine(`await checkCanWrite(ctx, model, normalizedInput, 'UPDATE');`);
+
+                        writer.writeLine(`const next = { ...prev, ...normalizedInput };`);
+                        writer.writeLine(`const data = { prev, input, normalizedInput, next };`);
+                        writer.writeLine(`await ctx.mutationHook?.(model, 'update', 'before', data, ctx);`);
+
+                        if (model.parent) {
+                          writer.writeLine(
+                            `const rootInput: Partial<db.${
+                              model.rootModel.name
+                            }Initializer> = pick(normalizedInput, ${model.fields
+                              .filter((field) => field.inherited)
+                              .map((field) => `'${field.kind === 'relation' ? `${field.name}Id` : field.name}'`)
+                              .join(', ')});`
+                          );
+                          writer.writeLine(
+                            `const childInput: Partial<db.${
+                              model.name
+                            }Initializer> = pick(normalizedInput, 'id', ${model.fields
+                              .filter((field) => !field.inherited)
+                              .map((field) => `'${field.kind === 'relation' ? `${field.name}Id` : field.name}'`)
+                              .join(', ')});`
+                          );
+
+                          writer
+                            .write(`if (Object.keys(rootInput).length) `)
+                            .inlineBlock(() => {
+                              writer.write(`await ctx.knex(model.parent).where({ id: prev.id }).update(rootInput);`);
+                            })
+                            .blankLine();
+
+                          writer
+                            .write(`if (Object.keys(childInput).length) `)
+                            .inlineBlock(() => {
+                              writer.writeLine(`await ctx.knex(model.name).where({ id: prev.id }).update(childInput);`);
+                            })
+                            .blankLine();
+                        } else {
+                          writer.writeLine(`await ctx.knex(model.name).where({ id: prev.id }).update(normalizedInput);`);
+                        }
+
+                        writer.writeLine(`await create${model.name}Revision(next as db.Full${model.name}, ctx);`);
+                        writer.writeLine(`await ctx.mutationHook?.(model, 'update', 'after', data, ctx);`);
+                      })
+                      .blankLine();
+
+                    writer.writeLine(`return await resolve(ctx);`);
+                  })
+                  .write(');')
+                  .newLine();
+              })
+              .write(',')
+              .blankLine();
+          }),
+        ...models.entities
+          .filter(not(isRootModel))
+          .filter(({ deletable }) => deletable)
+          .flatMap((model) => () => {
+            writer
+              .writeLine(
+                `delete${model.name}: async (_parent: unknown, { where, dryRun }: api.MutationDelete${model.name}Args, partialCtx: Context, info: GraphQLResolveInfo) => `
+              )
+              .inlineBlock(() => {
+                writer
+                  .write(`return await partialCtx.knex.transaction(async (knex) => `)
+                  .inlineBlock(() => {
+                    writer.writeLine(
+                      `const ctx: FullContext = { ...partialCtx, knex, info, aliases: new AliasGenerator() };`
+                    );
+                    writer.writeLine(`const model = ctx.models.getModel('${model.name}', 'entity');`);
+
+                    writer
+                      .write(`if (Object.keys(where).length === 0) `)
+                      .inlineBlock(() => {
+                        writer.writeLine(`throw new Error(\`No ${model.name} specified.\`);`);
+                      })
+                      .blankLine();
+
+                    const rootModel = model.rootModel;
+                    writer.writeLine(`const rootModel = model.rootModel;`);
+                    writer.writeLine(`const entity = await getEntityToMutate(ctx, rootModel, where, 'DELETE');`);
+
+                    writer
+                      .write(`if (entity.deleted) `)
+                      .inlineBlock(() => {
+                        writer.writeLine(`throw new ForbiddenError('Entity is already deleted.');`);
+                      })
+                      .blankLine();
+
+                    writer.write(`const deleteContext: DeleteContext = `).inlineBlock(() => {
+                      writer.writeLine(`model,`);
+                      writer.writeLine(`dryRun: !!dryRun,`);
+                      writer.writeLine(`toDelete: {},`);
+                      writer.writeLine(`toUnlink: {},`);
+                      writer.writeLine(`beforeHooks: [],`);
+                      writer.writeLine(`mutations: [],`);
+                      writer.writeLine(`afterHooks: [],`);
+                    });
+
+                    writer.writeLine(`await delete${rootModel.name}Cascade(entity, ctx, deleteContext);`);
+
+                    writer
+                      .write(
+                        `for (const callback of [...deleteContext.beforeHooks, ...deleteContext.mutations, ...deleteContext.afterHooks]) `
+                      )
+                      .inlineBlock(() => {
+                        writer.writeLine(`await callback();`);
+                      })
+                      .blankLine();
+
+                    writer
+                      .write(`if (dryRun) `)
+                      .inlineBlock(() => {
+                        writer.write(`throw new GraphQLError(\`Delete dry run:\`, {
+                        code: 'DELETE_DRY_RUN',
+                        toDelete: deleteContext.toDelete,
+                        toUnlink: deleteContext.toUnlink,
+                      });`);
+                      })
+                      .blankLine();
+
+                    writer.writeLine(`return entity.id;`);
+                  })
+                  .write(');');
+              })
+              .write(',')
+              .blankLine();
+            writer
+              .writeLine(
+                `restore${model.name}:async (_parent: unknown, { where }: api.MutationRestore${model.name}Args, partialCtx: Context, info: GraphQLResolveInfo) => `
+              )
+              .inlineBlock(() => {
+                writer
+                  .write(`return await partialCtx.knex.transaction(async (knex) => `)
+                  .inlineBlock(() => {
+                    writer.writeLine(
+                      `const ctx: FullContext = { ...partialCtx, knex, info, aliases: new AliasGenerator() };`
+                    );
+                    writer.writeLine(`const model = ctx.models.getModel('${model.name}', 'entity');`);
+
+                    writer
+                      .write(`if (Object.keys(where).length === 0) `)
+                      .inlineBlock(() => {
+                        writer.writeLine(`throw new Error(\`No ${model.name} specified.\`);`);
+                      })
+                      .blankLine();
+
+                    const rootModel = model.rootModel;
+                    writer.writeLine(`const rootModel = model.rootModel;`);
+                    writer.writeLine(`const entity = await getEntityToMutate(ctx, rootModel, where, 'RESTORE');`);
+
+                    writer
+                      .write(`if (!entity.deleted) `)
+                      .inlineBlock(() => {
+                        writer.writeLine(`throw new ForbiddenError('Entity is not deleted.');`);
+                      })
+                      .blankLine();
+
+                    writer.write(`const restoreContext: RestoreContext = `).inlineBlock(() => {
+                      writer.writeLine(`entity,`);
+                      writer.writeLine(`model,`);
+                      writer.writeLine(`beforeHooks: [],`);
+                      writer.writeLine(`mutations: [],`);
+                      writer.writeLine(`afterHooks: [],`);
+                    });
+
+                    writer.writeLine(`await restore${rootModel.name}Cascade(entity, ctx, restoreContext);`);
+
+                    writer
+                      .write(
+                        `for (const callback of [...restoreContext.beforeHooks, ...restoreContext.mutations, ...restoreContext.afterHooks]) `
+                      )
+                      .inlineBlock(() => {
+                        writer.writeLine(`await callback();`);
+                      })
+                      .blankLine();
+
+                    writer.writeLine(`return entity.id;`);
+                  })
+                  .write(');');
+              })
+              .write(',')
+              .blankLine();
+          }),
+      ];
+
+      if (mutations) {
+        writer
+          .write('Mutation: ')
+          .inlineBlock(() => {
+            for (const mutation of mutations) {
+              mutation();
+            }
+          })
+          .write(',')
+          .newLine();
+      }
+
+      for (const model of models.entities.filter(isRootModel)) {
+        writer
+          .write(`${model.name}: `)
+          .inlineBlock(() => {
+            writer.writeLine('__resolveType: ({ TYPE }) => TYPE,');
+          })
+          .write(',')
+          .newLine();
+      }
+    })
+    .write(';')
+    .newLine()
+    .blankLine();
+
+  for (const model of models.entities.filter((model) => model.rootModel === model).filter((model) => model.deletable)) {
+    writer
+      .write(
+        `const delete${model.name}Cascade = async (entity: db.Full${model.name}, ctx: FullContext, deleteCtx: DeleteContext) => `
+      )
+      .inlineBlock(() => {
+        writer.writeLine(`
+          const currentModel = ctx.models.getModel('${model.name}', 'entity');
+          if (entity.deleted) {
+            return;
+          }
+          if (!('${model.name}' in deleteCtx.toDelete)) {
+            deleteCtx.toDelete['${model.name}'] = {};
+          }
+          if ((entity.id as string) in deleteCtx.toDelete['${model.name}']) {
+            return;
+          }
+
+          deleteCtx.toDelete['${model.name}'][entity.id as string] = (${
+          model.displayField ? `entity.${model.displayField} || entity.id` : 'entity.id'
+        }) as unknown as string;
+          
+          if (!deleteCtx.dryRun) {
+            const normalizedInput = { deleted: true, deletedAt: ctx.now, deletedById: ctx.user?.id };
+            const data = { prev: entity, input: {}, normalizedInput, next: { ...entity, ...normalizedInput } };
+            if (ctx.mutationHook) {
+              deleteCtx.beforeHooks.push(async () => {
+                await ctx.mutationHook?.(currentModel, 'delete', 'before', data, ctx);
+              });
+            }
+            deleteCtx.mutations.push(async () => {
+              await ctx.knex('${model.name}').where({ id: entity.id }).update(normalizedInput);
+              await create${model.name}Revision({ ...entity, deleted: true }, ctx);
+            });
+            if (ctx.mutationHook) {
+              deleteCtx.afterHooks.push(async () => {
+                await ctx.mutationHook?.(currentModel, 'delete', 'after', data, ctx);
+              });
+            }
+          }
+        `);
+
+        for (const { targetModel: descendantModel, field } of model.reverseRelations.filter(
+          (reverseRelation) => !reverseRelation.field.inherited
+        )) {
+          writer.block(() => {
+            writer.writeLine(
+              `const query = ctx.knex('${descendantModel.name}').where({ ['${field.foreignKey}']: entity.id });`
+            );
+            switch (field.onDelete) {
+              case 'set-null': {
+                writer.write(`
+                  const descendants = await query;
+                  for (const descendant of descendants) {
+                    if (deleteCtx.dryRun) {
+                      if (!deleteCtx.toUnlink['${descendantModel.name}']) {
+                        deleteCtx.toUnlink['${descendantModel.name}'] = {};
+                      }
+                      if (!deleteCtx.toUnlink['${descendantModel.name}'][descendant.id]) {
+                        deleteCtx.toUnlink['${descendantModel.name}'][descendant.id] = {
+                          display: descendant['${descendantModel.displayField || 'id'}'] || entity.id,
+                          fields: [],
+                        };
+                      }
+                      get(deleteCtx.toUnlink['${descendantModel.name}'], descendant.id).fields.push('${field.name}');
+                    } else {
+                      deleteCtx.mutations.push(async () => {
+                        await ctx
+                          .knex('${descendantModel.name}')
+                          .where({ id: descendant.id })
+                          .update({
+                            [\`${field.name}Id\`]: null,
+                          });
+                      });
+                    }
+                  }
+                `);
+                break;
+              }
+              case 'cascade':
+              default: {
+                writer.write(`
+                  applyPermissions(ctx, '${descendantModel.name}', '${descendantModel.name}', query, 'DELETE');
+                  const descendants = await query;
+                `);
+                if (!descendantModel.deletable) {
+                  writer.write(` 
+                    if (descendants.length && !descendantModel.deletable) {
+                      throw new ForbiddenError(\`This ${model.name} depends on a ${descendantModel.name} which cannot be deleted.\`);
+                    }
+                  `);
+                }
+                writer.write(`
+                  for (const descendant of descendants) {
+                    await delete${descendantModel.name}Cascade(descendant, ctx, deleteCtx);
+                  }
+                `);
+                break;
+              }
+            }
+          });
+        }
+      })
+      .write(';')
+      .blankLine();
+
+    writer
+      .write(
+        `export const restore${model.name}Cascade = async (
+          relatedEntity: db.${model.name},
+          ctx: FullContext,
+          restoreCtx: RestoreContext
+        ) => `
+      )
+      .inlineBlock(() => {
+        writer.writeLine(`
+            const currentModel = ctx.models.getModel('${model.name}', 'entity');
+            if (
+              !relatedEntity.deleted ||
+              !relatedEntity.deletedAt ||
+              !anyDateToLuxon(relatedEntity.deletedAt, ctx.timeZone)!.equals(anyDateToLuxon(restoreCtx.entity.deletedAt, ctx.timeZone)!)
+            ) {
+              return;
+            }
+    
+            const normalizedInput: Partial<db.${model.name}Mutator> = { deleted: false, deletedAt: null, deletedById: null };
+            const data = { prev: relatedEntity, input: {}, normalizedInput, next: { ...relatedEntity, ...normalizedInput } };
+            if (ctx.mutationHook) {
+              restoreCtx.beforeHooks.push(async () => {
+                await ctx.mutationHook?.(currentModel, 'restore', 'before', data, ctx);
+              });
+            }
+            restoreCtx.mutations.push(async () => {
+              await ctx.knex(currentModel.name).where({ id: relatedEntity.id }).update(normalizedInput);
+              await create${model.name}Revision({ ...relatedEntity, deleted: false }, ctx);
+            });
+            if (ctx.mutationHook) {
+              restoreCtx.afterHooks.push(async () => {
+                await ctx.mutationHook?.(currentModel, 'restore', 'after', data, ctx);
+              });
+            }
+          `);
+
+        for (const { targetModel: descendantModel, field } of model.reverseRelations
+          .filter((reverseRelation) => !reverseRelation.field.inherited)
+          .filter(({ targetModel: { deletable } }) => deletable)) {
+          writer
+            .block(() => {
+              writer.write(`
+                    const query = ctx.knex('${descendantModel.name}').where({ ['${field.foreignKey}']: relatedEntity.id });
+                    applyPermissions(ctx, '${descendantModel.name}', '${descendantModel.name}', query, 'RESTORE');
+                    const descendants = await query;
+                    for (const descendant of descendants) {
+                      await restore${descendantModel.name}Cascade(descendant, ctx, restoreCtx);
+                    }
+                  `);
+            })
+            .blankLine();
+        }
+      })
+      .write(';')
+      .blankLine();
+  }
+
+  for (const model of models.entities.filter((model) => model.updatable || model.deletable)) {
+    writer
+      .write(
+        `export const create${model.name}Revision = async (data: db.Full${model.name}, ctx: Pick<Context, 'knex' | 'now' | 'user'>) => `
+      )
+      .inlineBlock(() => {
+        if (!model.updatable) {
+          writer.writeLine(`// TODO: revisions for models that are deletable but not updatable...`);
+          return;
+        }
+
+        writer.writeLine(`
+          const revisionId = uuid();
+          const rootRevisionData: Entity = {
+            id: revisionId,
+            ['${`${model.parent ? model.parentModel.asField : model.asField}Id`}']: data.id,
+            createdAt: ctx.now,
+            createdById: ctx.user?.id,
+          };
+          `);
+
+        if (model.deletable) {
+          writer.writeLine(`rootRevisionData.deleted = data.deleted || false;`);
+        }
+
+        if (model.parent) {
+          writer.writeLine(`
+            const childRevisionData = { id: revisionId };
+          `);
+        }
+
+        for (const field of model.fields.filter(({ updatable }) => updatable)) {
+          writer.block(() => {
+            const col = field.kind === 'relation' ? `${field.name}Id` : field.name;
+            if (field.nonNull) {
+              if (col === undefined || col === null) {
+                writer.writeLine(field.defaultValue ? `const value = ${field.defaultValue}` : 'throw new Error()');
+              } else {
+                writer.writeLine(`
+                  let value;
+                    if (!('${col}' in data)) {
+                      ${field.defaultValue ? `value = '${field.defaultValue}'` : 'throw new Error()'};
+                    } else {
+                      value = data['${col}'];
+                    }
+                  `);
+              }
+            } else {
+              writer.writeLine(`const value = data['${col}'];`);
+            }
+            if (!model.parent || field.inherited) {
+              writer.writeLine(`rootRevisionData['${col}'] = value;`);
+            } else {
+              writer.writeLine(`childRevisionData['${col}'] = value;`);
+            }
+          });
+        }
+
+        if (model.parent) {
+          writer.writeLine(`
+              await ctx.knex('${model.parent}Revision').insert(rootRevisionData);
+              await ctx.knex('${model.name}Revision').insert(childRevisionData);
+            `);
+        } else {
+          writer.writeLine(`await ctx.knex('${model.name}Revision').insert(rootRevisionData);`);
+        }
+      })
+      .write(`;`)
+      .blankLine();
+  }
+
+  return importWriter.toString() + writer.toString();
+};
diff --git a/src/resolvers/index.ts b/src/resolvers/index.ts
index b304d8e..46efe24 100644
--- a/src/resolvers/index.ts
+++ b/src/resolvers/index.ts
@@ -2,9 +2,8 @@
 
 export * from './arguments';
 export * from './filters';
-export * from './mutations';
+export * from './generate';
 export * from './node';
 export * from './resolver';
-export * from './resolvers';
 export * from './selects';
 export * from './utils';
diff --git a/src/resolvers/mutations.ts b/src/resolvers/mutations.ts
deleted file mode 100644
index 882aa62..0000000
--- a/src/resolvers/mutations.ts
+++ /dev/null
@@ -1,384 +0,0 @@
-import { GraphQLResolveInfo } from 'graphql';
-import { v4 as uuid } from 'uuid';
-import { Context, FullContext } from '../context';
-import { ForbiddenError, GraphQLError } from '../errors';
-import { EntityField, EntityModel } from '../models/models';
-import { Entity } from '../models/mutation-hook';
-import { get, isPrimitive, it, typeToField } from '../models/utils';
-import { applyPermissions, checkCanWrite, getEntityToMutate } from '../permissions/check';
-import { anyDateToLuxon } from '../utils';
-import { resolve } from './resolver';
-import { AliasGenerator } from './utils';
-
-export const mutationResolver = async (_parent: any, args: any, partialCtx: Context, info: GraphQLResolveInfo) => {
-  return await partialCtx.knex.transaction(async (knex) => {
-    const [, mutation, modelName] = it(info.fieldName.match(/^(create|update|delete|restore)(.+)$/));
-    const ctx = { ...partialCtx, knex, info, aliases: new AliasGenerator() };
-    const model = ctx.models.getModel(modelName, 'entity');
-    switch (mutation) {
-      case 'create':
-        return await create(model, args, ctx);
-      case 'update':
-        return await update(model, args, ctx);
-      case 'delete':
-        return await del(model, args, ctx);
-      case 'restore':
-        return await restore(model, args, ctx);
-    }
-  });
-};
-
-const create = async (model: EntityModel, { data: input }: { data: any }, ctx: FullContext) => {
-  const normalizedInput = { ...input };
-  normalizedInput.id = uuid();
-  normalizedInput.createdAt = ctx.now;
-  normalizedInput.createdById = ctx.user?.id;
-  if (model.parent) {
-    normalizedInput.type = model.name;
-  }
-  sanitize(ctx, model, normalizedInput);
-
-  await checkCanWrite(ctx, model, normalizedInput, 'CREATE');
-  await ctx.handleUploads?.(normalizedInput);
-
-  const data = { prev: {}, input, normalizedInput, next: normalizedInput };
-  await ctx.mutationHook?.(model, 'create', 'before', data, ctx);
-  if (model.parent) {
-    const rootInput = {};
-    const childInput = { id: normalizedInput.id };
-    for (const field of model.fields) {
-      const columnName = field.kind === 'relation' ? `${field.name}Id` : field.name;
-      if (columnName in normalizedInput) {
-        if (field.inherited) {
-          rootInput[columnName] = normalizedInput[columnName];
-        } else {
-          childInput[columnName] = normalizedInput[columnName];
-        }
-      }
-    }
-    await ctx.knex(model.parent).insert(rootInput);
-    await ctx.knex(model.name).insert(childInput);
-  } else {
-    await ctx.knex(model.name).insert(normalizedInput);
-  }
-  await createRevision(model, normalizedInput, ctx);
-  await ctx.mutationHook?.(model, 'create', 'after', data, ctx);
-
-  return await resolve(ctx, normalizedInput.id);
-};
-
-const update = async (model: EntityModel, { where, data: input }: { where: any; data: any }, ctx: FullContext) => {
-  if (Object.keys(where).length === 0) {
-    throw new Error(`No ${model.name} specified.`);
-  }
-
-  const normalizedInput = { ...input };
-
-  sanitize(ctx, model, normalizedInput);
-
-  const prev = await getEntityToMutate(ctx, model, where, 'UPDATE');
-
-  // Remove data that wouldn't mutate given that it's irrelevant for permissions
-  for (const key of Object.keys(normalizedInput)) {
-    if (normalizedInput[key] === prev[key]) {
-      delete normalizedInput[key];
-    }
-  }
-
-  if (Object.keys(normalizedInput).length > 0) {
-    await checkCanWrite(ctx, model, normalizedInput, 'UPDATE');
-    await ctx.handleUploads?.(normalizedInput);
-
-    const next = { ...prev, ...normalizedInput };
-    const data = { prev, input, normalizedInput, next };
-    await ctx.mutationHook?.(model, 'update', 'before', data, ctx);
-
-    if (model.parent) {
-      const rootInput = {};
-      const childInput = {};
-      for (const field of model.fields) {
-        const columnName = field.kind === 'relation' ? `${field.name}Id` : field.name;
-        if (columnName in normalizedInput) {
-          if (field.inherited) {
-            rootInput[columnName] = normalizedInput[columnName];
-          } else {
-            childInput[columnName] = normalizedInput[columnName];
-          }
-        }
-      }
-      if (Object.keys(rootInput).length) {
-        await ctx.knex(model.parent).where({ id: prev.id }).update(rootInput);
-      }
-      if (Object.keys(childInput).length) {
-        await ctx.knex(model.name).where({ id: prev.id }).update(childInput);
-      }
-    } else {
-      await ctx.knex(model.name).where({ id: prev.id }).update(normalizedInput);
-    }
-
-    await createRevision(model, next, ctx);
-    await ctx.mutationHook?.(model, 'update', 'after', data, ctx);
-  }
-
-  return await resolve(ctx);
-};
-
-type Callbacks = (() => Promise<void>)[];
-
-const del = async (model: EntityModel, { where, dryRun }: { where: any; dryRun: boolean }, ctx: FullContext) => {
-  if (Object.keys(where).length === 0) {
-    throw new Error(`No ${model.name} specified.`);
-  }
-
-  const rootModel = model.rootModel;
-  const entity = await getEntityToMutate(ctx, rootModel, where, 'DELETE');
-
-  if (entity.deleted) {
-    throw new ForbiddenError('Entity is already deleted.');
-  }
-
-  const toDelete: { [type: string]: { [id: string]: string } } = {};
-  const toUnlink: {
-    [type: string]: {
-      [id: string]: {
-        display: string;
-        fields: string[];
-      };
-    };
-  } = {};
-
-  const beforeHooks: Callbacks = [];
-  const mutations: Callbacks = [];
-  const afterHooks: Callbacks = [];
-
-  const deleteCascade = async (currentModel: EntityModel, entity: Entity) => {
-    if (entity.deleted) {
-      return;
-    }
-
-    if (!(currentModel.name in toDelete)) {
-      toDelete[currentModel.name] = {};
-    }
-    if ((entity.id as string) in toDelete[currentModel.name]) {
-      return;
-    }
-    toDelete[currentModel.name][entity.id as string] = (entity[currentModel.displayField || 'id'] || entity.id) as string;
-
-    if (!dryRun) {
-      const normalizedInput = { deleted: true, deletedAt: ctx.now, deletedById: ctx.user?.id };
-      const data = { prev: entity, input: {}, normalizedInput, next: { ...entity, ...normalizedInput } };
-      if (ctx.mutationHook) {
-        beforeHooks.push(async () => {
-          await ctx.mutationHook(currentModel, 'delete', 'before', data, ctx);
-        });
-      }
-      mutations.push(async () => {
-        await ctx.knex(currentModel.name).where({ id: entity.id }).update(normalizedInput);
-        await createRevision(currentModel, { ...entity, deleted: true }, ctx);
-      });
-      if (ctx.mutationHook) {
-        afterHooks.push(async () => {
-          await ctx.mutationHook(currentModel, 'delete', 'after', data, ctx);
-        });
-      }
-    }
-
-    for (const {
-      targetModel: descendantModel,
-      field: { name, foreignKey, onDelete },
-    } of currentModel.reverseRelations.filter((reverseRelation) => !reverseRelation.field.inherited)) {
-      const query = ctx.knex(descendantModel.name).where({ [foreignKey]: entity.id });
-      switch (onDelete) {
-        case 'set-null': {
-          const descendants = await query;
-          for (const descendant of descendants) {
-            if (dryRun) {
-              if (!toUnlink[descendantModel.name]) {
-                toUnlink[descendantModel.name] = {};
-              }
-              if (!toUnlink[descendantModel.name][descendant.id]) {
-                toUnlink[descendantModel.name][descendant.id] = {
-                  display: descendant[descendantModel.displayField || 'id'] || entity.id,
-                  fields: [],
-                };
-              }
-              toUnlink[descendantModel.name][descendant.id].fields.push(name);
-            } else {
-              mutations.push(async () => {
-                await ctx
-                  .knex(descendantModel.name)
-                  .where({ id: descendant.id })
-                  .update({
-                    [`${name}Id`]: null,
-                  });
-              });
-            }
-          }
-          break;
-        }
-        case 'cascade':
-        default: {
-          applyPermissions(ctx, descendantModel.name, descendantModel.name, query, 'DELETE');
-          const descendants = await query;
-          if (descendants.length && !descendantModel.deletable) {
-            throw new ForbiddenError(`This ${model.name} depends on a ${descendantModel.name} which cannot be deleted.`);
-          }
-          for (const descendant of descendants) {
-            await deleteCascade(descendantModel, descendant);
-          }
-          break;
-        }
-      }
-    }
-  };
-
-  await deleteCascade(rootModel, entity);
-
-  for (const callback of [...beforeHooks, ...mutations, ...afterHooks]) {
-    await callback();
-  }
-
-  if (dryRun) {
-    throw new GraphQLError(`Delete dry run:`, {
-      code: 'DELETE_DRY_RUN',
-      toDelete,
-      toUnlink,
-    });
-  }
-
-  return entity.id;
-};
-
-const restore = async (model: EntityModel, { where }: { where: any }, ctx: FullContext) => {
-  if (Object.keys(where).length === 0) {
-    throw new Error(`No ${model.name} specified.`);
-  }
-
-  const rootModel = model.rootModel;
-
-  const entity = await getEntityToMutate(ctx, rootModel, where, 'RESTORE');
-
-  if (!entity.deleted) {
-    throw new ForbiddenError('Entity is not deleted.');
-  }
-
-  const beforeHooks: Callbacks = [];
-  const mutations: Callbacks = [];
-  const afterHooks: Callbacks = [];
-
-  const restoreCascade = async (currentModel: EntityModel, relatedEntity: Entity) => {
-    if (
-      !relatedEntity.deleted ||
-      !relatedEntity.deletedAt ||
-      !anyDateToLuxon(relatedEntity.deletedAt, ctx.timeZone).equals(anyDateToLuxon(entity.deletedAt, ctx.timeZone))
-    ) {
-      return;
-    }
-
-    const normalizedInput: Entity = { deleted: false, deletedAt: null, deletedById: null };
-    const data = { prev: relatedEntity, input: {}, normalizedInput, next: { ...relatedEntity, ...normalizedInput } };
-    if (ctx.mutationHook) {
-      beforeHooks.push(async () => {
-        await ctx.mutationHook(currentModel, 'restore', 'before', data, ctx);
-      });
-    }
-    mutations.push(async () => {
-      await ctx.knex(currentModel.name).where({ id: relatedEntity.id }).update(normalizedInput);
-      await createRevision(currentModel, { ...relatedEntity, deleted: false }, ctx);
-    });
-    if (ctx.mutationHook) {
-      afterHooks.push(async () => {
-        await ctx.mutationHook(currentModel, 'restore', 'after', data, ctx);
-      });
-    }
-
-    for (const {
-      targetModel: descendantModel,
-      field: { foreignKey },
-    } of currentModel.reverseRelations
-      .filter((reverseRelation) => !reverseRelation.field.inherited)
-      .filter(({ targetModel: { deletable } }) => deletable)) {
-      const query = ctx.knex(descendantModel.name).where({ [foreignKey]: relatedEntity.id });
-      applyPermissions(ctx, descendantModel.name, descendantModel.name, query, 'RESTORE');
-      const descendants = await query;
-      for (const descendant of descendants) {
-        await restoreCascade(descendantModel, descendant);
-      }
-    }
-  };
-
-  await restoreCascade(rootModel, entity);
-
-  for (const callback of [...beforeHooks, ...mutations, ...afterHooks]) {
-    await callback();
-  }
-
-  return entity.id;
-};
-
-export const createRevision = async (model: EntityModel, data: Entity, ctx: Pick<Context, 'knex' | 'now' | 'user'>) => {
-  if (model.updatable) {
-    const revisionId = uuid();
-    const rootRevisionData: Entity = {
-      id: revisionId,
-      [`${typeToField(model.parent || model.name)}Id`]: data.id,
-      createdAt: ctx.now,
-      createdById: ctx.user?.id,
-    };
-
-    if (model.deletable) {
-      rootRevisionData.deleted = data.deleted || false;
-    }
-    const childRevisionData = { id: revisionId };
-
-    for (const field of model.fields.filter(({ updatable }) => updatable)) {
-      const col = field.kind === 'relation' ? `${field.name}Id` : field.name;
-      let value;
-      if (field.nonNull && (!(col in data) || col === undefined || col === null)) {
-        value = get(field, 'defaultValue');
-      } else {
-        value = data[col];
-      }
-      if (!model.parent || field.inherited) {
-        rootRevisionData[col] = value;
-      } else {
-        childRevisionData[col] = value;
-      }
-    }
-
-    if (model.parent) {
-      await ctx.knex(`${model.parent}Revision`).insert(rootRevisionData);
-      await ctx.knex(`${model.name}Revision`).insert(childRevisionData);
-    } else {
-      await ctx.knex(`${model.name}Revision`).insert(rootRevisionData);
-    }
-  }
-};
-
-const sanitize = (ctx: FullContext, model: EntityModel, data: Entity) => {
-  if (model.updatable) {
-    data.updatedAt = ctx.now;
-    data.updatedById = ctx.user?.id;
-  }
-
-  for (const key of Object.keys(data)) {
-    const field = model.fields.find(({ name }) => name === key);
-
-    if (!field) {
-      continue;
-    }
-
-    if (isEndOfDay(field) && data[key]) {
-      data[key] = anyDateToLuxon(data[key], ctx.timeZone).endOf('day');
-      continue;
-    }
-
-    if (field.list && field.kind === 'enum' && Array.isArray(data[key])) {
-      data[key] = `{${(data[key] as string[]).join(',')}}`;
-      continue;
-    }
-  }
-};
-
-const isEndOfDay = (field?: EntityField) =>
-  isPrimitive(field) && field.type === 'DateTime' && field?.endOfDay === true && field?.dateTimeType === 'date';
diff --git a/src/resolvers/node.ts b/src/resolvers/node.ts
index e55a401..037604c 100644
--- a/src/resolvers/node.ts
+++ b/src/resolvers/node.ts
@@ -9,7 +9,8 @@ import type {
 
 import { FullContext } from '../context';
 import { EntityModel, Relation } from '../models/models';
-import { get, isObjectModel, summonByKey } from '../models/utils';
+import { isObjectModel } from '../models/utils';
+import { get, summonByKey } from '../utils/getters';
 import {
   getFragmentTypeName,
   getNameOrAlias,
diff --git a/src/resolvers/resolver.ts b/src/resolvers/resolver.ts
index f570d11..9fc23e6 100644
--- a/src/resolvers/resolver.ts
+++ b/src/resolvers/resolver.ts
@@ -4,9 +4,10 @@ import cloneDeep from 'lodash/cloneDeep';
 import flatMap from 'lodash/flatMap';
 import { Context, FullContext } from '../context';
 import { NotFoundError } from '../errors';
-import { get, summonByKey } from '../models/utils';
 import { applyPermissions } from '../permissions/check';
 import { PermissionStack } from '../permissions/generate';
+import { AnyDateType } from '../utils';
+import { get, summonByKey } from '../utils/getters';
 import { applyFilters } from './filters';
 import { FieldResolverNode, ResolverNode, getFragmentSpreads, getInlineFragments, getJoins, getRootFieldNode } from './node';
 import { applySelects } from './selects';
@@ -15,7 +16,7 @@ import { AliasGenerator, Entry, ID_ALIAS, Joins, applyJoins, getColumn, getNameO
 export const queryResolver = (_parent: any, _args: any, ctx: Context, info: GraphQLResolveInfo) =>
   resolve({ ...ctx, info, aliases: new AliasGenerator() });
 
-export const resolve = async (ctx: FullContext, id?: string) => {
+export const resolve = async <DateType extends AnyDateType = AnyDateType>(ctx: FullContext<DateType>, id?: string) => {
   const fieldNode = summonByKey(ctx.info.fieldNodes, 'name.value', ctx.info.fieldName);
   const baseTypeDefinition = get(
     ctx.info.operation.operation === 'query' ? ctx.info.schema.getQueryType() : ctx.info.schema.getMutationType(),
diff --git a/src/resolvers/resolvers.ts b/src/resolvers/resolvers.ts
deleted file mode 100644
index f25dbad..0000000
--- a/src/resolvers/resolvers.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-import { Models } from '../models/models';
-import { isRootModel, merge, not, typeToField } from '../models/utils';
-import { mutationResolver } from './mutations';
-import { queryResolver } from './resolver';
-
-export const getResolvers = (models: Models) => {
-  const resolvers: Record<string, any> = {
-    Query: merge([
-      {
-        me: queryResolver,
-      },
-      ...models.entities
-        .filter(({ queriable }) => queriable)
-        .map((model) => ({
-          [typeToField(model.name)]: queryResolver,
-        })),
-      ...models.entities
-        .filter(({ listQueriable }) => listQueriable)
-        .map((model) => ({
-          [model.pluralField]: queryResolver,
-        })),
-    ]),
-  };
-  const mutations = [
-    ...models.entities
-      .filter(not(isRootModel))
-      .filter(({ creatable }) => creatable)
-      .map((model) => ({
-        [`create${model.name}`]: mutationResolver,
-      })),
-    ...models.entities
-      .filter(not(isRootModel))
-      .filter(({ updatable }) => updatable)
-      .map((model) => ({
-        [`update${model.name}`]: mutationResolver,
-      })),
-    ...models.entities
-      .filter(not(isRootModel))
-      .filter(({ deletable }) => deletable)
-      .map((model) => ({
-        [`delete${model.name}`]: mutationResolver,
-        [`restore${model.name}`]: mutationResolver,
-      })),
-  ];
-
-  if (mutations.length) {
-    resolvers.Mutation = merge<unknown>(mutations);
-  }
-
-  for (const model of models.entities.filter(isRootModel)) {
-    resolvers[model.name] = {
-      __resolveType: ({ TYPE }) => TYPE,
-    };
-  }
-
-  return resolvers;
-};
diff --git a/src/resolvers/utils.ts b/src/resolvers/utils.ts
index 1752e94..77027a9 100644
--- a/src/resolvers/utils.ts
+++ b/src/resolvers/utils.ts
@@ -14,7 +14,7 @@ import { Knex } from 'knex';
 import { isEqual } from 'lodash';
 import { EntityField } from '..';
 import { UserInputError } from '../errors';
-import { get, it } from '../models/utils';
+import { get, it } from '../utils/getters';
 import { Value } from '../values';
 import { FieldResolverNode, ResolverNode } from './node';
 
diff --git a/src/schema/generate.ts b/src/schema/generate.ts
index 8977bb7..64aafd6 100644
--- a/src/schema/generate.ts
+++ b/src/schema/generate.ts
@@ -1,6 +1,6 @@
 import { DefinitionNode, DocumentNode, GraphQLSchema, buildASTSchema, print } from 'graphql';
 import { Models } from '../models/models';
-import { isQueriableField, isRootModel, typeToField } from '../models/utils';
+import { isQueriableField, isRootModel } from '../models/utils';
 import { Field, document, enm, iface, input, object, scalar } from './utils';
 
 export const generateDefinitions = ({
@@ -174,14 +174,14 @@ export const generateDefinitions = ({
       },
       ...entities
         .filter(({ queriable }) => queriable)
-        .map(({ name }) => ({
-          name: typeToField(name),
-          type: name,
+        .map((model) => ({
+          name: model.asField,
+          type: model.name,
           nonNull: true,
           args: [
             {
               name: 'where',
-              type: `${name}WhereUnique`,
+              type: `${model.name}WhereUnique`,
               nonNull: true,
             },
           ],
@@ -308,3 +308,7 @@ export const printSchema = (schema: GraphQLSchema): string =>
 export const printSchemaFromDocument = (document: DocumentNode) => printSchema(buildASTSchema(document));
 
 export const printSchemaFromModels = (models: Models) => printSchema(buildASTSchema(generate(models)));
+
+export const printSchemaAsVariables = (models: Models) => {
+  return `import { gql } from 'graphql-request';\n\nexport const typeDefs = gql\`${printSchemaFromModels(models)}\`;\n`;
+};
diff --git a/src/utils/getters.ts b/src/utils/getters.ts
new file mode 100644
index 0000000..acfcb50
--- /dev/null
+++ b/src/utils/getters.ts
@@ -0,0 +1,46 @@
+import assert from 'assert';
+import lodashGet from 'lodash/get';
+
+export const summonByName = <T extends { name: string }>(array: T[], value: string) => summonByKey(array, 'name', value);
+
+export const summonByKey = <T>(array: readonly T[] | undefined, key: string, value: unknown) =>
+  summon(array, (element: T) => lodashGet(element, key) === value, `No element found with ${key} ${value}`);
+
+export const summon = <T>(array: readonly T[] | undefined, cb: Parameters<T[]['find']>[1], errorMessage?: string) => {
+  if (array === undefined) {
+    console.trace();
+    throw new Error('Base array is not defined.');
+  }
+  const result = array.find(cb);
+  if (result === undefined) {
+    console.trace();
+    throw new Error(errorMessage || 'Element not found.');
+  }
+  return result;
+};
+
+type ForSure<T> = T extends undefined | null ? never : T;
+
+export const it = <T>(object: T | null | undefined): ForSure<T> => {
+  if (object === undefined || object === null) {
+    console.trace();
+    throw new Error('Base object is not defined.');
+  }
+
+  return object as ForSure<T>;
+};
+
+export const get = <T, U extends keyof ForSure<T>>(object: T | null | undefined, key: U): ForSure<ForSure<T>[U]> => {
+  const value = it(object)[key];
+  if (value === undefined || value === null) {
+    const error = new Error(`Object doesn't have ${String(key)}`);
+    console.warn(error);
+    throw error;
+  }
+  return value as ForSure<ForSure<T>[U]>;
+};
+
+export const getString = (v: unknown) => {
+  assert(typeof v === 'string');
+  return v;
+};
diff --git a/src/utils/index.ts b/src/utils/index.ts
index 24f77ca..735af42 100644
--- a/src/utils/index.ts
+++ b/src/utils/index.ts
@@ -1,3 +1,4 @@
 // created from 'create-ts-index'
 
 export * from './dates';
+export * from './getters';
diff --git a/tests/api/__snapshots__/inheritance.spec.ts.snap b/tests/api/__snapshots__/inheritance.spec.ts.snap
index 81f85ce..8cfc731 100644
--- a/tests/api/__snapshots__/inheritance.spec.ts.snap
+++ b/tests/api/__snapshots__/inheritance.spec.ts.snap
@@ -11,13 +11,13 @@ exports[`inheritance mutations create 1`] = `
 
 exports[`inheritance mutations delete and restore 1`] = `
 {
-  "deleteReview": "817c55de-2f77-4159-bd44-9837d868f889",
+  "mutated": "817c55de-2f77-4159-bd44-9837d868f889",
 }
 `;
 
 exports[`inheritance mutations delete and restore 2`] = `
 {
-  "restoreReview": "817c55de-2f77-4159-bd44-9837d868f889",
+  "mutated": "817c55de-2f77-4159-bd44-9837d868f889",
 }
 `;
 
diff --git a/tests/api/delete.spec.ts b/tests/api/delete.spec.ts
index ebe2cb1..4ce7c7d 100644
--- a/tests/api/delete.spec.ts
+++ b/tests/api/delete.spec.ts
@@ -1,4 +1,4 @@
-import { gql } from '../../src';
+import { gql } from 'graphql-request';
 import { ANOTHER_ID } from '../utils/database/seed';
 import { withServer } from '../utils/server';
 
diff --git a/tests/api/inheritance.spec.ts b/tests/api/inheritance.spec.ts
index b680471..3b5fec0 100644
--- a/tests/api/inheritance.spec.ts
+++ b/tests/api/inheritance.spec.ts
@@ -1,4 +1,4 @@
-import { gql } from '../../src';
+import { gql } from 'graphql-request';
 import { DELETE_REVIEW, RESTORE_REVIEW } from '../generated/client/mutations';
 import { REVIEW_ID } from '../utils/database/seed';
 import { withServer } from '../utils/server';
diff --git a/tests/api/query.spec.ts b/tests/api/query.spec.ts
index 8db072b..d775827 100644
--- a/tests/api/query.spec.ts
+++ b/tests/api/query.spec.ts
@@ -1,4 +1,4 @@
-import { gql } from '../../src';
+import { gql } from 'graphql-request';
 import { ANOTHER_ID, SOME_ID, SOME_ID_2 } from '../utils/database/seed';
 import { withServer } from '../utils/server';
 
diff --git a/tests/generated/api/index.ts b/tests/generated/api/index.ts
index 4193545..ff5055f 100644
--- a/tests/generated/api/index.ts
+++ b/tests/generated/api/index.ts
@@ -10,13 +10,13 @@ export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' |
 export type RequireFields<T, K extends keyof T> = Omit<T, K> & { [P in K]-?: NonNullable<T[P]> };
 /** All built-in and custom scalars, mapped to their actual values */
 export type Scalars = {
-  ID: { input: string; output: string; }
-  String: { input: string; output: string; }
-  Boolean: { input: boolean; output: boolean; }
-  Int: { input: number; output: number; }
-  Float: { input: number; output: number; }
-  DateTime: { input: DateTime; output: DateTime; }
-  Upload: { input: any; output: any; }
+  ID: { input: string; output: string };
+  String: { input: string; output: string };
+  Boolean: { input: boolean; output: boolean };
+  Int: { input: number; output: number };
+  Float: { input: number; output: number };
+  DateTime: { input: DateTime; output: DateTime };
+  Upload: { input: any; output: any };
 };
 
 export type AnotherObject = {
@@ -31,7 +31,6 @@ export type AnotherObject = {
   self?: Maybe<AnotherObject>;
 };
 
-
 export type AnotherObjectManyObjectsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -40,7 +39,6 @@ export type AnotherObjectManyObjectsArgs = {
   where?: InputMaybe<SomeObjectWhere>;
 };
 
-
 export type AnotherObjectSelfArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -86,7 +84,6 @@ export type Answer = Reaction & {
   updatedBy: User;
 };
 
-
 export type AnswerChildAnswersArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -94,7 +91,6 @@ export type AnswerChildAnswersArgs = {
   where?: InputMaybe<AnswerWhere>;
 };
 
-
 export type AnswerChildQuestionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -102,7 +98,6 @@ export type AnswerChildQuestionsArgs = {
   where?: InputMaybe<QuestionWhere>;
 };
 
-
 export type AnswerChildReactionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -110,7 +105,6 @@ export type AnswerChildReactionsArgs = {
   where?: InputMaybe<ReactionWhere>;
 };
 
-
 export type AnswerChildReviewsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -175,100 +169,82 @@ export type Mutation = {
   updateSomeObject: SomeObject;
 };
 
-
 export type MutationCreateAnswerArgs = {
   data: CreateAnswer;
 };
 
-
 export type MutationCreateQuestionArgs = {
   data: CreateQuestion;
 };
 
-
 export type MutationCreateReviewArgs = {
   data: CreateReview;
 };
 
-
 export type MutationCreateSomeObjectArgs = {
   data: CreateSomeObject;
 };
 
-
 export type MutationDeleteAnotherObjectArgs = {
   dryRun?: InputMaybe<Scalars['Boolean']['input']>;
   where: AnotherObjectWhereUnique;
 };
 
-
 export type MutationDeleteAnswerArgs = {
   dryRun?: InputMaybe<Scalars['Boolean']['input']>;
   where: AnswerWhereUnique;
 };
 
-
 export type MutationDeleteQuestionArgs = {
   dryRun?: InputMaybe<Scalars['Boolean']['input']>;
   where: QuestionWhereUnique;
 };
 
-
 export type MutationDeleteReviewArgs = {
   dryRun?: InputMaybe<Scalars['Boolean']['input']>;
   where: ReviewWhereUnique;
 };
 
-
 export type MutationDeleteSomeObjectArgs = {
   dryRun?: InputMaybe<Scalars['Boolean']['input']>;
   where: SomeObjectWhereUnique;
 };
 
-
 export type MutationRestoreAnotherObjectArgs = {
   where: AnotherObjectWhereUnique;
 };
 
-
 export type MutationRestoreAnswerArgs = {
   where: AnswerWhereUnique;
 };
 
-
 export type MutationRestoreQuestionArgs = {
   where: QuestionWhereUnique;
 };
 
-
 export type MutationRestoreReviewArgs = {
   where: ReviewWhereUnique;
 };
 
-
 export type MutationRestoreSomeObjectArgs = {
   where: SomeObjectWhereUnique;
 };
 
-
 export type MutationUpdateAnswerArgs = {
   data: UpdateAnswer;
   where: AnswerWhereUnique;
 };
 
-
 export type MutationUpdateQuestionArgs = {
   data: UpdateQuestion;
   where: QuestionWhereUnique;
 };
 
-
 export type MutationUpdateReviewArgs = {
   data: UpdateReview;
   where: ReviewWhereUnique;
 };
 
-
 export type MutationUpdateSomeObjectArgs = {
   data: UpdateSomeObject;
   where: SomeObjectWhereUnique;
@@ -276,7 +252,7 @@ export type MutationUpdateSomeObjectArgs = {
 
 export enum Order {
   Asc = 'ASC',
-  Desc = 'DESC'
+  Desc = 'DESC',
 }
 
 export type Query = {
@@ -295,7 +271,6 @@ export type Query = {
   someObject: SomeObject;
 };
 
-
 export type QueryAnotherObjectsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -303,12 +278,10 @@ export type QueryAnotherObjectsArgs = {
   where?: InputMaybe<AnotherObjectWhere>;
 };
 
-
 export type QueryAnswerArgs = {
   where: AnswerWhereUnique;
 };
 
-
 export type QueryAnswersArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -316,7 +289,6 @@ export type QueryAnswersArgs = {
   where?: InputMaybe<AnswerWhere>;
 };
 
-
 export type QueryManyObjectsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -325,12 +297,10 @@ export type QueryManyObjectsArgs = {
   where?: InputMaybe<SomeObjectWhere>;
 };
 
-
 export type QueryQuestionArgs = {
   where: QuestionWhereUnique;
 };
 
-
 export type QueryQuestionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -338,12 +308,10 @@ export type QueryQuestionsArgs = {
   where?: InputMaybe<QuestionWhere>;
 };
 
-
 export type QueryReactionArgs = {
   where: ReactionWhereUnique;
 };
 
-
 export type QueryReactionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -351,12 +319,10 @@ export type QueryReactionsArgs = {
   where?: InputMaybe<ReactionWhere>;
 };
 
-
 export type QueryReviewArgs = {
   where: ReviewWhereUnique;
 };
 
-
 export type QueryReviewsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -364,7 +330,6 @@ export type QueryReviewsArgs = {
   where?: InputMaybe<ReviewWhere>;
 };
 
-
 export type QuerySomeObjectArgs = {
   where: SomeObjectWhereUnique;
 };
@@ -388,7 +353,6 @@ export type Question = Reaction & {
   updatedBy: User;
 };
 
-
 export type QuestionChildAnswersArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -396,7 +360,6 @@ export type QuestionChildAnswersArgs = {
   where?: InputMaybe<AnswerWhere>;
 };
 
-
 export type QuestionChildQuestionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -404,7 +367,6 @@ export type QuestionChildQuestionsArgs = {
   where?: InputMaybe<QuestionWhere>;
 };
 
-
 export type QuestionChildReactionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -412,7 +374,6 @@ export type QuestionChildReactionsArgs = {
   where?: InputMaybe<ReactionWhere>;
 };
 
-
 export type QuestionChildReviewsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -456,7 +417,6 @@ export type Reaction = {
   updatedBy: User;
 };
 
-
 export type ReactionChildAnswersArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -464,7 +424,6 @@ export type ReactionChildAnswersArgs = {
   where?: InputMaybe<AnswerWhere>;
 };
 
-
 export type ReactionChildQuestionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -472,7 +431,6 @@ export type ReactionChildQuestionsArgs = {
   where?: InputMaybe<QuestionWhere>;
 };
 
-
 export type ReactionChildReactionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -480,7 +438,6 @@ export type ReactionChildReactionsArgs = {
   where?: InputMaybe<ReactionWhere>;
 };
 
-
 export type ReactionChildReviewsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -497,7 +454,7 @@ export type ReactionOrderBy = {
 export enum ReactionType {
   Answer = 'Answer',
   Question = 'Question',
-  Review = 'Review'
+  Review = 'Review',
 }
 
 export type ReactionWhere = {
@@ -532,7 +489,6 @@ export type Review = Reaction & {
   updatedBy: User;
 };
 
-
 export type ReviewChildAnswersArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -540,7 +496,6 @@ export type ReviewChildAnswersArgs = {
   where?: InputMaybe<AnswerWhere>;
 };
 
-
 export type ReviewChildQuestionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -548,7 +503,6 @@ export type ReviewChildQuestionsArgs = {
   where?: InputMaybe<QuestionWhere>;
 };
 
-
 export type ReviewChildReactionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -556,7 +510,6 @@ export type ReviewChildReactionsArgs = {
   where?: InputMaybe<ReactionWhere>;
 };
 
-
 export type ReviewChildReviewsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -588,13 +541,13 @@ export type ReviewWhereUnique = {
 
 export enum Role {
   Admin = 'ADMIN',
-  User = 'USER'
+  User = 'USER',
 }
 
 export enum SomeEnum {
   A = 'A',
   B = 'B',
-  C = 'C'
+  C = 'C',
 }
 
 export type SomeObject = {
@@ -614,7 +567,6 @@ export type SomeObject = {
   xyz: Scalars['Int']['output'];
 };
 
-
 export type SomeObjectListArgs = {
   magic?: InputMaybe<Scalars['Boolean']['input']>;
 };
@@ -687,7 +639,6 @@ export type User = {
   username?: Maybe<Scalars['String']['output']>;
 };
 
-
 export type UserCreatedAnswersArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -695,7 +646,6 @@ export type UserCreatedAnswersArgs = {
   where?: InputMaybe<AnswerWhere>;
 };
 
-
 export type UserCreatedManyObjectsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -704,7 +654,6 @@ export type UserCreatedManyObjectsArgs = {
   where?: InputMaybe<SomeObjectWhere>;
 };
 
-
 export type UserCreatedQuestionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -712,7 +661,6 @@ export type UserCreatedQuestionsArgs = {
   where?: InputMaybe<QuestionWhere>;
 };
 
-
 export type UserCreatedReactionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -720,7 +668,6 @@ export type UserCreatedReactionsArgs = {
   where?: InputMaybe<ReactionWhere>;
 };
 
-
 export type UserCreatedReviewsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -728,7 +675,6 @@ export type UserCreatedReviewsArgs = {
   where?: InputMaybe<ReviewWhere>;
 };
 
-
 export type UserDeletedAnotherObjectsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -736,7 +682,6 @@ export type UserDeletedAnotherObjectsArgs = {
   where?: InputMaybe<AnotherObjectWhere>;
 };
 
-
 export type UserDeletedAnswersArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -744,7 +689,6 @@ export type UserDeletedAnswersArgs = {
   where?: InputMaybe<AnswerWhere>;
 };
 
-
 export type UserDeletedManyObjectsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -753,7 +697,6 @@ export type UserDeletedManyObjectsArgs = {
   where?: InputMaybe<SomeObjectWhere>;
 };
 
-
 export type UserDeletedQuestionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -761,7 +704,6 @@ export type UserDeletedQuestionsArgs = {
   where?: InputMaybe<QuestionWhere>;
 };
 
-
 export type UserDeletedReactionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -769,7 +711,6 @@ export type UserDeletedReactionsArgs = {
   where?: InputMaybe<ReactionWhere>;
 };
 
-
 export type UserDeletedReviewsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -777,7 +718,6 @@ export type UserDeletedReviewsArgs = {
   where?: InputMaybe<ReviewWhere>;
 };
 
-
 export type UserUpdatedAnswersArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -785,7 +725,6 @@ export type UserUpdatedAnswersArgs = {
   where?: InputMaybe<AnswerWhere>;
 };
 
-
 export type UserUpdatedManyObjectsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -794,7 +733,6 @@ export type UserUpdatedManyObjectsArgs = {
   where?: InputMaybe<SomeObjectWhere>;
 };
 
-
 export type UserUpdatedQuestionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -802,7 +740,6 @@ export type UserUpdatedQuestionsArgs = {
   where?: InputMaybe<QuestionWhere>;
 };
 
-
 export type UserUpdatedReactionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -810,7 +747,6 @@ export type UserUpdatedReactionsArgs = {
   where?: InputMaybe<ReactionWhere>;
 };
 
-
 export type UserUpdatedReviewsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -829,15 +765,14 @@ export type UserWhereUnique = {
   id?: InputMaybe<Scalars['ID']['input']>;
 };
 
-
-
 export type ResolverTypeWrapper<T> = Promise<T> | T;
 
-
 export type ResolverWithResolve<TResult, TParent, TContext, TArgs> = {
   resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
 };
-export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> = ResolverFn<TResult, TParent, TContext, TArgs> | ResolverWithResolve<TResult, TParent, TContext, TArgs>;
+export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> =
+  | ResolverFn<TResult, TParent, TContext, TArgs>
+  | ResolverWithResolve<TResult, TParent, TContext, TArgs>;
 
 export type ResolverFn<TResult, TParent, TContext, TArgs> = (
   parent: TParent,
@@ -884,7 +819,11 @@ export type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (
   info: GraphQLResolveInfo
 ) => Maybe<TTypes> | Promise<Maybe<TTypes>>;
 
-export type IsTypeOfResolverFn<T = {}, TContext = {}> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>;
+export type IsTypeOfResolverFn<T = {}, TContext = {}> = (
+  obj: T,
+  context: TContext,
+  info: GraphQLResolveInfo
+) => boolean | Promise<boolean>;
 
 export type NextResolverFn<T> = () => Promise<T>;
 
@@ -896,10 +835,9 @@ export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs
   info: GraphQLResolveInfo
 ) => TResult | Promise<TResult>;
 
-
 /** Mapping of interface types */
 export type ResolversInterfaceTypes<RefType extends Record<string, unknown>> = {
-  Reaction: ( Answer ) | ( Question ) | ( Review );
+  Reaction: Answer | Question | Review;
 };
 
 /** Mapping between all available schema types and the resolvers types */
@@ -1004,19 +942,30 @@ export type ResolversParentTypes = {
   UserWhereUnique: UserWhereUnique;
 };
 
-export type AnotherObjectResolvers<ContextType = any, ParentType extends ResolversParentTypes['AnotherObject'] = ResolversParentTypes['AnotherObject']> = {
+export type AnotherObjectResolvers<
+  ContextType = any,
+  ParentType extends ResolversParentTypes['AnotherObject'] = ResolversParentTypes['AnotherObject']
+> = {
   deleted?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
   deletedAt?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
   deletedBy?: Resolver<Maybe<ResolversTypes['User']>, ParentType, ContextType>;
   id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
-  manyObjects?: Resolver<Array<ResolversTypes['SomeObject']>, ParentType, ContextType, Partial<AnotherObjectManyObjectsArgs>>;
+  manyObjects?: Resolver<
+    Array<ResolversTypes['SomeObject']>,
+    ParentType,
+    ContextType,
+    Partial<AnotherObjectManyObjectsArgs>
+  >;
   myself?: Resolver<Maybe<ResolversTypes['AnotherObject']>, ParentType, ContextType>;
   name?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
   self?: Resolver<Maybe<ResolversTypes['AnotherObject']>, ParentType, ContextType, Partial<AnotherObjectSelfArgs>>;
   __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 
-export type AnswerResolvers<ContextType = any, ParentType extends ResolversParentTypes['Answer'] = ResolversParentTypes['Answer']> = {
+export type AnswerResolvers<
+  ContextType = any,
+  ParentType extends ResolversParentTypes['Answer'] = ResolversParentTypes['Answer']
+> = {
   childAnswers?: Resolver<Array<ResolversTypes['Answer']>, ParentType, ContextType, Partial<AnswerChildAnswersArgs>>;
   childQuestions?: Resolver<Array<ResolversTypes['Question']>, ParentType, ContextType, Partial<AnswerChildQuestionsArgs>>;
   childReactions?: Resolver<Array<ResolversTypes['Reaction']>, ParentType, ContextType, Partial<AnswerChildReactionsArgs>>;
@@ -1039,29 +988,110 @@ export interface DateTimeScalarConfig extends GraphQLScalarTypeConfig<ResolversT
   name: 'DateTime';
 }
 
-export type MutationResolvers<ContextType = any, ParentType extends ResolversParentTypes['Mutation'] = ResolversParentTypes['Mutation']> = {
-  createAnswer?: Resolver<ResolversTypes['Answer'], ParentType, ContextType, RequireFields<MutationCreateAnswerArgs, 'data'>>;
-  createQuestion?: Resolver<ResolversTypes['Question'], ParentType, ContextType, RequireFields<MutationCreateQuestionArgs, 'data'>>;
-  createReview?: Resolver<ResolversTypes['Review'], ParentType, ContextType, RequireFields<MutationCreateReviewArgs, 'data'>>;
-  createSomeObject?: Resolver<ResolversTypes['SomeObject'], ParentType, ContextType, RequireFields<MutationCreateSomeObjectArgs, 'data'>>;
-  deleteAnotherObject?: Resolver<ResolversTypes['ID'], ParentType, ContextType, RequireFields<MutationDeleteAnotherObjectArgs, 'where'>>;
+export type MutationResolvers<
+  ContextType = any,
+  ParentType extends ResolversParentTypes['Mutation'] = ResolversParentTypes['Mutation']
+> = {
+  createAnswer?: Resolver<
+    ResolversTypes['Answer'],
+    ParentType,
+    ContextType,
+    RequireFields<MutationCreateAnswerArgs, 'data'>
+  >;
+  createQuestion?: Resolver<
+    ResolversTypes['Question'],
+    ParentType,
+    ContextType,
+    RequireFields<MutationCreateQuestionArgs, 'data'>
+  >;
+  createReview?: Resolver<
+    ResolversTypes['Review'],
+    ParentType,
+    ContextType,
+    RequireFields<MutationCreateReviewArgs, 'data'>
+  >;
+  createSomeObject?: Resolver<
+    ResolversTypes['SomeObject'],
+    ParentType,
+    ContextType,
+    RequireFields<MutationCreateSomeObjectArgs, 'data'>
+  >;
+  deleteAnotherObject?: Resolver<
+    ResolversTypes['ID'],
+    ParentType,
+    ContextType,
+    RequireFields<MutationDeleteAnotherObjectArgs, 'where'>
+  >;
   deleteAnswer?: Resolver<ResolversTypes['ID'], ParentType, ContextType, RequireFields<MutationDeleteAnswerArgs, 'where'>>;
-  deleteQuestion?: Resolver<ResolversTypes['ID'], ParentType, ContextType, RequireFields<MutationDeleteQuestionArgs, 'where'>>;
+  deleteQuestion?: Resolver<
+    ResolversTypes['ID'],
+    ParentType,
+    ContextType,
+    RequireFields<MutationDeleteQuestionArgs, 'where'>
+  >;
   deleteReview?: Resolver<ResolversTypes['ID'], ParentType, ContextType, RequireFields<MutationDeleteReviewArgs, 'where'>>;
-  deleteSomeObject?: Resolver<ResolversTypes['ID'], ParentType, ContextType, RequireFields<MutationDeleteSomeObjectArgs, 'where'>>;
-  restoreAnotherObject?: Resolver<ResolversTypes['ID'], ParentType, ContextType, RequireFields<MutationRestoreAnotherObjectArgs, 'where'>>;
+  deleteSomeObject?: Resolver<
+    ResolversTypes['ID'],
+    ParentType,
+    ContextType,
+    RequireFields<MutationDeleteSomeObjectArgs, 'where'>
+  >;
+  restoreAnotherObject?: Resolver<
+    ResolversTypes['ID'],
+    ParentType,
+    ContextType,
+    RequireFields<MutationRestoreAnotherObjectArgs, 'where'>
+  >;
   restoreAnswer?: Resolver<ResolversTypes['ID'], ParentType, ContextType, RequireFields<MutationRestoreAnswerArgs, 'where'>>;
-  restoreQuestion?: Resolver<ResolversTypes['ID'], ParentType, ContextType, RequireFields<MutationRestoreQuestionArgs, 'where'>>;
+  restoreQuestion?: Resolver<
+    ResolversTypes['ID'],
+    ParentType,
+    ContextType,
+    RequireFields<MutationRestoreQuestionArgs, 'where'>
+  >;
   restoreReview?: Resolver<ResolversTypes['ID'], ParentType, ContextType, RequireFields<MutationRestoreReviewArgs, 'where'>>;
-  restoreSomeObject?: Resolver<ResolversTypes['ID'], ParentType, ContextType, RequireFields<MutationRestoreSomeObjectArgs, 'where'>>;
-  updateAnswer?: Resolver<ResolversTypes['Answer'], ParentType, ContextType, RequireFields<MutationUpdateAnswerArgs, 'data' | 'where'>>;
-  updateQuestion?: Resolver<ResolversTypes['Question'], ParentType, ContextType, RequireFields<MutationUpdateQuestionArgs, 'data' | 'where'>>;
-  updateReview?: Resolver<ResolversTypes['Review'], ParentType, ContextType, RequireFields<MutationUpdateReviewArgs, 'data' | 'where'>>;
-  updateSomeObject?: Resolver<ResolversTypes['SomeObject'], ParentType, ContextType, RequireFields<MutationUpdateSomeObjectArgs, 'data' | 'where'>>;
-};
-
-export type QueryResolvers<ContextType = any, ParentType extends ResolversParentTypes['Query'] = ResolversParentTypes['Query']> = {
-  anotherObjects?: Resolver<Array<ResolversTypes['AnotherObject']>, ParentType, ContextType, Partial<QueryAnotherObjectsArgs>>;
+  restoreSomeObject?: Resolver<
+    ResolversTypes['ID'],
+    ParentType,
+    ContextType,
+    RequireFields<MutationRestoreSomeObjectArgs, 'where'>
+  >;
+  updateAnswer?: Resolver<
+    ResolversTypes['Answer'],
+    ParentType,
+    ContextType,
+    RequireFields<MutationUpdateAnswerArgs, 'data' | 'where'>
+  >;
+  updateQuestion?: Resolver<
+    ResolversTypes['Question'],
+    ParentType,
+    ContextType,
+    RequireFields<MutationUpdateQuestionArgs, 'data' | 'where'>
+  >;
+  updateReview?: Resolver<
+    ResolversTypes['Review'],
+    ParentType,
+    ContextType,
+    RequireFields<MutationUpdateReviewArgs, 'data' | 'where'>
+  >;
+  updateSomeObject?: Resolver<
+    ResolversTypes['SomeObject'],
+    ParentType,
+    ContextType,
+    RequireFields<MutationUpdateSomeObjectArgs, 'data' | 'where'>
+  >;
+};
+
+export type QueryResolvers<
+  ContextType = any,
+  ParentType extends ResolversParentTypes['Query'] = ResolversParentTypes['Query']
+> = {
+  anotherObjects?: Resolver<
+    Array<ResolversTypes['AnotherObject']>,
+    ParentType,
+    ContextType,
+    Partial<QueryAnotherObjectsArgs>
+  >;
   answer?: Resolver<ResolversTypes['Answer'], ParentType, ContextType, RequireFields<QueryAnswerArgs, 'where'>>;
   answers?: Resolver<Array<ResolversTypes['Answer']>, ParentType, ContextType, Partial<QueryAnswersArgs>>;
   manyObjects?: Resolver<Array<ResolversTypes['SomeObject']>, ParentType, ContextType, Partial<QueryManyObjectsArgs>>;
@@ -1075,7 +1105,10 @@ export type QueryResolvers<ContextType = any, ParentType extends ResolversParent
   someObject?: Resolver<ResolversTypes['SomeObject'], ParentType, ContextType, RequireFields<QuerySomeObjectArgs, 'where'>>;
 };
 
-export type QuestionResolvers<ContextType = any, ParentType extends ResolversParentTypes['Question'] = ResolversParentTypes['Question']> = {
+export type QuestionResolvers<
+  ContextType = any,
+  ParentType extends ResolversParentTypes['Question'] = ResolversParentTypes['Question']
+> = {
   childAnswers?: Resolver<Array<ResolversTypes['Answer']>, ParentType, ContextType, Partial<QuestionChildAnswersArgs>>;
   childQuestions?: Resolver<Array<ResolversTypes['Question']>, ParentType, ContextType, Partial<QuestionChildQuestionsArgs>>;
   childReactions?: Resolver<Array<ResolversTypes['Reaction']>, ParentType, ContextType, Partial<QuestionChildReactionsArgs>>;
@@ -1094,7 +1127,10 @@ export type QuestionResolvers<ContextType = any, ParentType extends ResolversPar
   __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 
-export type ReactionResolvers<ContextType = any, ParentType extends ResolversParentTypes['Reaction'] = ResolversParentTypes['Reaction']> = {
+export type ReactionResolvers<
+  ContextType = any,
+  ParentType extends ResolversParentTypes['Reaction'] = ResolversParentTypes['Reaction']
+> = {
   __resolveType: TypeResolveFn<'Answer' | 'Question' | 'Review', ParentType, ContextType>;
   childAnswers?: Resolver<Array<ResolversTypes['Answer']>, ParentType, ContextType, Partial<ReactionChildAnswersArgs>>;
   childQuestions?: Resolver<Array<ResolversTypes['Question']>, ParentType, ContextType, Partial<ReactionChildQuestionsArgs>>;
@@ -1113,7 +1149,10 @@ export type ReactionResolvers<ContextType = any, ParentType extends ResolversPar
   updatedBy?: Resolver<ResolversTypes['User'], ParentType, ContextType>;
 };
 
-export type ReviewResolvers<ContextType = any, ParentType extends ResolversParentTypes['Review'] = ResolversParentTypes['Review']> = {
+export type ReviewResolvers<
+  ContextType = any,
+  ParentType extends ResolversParentTypes['Review'] = ResolversParentTypes['Review']
+> = {
   childAnswers?: Resolver<Array<ResolversTypes['Answer']>, ParentType, ContextType, Partial<ReviewChildAnswersArgs>>;
   childQuestions?: Resolver<Array<ResolversTypes['Question']>, ParentType, ContextType, Partial<ReviewChildQuestionsArgs>>;
   childReactions?: Resolver<Array<ResolversTypes['Reaction']>, ParentType, ContextType, Partial<ReviewChildReactionsArgs>>;
@@ -1133,7 +1172,10 @@ export type ReviewResolvers<ContextType = any, ParentType extends ResolversParen
   __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 
-export type SomeObjectResolvers<ContextType = any, ParentType extends ResolversParentTypes['SomeObject'] = ResolversParentTypes['SomeObject']> = {
+export type SomeObjectResolvers<
+  ContextType = any,
+  ParentType extends ResolversParentTypes['SomeObject'] = ResolversParentTypes['SomeObject']
+> = {
   another?: Resolver<ResolversTypes['AnotherObject'], ParentType, ContextType>;
   createdAt?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>;
   createdBy?: Resolver<ResolversTypes['User'], ParentType, ContextType>;
@@ -1150,7 +1192,10 @@ export type SomeObjectResolvers<ContextType = any, ParentType extends ResolversP
   __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 
-export type SomeRawObjectResolvers<ContextType = any, ParentType extends ResolversParentTypes['SomeRawObject'] = ResolversParentTypes['SomeRawObject']> = {
+export type SomeRawObjectResolvers<
+  ContextType = any,
+  ParentType extends ResolversParentTypes['SomeRawObject'] = ResolversParentTypes['SomeRawObject']
+> = {
   field?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
   __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
@@ -1159,22 +1204,45 @@ export interface UploadScalarConfig extends GraphQLScalarTypeConfig<ResolversTyp
   name: 'Upload';
 }
 
-export type UserResolvers<ContextType = any, ParentType extends ResolversParentTypes['User'] = ResolversParentTypes['User']> = {
+export type UserResolvers<
+  ContextType = any,
+  ParentType extends ResolversParentTypes['User'] = ResolversParentTypes['User']
+> = {
   createdAnswers?: Resolver<Array<ResolversTypes['Answer']>, ParentType, ContextType, Partial<UserCreatedAnswersArgs>>;
-  createdManyObjects?: Resolver<Array<ResolversTypes['SomeObject']>, ParentType, ContextType, Partial<UserCreatedManyObjectsArgs>>;
+  createdManyObjects?: Resolver<
+    Array<ResolversTypes['SomeObject']>,
+    ParentType,
+    ContextType,
+    Partial<UserCreatedManyObjectsArgs>
+  >;
   createdQuestions?: Resolver<Array<ResolversTypes['Question']>, ParentType, ContextType, Partial<UserCreatedQuestionsArgs>>;
   createdReactions?: Resolver<Array<ResolversTypes['Reaction']>, ParentType, ContextType, Partial<UserCreatedReactionsArgs>>;
   createdReviews?: Resolver<Array<ResolversTypes['Review']>, ParentType, ContextType, Partial<UserCreatedReviewsArgs>>;
-  deletedAnotherObjects?: Resolver<Array<ResolversTypes['AnotherObject']>, ParentType, ContextType, Partial<UserDeletedAnotherObjectsArgs>>;
+  deletedAnotherObjects?: Resolver<
+    Array<ResolversTypes['AnotherObject']>,
+    ParentType,
+    ContextType,
+    Partial<UserDeletedAnotherObjectsArgs>
+  >;
   deletedAnswers?: Resolver<Array<ResolversTypes['Answer']>, ParentType, ContextType, Partial<UserDeletedAnswersArgs>>;
-  deletedManyObjects?: Resolver<Array<ResolversTypes['SomeObject']>, ParentType, ContextType, Partial<UserDeletedManyObjectsArgs>>;
+  deletedManyObjects?: Resolver<
+    Array<ResolversTypes['SomeObject']>,
+    ParentType,
+    ContextType,
+    Partial<UserDeletedManyObjectsArgs>
+  >;
   deletedQuestions?: Resolver<Array<ResolversTypes['Question']>, ParentType, ContextType, Partial<UserDeletedQuestionsArgs>>;
   deletedReactions?: Resolver<Array<ResolversTypes['Reaction']>, ParentType, ContextType, Partial<UserDeletedReactionsArgs>>;
   deletedReviews?: Resolver<Array<ResolversTypes['Review']>, ParentType, ContextType, Partial<UserDeletedReviewsArgs>>;
   id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
   role?: Resolver<Maybe<ResolversTypes['Role']>, ParentType, ContextType>;
   updatedAnswers?: Resolver<Array<ResolversTypes['Answer']>, ParentType, ContextType, Partial<UserUpdatedAnswersArgs>>;
-  updatedManyObjects?: Resolver<Array<ResolversTypes['SomeObject']>, ParentType, ContextType, Partial<UserUpdatedManyObjectsArgs>>;
+  updatedManyObjects?: Resolver<
+    Array<ResolversTypes['SomeObject']>,
+    ParentType,
+    ContextType,
+    Partial<UserUpdatedManyObjectsArgs>
+  >;
   updatedQuestions?: Resolver<Array<ResolversTypes['Question']>, ParentType, ContextType, Partial<UserUpdatedQuestionsArgs>>;
   updatedReactions?: Resolver<Array<ResolversTypes['Reaction']>, ParentType, ContextType, Partial<UserUpdatedReactionsArgs>>;
   updatedReviews?: Resolver<Array<ResolversTypes['Review']>, ParentType, ContextType, Partial<UserUpdatedReviewsArgs>>;
@@ -1196,4 +1264,3 @@ export type Resolvers<ContextType = any> = {
   Upload?: GraphQLScalarType;
   User?: UserResolvers<ContextType>;
 };
-
diff --git a/tests/generated/client/index.ts b/tests/generated/client/index.ts
index c2b9dc9..58cce2e 100644
--- a/tests/generated/client/index.ts
+++ b/tests/generated/client/index.ts
@@ -7,13 +7,13 @@ export type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> =
 export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never };
 /** All built-in and custom scalars, mapped to their actual values */
 export type Scalars = {
-  ID: { input: string; output: string; }
-  String: { input: string; output: string; }
-  Boolean: { input: boolean; output: boolean; }
-  Int: { input: number; output: number; }
-  Float: { input: number; output: number; }
-  DateTime: { input: string; output: string; }
-  Upload: { input: any; output: any; }
+  ID: { input: string; output: string };
+  String: { input: string; output: string };
+  Boolean: { input: boolean; output: boolean };
+  Int: { input: number; output: number };
+  Float: { input: number; output: number };
+  DateTime: { input: string; output: string };
+  Upload: { input: any; output: any };
 };
 
 export type AnotherObject = {
@@ -28,7 +28,6 @@ export type AnotherObject = {
   self: Maybe<AnotherObject>;
 };
 
-
 export type AnotherObjectmanyObjectsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -37,7 +36,6 @@ export type AnotherObjectmanyObjectsArgs = {
   where?: InputMaybe<SomeObjectWhere>;
 };
 
-
 export type AnotherObjectselfArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -83,7 +81,6 @@ export type Answer = Reaction & {
   updatedBy: User;
 };
 
-
 export type AnswerchildAnswersArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -91,7 +88,6 @@ export type AnswerchildAnswersArgs = {
   where?: InputMaybe<AnswerWhere>;
 };
 
-
 export type AnswerchildQuestionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -99,7 +95,6 @@ export type AnswerchildQuestionsArgs = {
   where?: InputMaybe<QuestionWhere>;
 };
 
-
 export type AnswerchildReactionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -107,7 +102,6 @@ export type AnswerchildReactionsArgs = {
   where?: InputMaybe<ReactionWhere>;
 };
 
-
 export type AnswerchildReviewsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -172,100 +166,82 @@ export type Mutation = {
   updateSomeObject: SomeObject;
 };
 
-
 export type MutationcreateAnswerArgs = {
   data: CreateAnswer;
 };
 
-
 export type MutationcreateQuestionArgs = {
   data: CreateQuestion;
 };
 
-
 export type MutationcreateReviewArgs = {
   data: CreateReview;
 };
 
-
 export type MutationcreateSomeObjectArgs = {
   data: CreateSomeObject;
 };
 
-
 export type MutationdeleteAnotherObjectArgs = {
   dryRun?: InputMaybe<Scalars['Boolean']['input']>;
   where: AnotherObjectWhereUnique;
 };
 
-
 export type MutationdeleteAnswerArgs = {
   dryRun?: InputMaybe<Scalars['Boolean']['input']>;
   where: AnswerWhereUnique;
 };
 
-
 export type MutationdeleteQuestionArgs = {
   dryRun?: InputMaybe<Scalars['Boolean']['input']>;
   where: QuestionWhereUnique;
 };
 
-
 export type MutationdeleteReviewArgs = {
   dryRun?: InputMaybe<Scalars['Boolean']['input']>;
   where: ReviewWhereUnique;
 };
 
-
 export type MutationdeleteSomeObjectArgs = {
   dryRun?: InputMaybe<Scalars['Boolean']['input']>;
   where: SomeObjectWhereUnique;
 };
 
-
 export type MutationrestoreAnotherObjectArgs = {
   where: AnotherObjectWhereUnique;
 };
 
-
 export type MutationrestoreAnswerArgs = {
   where: AnswerWhereUnique;
 };
 
-
 export type MutationrestoreQuestionArgs = {
   where: QuestionWhereUnique;
 };
 
-
 export type MutationrestoreReviewArgs = {
   where: ReviewWhereUnique;
 };
 
-
 export type MutationrestoreSomeObjectArgs = {
   where: SomeObjectWhereUnique;
 };
 
-
 export type MutationupdateAnswerArgs = {
   data: UpdateAnswer;
   where: AnswerWhereUnique;
 };
 
-
 export type MutationupdateQuestionArgs = {
   data: UpdateQuestion;
   where: QuestionWhereUnique;
 };
 
-
 export type MutationupdateReviewArgs = {
   data: UpdateReview;
   where: ReviewWhereUnique;
 };
 
-
 export type MutationupdateSomeObjectArgs = {
   data: UpdateSomeObject;
   where: SomeObjectWhereUnique;
@@ -273,7 +249,7 @@ export type MutationupdateSomeObjectArgs = {
 
 export enum Order {
   ASC = 'ASC',
-  DESC = 'DESC'
+  DESC = 'DESC',
 }
 
 export type Query = {
@@ -292,7 +268,6 @@ export type Query = {
   someObject: SomeObject;
 };
 
-
 export type QueryanotherObjectsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -300,12 +275,10 @@ export type QueryanotherObjectsArgs = {
   where?: InputMaybe<AnotherObjectWhere>;
 };
 
-
 export type QueryanswerArgs = {
   where: AnswerWhereUnique;
 };
 
-
 export type QueryanswersArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -313,7 +286,6 @@ export type QueryanswersArgs = {
   where?: InputMaybe<AnswerWhere>;
 };
 
-
 export type QuerymanyObjectsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -322,12 +294,10 @@ export type QuerymanyObjectsArgs = {
   where?: InputMaybe<SomeObjectWhere>;
 };
 
-
 export type QueryquestionArgs = {
   where: QuestionWhereUnique;
 };
 
-
 export type QueryquestionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -335,12 +305,10 @@ export type QueryquestionsArgs = {
   where?: InputMaybe<QuestionWhere>;
 };
 
-
 export type QueryreactionArgs = {
   where: ReactionWhereUnique;
 };
 
-
 export type QueryreactionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -348,12 +316,10 @@ export type QueryreactionsArgs = {
   where?: InputMaybe<ReactionWhere>;
 };
 
-
 export type QueryreviewArgs = {
   where: ReviewWhereUnique;
 };
 
-
 export type QueryreviewsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -361,7 +327,6 @@ export type QueryreviewsArgs = {
   where?: InputMaybe<ReviewWhere>;
 };
 
-
 export type QuerysomeObjectArgs = {
   where: SomeObjectWhereUnique;
 };
@@ -385,7 +350,6 @@ export type Question = Reaction & {
   updatedBy: User;
 };
 
-
 export type QuestionchildAnswersArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -393,7 +357,6 @@ export type QuestionchildAnswersArgs = {
   where?: InputMaybe<AnswerWhere>;
 };
 
-
 export type QuestionchildQuestionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -401,7 +364,6 @@ export type QuestionchildQuestionsArgs = {
   where?: InputMaybe<QuestionWhere>;
 };
 
-
 export type QuestionchildReactionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -409,7 +371,6 @@ export type QuestionchildReactionsArgs = {
   where?: InputMaybe<ReactionWhere>;
 };
 
-
 export type QuestionchildReviewsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -453,7 +414,6 @@ export type Reaction = {
   updatedBy: User;
 };
 
-
 export type ReactionchildAnswersArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -461,7 +421,6 @@ export type ReactionchildAnswersArgs = {
   where?: InputMaybe<AnswerWhere>;
 };
 
-
 export type ReactionchildQuestionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -469,7 +428,6 @@ export type ReactionchildQuestionsArgs = {
   where?: InputMaybe<QuestionWhere>;
 };
 
-
 export type ReactionchildReactionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -477,7 +435,6 @@ export type ReactionchildReactionsArgs = {
   where?: InputMaybe<ReactionWhere>;
 };
 
-
 export type ReactionchildReviewsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -494,7 +451,7 @@ export type ReactionOrderBy = {
 export enum ReactionType {
   Answer = 'Answer',
   Question = 'Question',
-  Review = 'Review'
+  Review = 'Review',
 }
 
 export type ReactionWhere = {
@@ -529,7 +486,6 @@ export type Review = Reaction & {
   updatedBy: User;
 };
 
-
 export type ReviewchildAnswersArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -537,7 +493,6 @@ export type ReviewchildAnswersArgs = {
   where?: InputMaybe<AnswerWhere>;
 };
 
-
 export type ReviewchildQuestionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -545,7 +500,6 @@ export type ReviewchildQuestionsArgs = {
   where?: InputMaybe<QuestionWhere>;
 };
 
-
 export type ReviewchildReactionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -553,7 +507,6 @@ export type ReviewchildReactionsArgs = {
   where?: InputMaybe<ReactionWhere>;
 };
 
-
 export type ReviewchildReviewsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -585,13 +538,13 @@ export type ReviewWhereUnique = {
 
 export enum Role {
   ADMIN = 'ADMIN',
-  USER = 'USER'
+  USER = 'USER',
 }
 
 export enum SomeEnum {
   A = 'A',
   B = 'B',
-  C = 'C'
+  C = 'C',
 }
 
 export type SomeObject = {
@@ -611,7 +564,6 @@ export type SomeObject = {
   xyz: Scalars['Int']['output'];
 };
 
-
 export type SomeObjectlistArgs = {
   magic?: InputMaybe<Scalars['Boolean']['input']>;
 };
@@ -684,7 +636,6 @@ export type User = {
   username: Maybe<Scalars['String']['output']>;
 };
 
-
 export type UsercreatedAnswersArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -692,7 +643,6 @@ export type UsercreatedAnswersArgs = {
   where?: InputMaybe<AnswerWhere>;
 };
 
-
 export type UsercreatedManyObjectsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -701,7 +651,6 @@ export type UsercreatedManyObjectsArgs = {
   where?: InputMaybe<SomeObjectWhere>;
 };
 
-
 export type UsercreatedQuestionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -709,7 +658,6 @@ export type UsercreatedQuestionsArgs = {
   where?: InputMaybe<QuestionWhere>;
 };
 
-
 export type UsercreatedReactionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -717,7 +665,6 @@ export type UsercreatedReactionsArgs = {
   where?: InputMaybe<ReactionWhere>;
 };
 
-
 export type UsercreatedReviewsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -725,7 +672,6 @@ export type UsercreatedReviewsArgs = {
   where?: InputMaybe<ReviewWhere>;
 };
 
-
 export type UserdeletedAnotherObjectsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -733,7 +679,6 @@ export type UserdeletedAnotherObjectsArgs = {
   where?: InputMaybe<AnotherObjectWhere>;
 };
 
-
 export type UserdeletedAnswersArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -741,7 +686,6 @@ export type UserdeletedAnswersArgs = {
   where?: InputMaybe<AnswerWhere>;
 };
 
-
 export type UserdeletedManyObjectsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -750,7 +694,6 @@ export type UserdeletedManyObjectsArgs = {
   where?: InputMaybe<SomeObjectWhere>;
 };
 
-
 export type UserdeletedQuestionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -758,7 +701,6 @@ export type UserdeletedQuestionsArgs = {
   where?: InputMaybe<QuestionWhere>;
 };
 
-
 export type UserdeletedReactionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -766,7 +708,6 @@ export type UserdeletedReactionsArgs = {
   where?: InputMaybe<ReactionWhere>;
 };
 
-
 export type UserdeletedReviewsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -774,7 +715,6 @@ export type UserdeletedReviewsArgs = {
   where?: InputMaybe<ReviewWhere>;
 };
 
-
 export type UserupdatedAnswersArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -782,7 +722,6 @@ export type UserupdatedAnswersArgs = {
   where?: InputMaybe<AnswerWhere>;
 };
 
-
 export type UserupdatedManyObjectsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -791,7 +730,6 @@ export type UserupdatedManyObjectsArgs = {
   where?: InputMaybe<SomeObjectWhere>;
 };
 
-
 export type UserupdatedQuestionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -799,7 +737,6 @@ export type UserupdatedQuestionsArgs = {
   where?: InputMaybe<QuestionWhere>;
 };
 
-
 export type UserupdatedReactionsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -807,7 +744,6 @@ export type UserupdatedReactionsArgs = {
   where?: InputMaybe<ReactionWhere>;
 };
 
-
 export type UserupdatedReviewsArgs = {
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
@@ -826,205 +762,228 @@ export type UserWhereUnique = {
   id?: InputMaybe<Scalars['ID']['input']>;
 };
 
-export type DeleteAnotherObjectMutationVariables = Exact<{ [key: string]: never; }>;
-
+export type DeleteAnotherObjectMutationVariables = Exact<{ [key: string]: never }>;
 
 export type DeleteAnotherObjectMutation = { deleteAnotherObject: string };
 
-export type GetAnotherObjectQueryVariables = Exact<{ [key: string]: never; }>;
-
-
-export type GetAnotherObjectQuery = { anotherObjects: Array<{ __typename: 'AnotherObject', id: string, deleted: boolean }> };
-
-export type GetReactionsQueryVariables = Exact<{ [key: string]: never; }>;
-
+export type GetAnotherObjectQueryVariables = Exact<{ [key: string]: never }>;
 
-export type GetReactionsQuery = { reactions: Array<{ __typename: 'Answer', type: ReactionType, content: string | null } | { __typename: 'Question', type: ReactionType, content: string | null } | { __typename: 'Review', rating: number | null, type: ReactionType, content: string | null }> };
+export type GetAnotherObjectQuery = { anotherObjects: Array<{ __typename: 'AnotherObject'; id: string; deleted: boolean }> };
 
-export type GetReactionQueryVariables = Exact<{ [key: string]: never; }>;
+export type GetReactionsQueryVariables = Exact<{ [key: string]: never }>;
 
+export type GetReactionsQuery = {
+  reactions: Array<
+    | { __typename: 'Answer'; type: ReactionType; content: string | null }
+    | { __typename: 'Question'; type: ReactionType; content: string | null }
+    | { __typename: 'Review'; rating: number | null; type: ReactionType; content: string | null }
+  >;
+};
 
-export type GetReactionQuery = { reaction: { __typename: 'Answer', type: ReactionType, content: string | null } | { __typename: 'Question', type: ReactionType, content: string | null } | { __typename: 'Review', rating: number | null, type: ReactionType, content: string | null } };
-
-export type GetReviewsQueryVariables = Exact<{ [key: string]: never; }>;
+export type GetReactionQueryVariables = Exact<{ [key: string]: never }>;
 
+export type GetReactionQuery = {
+  reaction:
+    | { __typename: 'Answer'; type: ReactionType; content: string | null }
+    | { __typename: 'Question'; type: ReactionType; content: string | null }
+    | { __typename: 'Review'; rating: number | null; type: ReactionType; content: string | null };
+};
 
-export type GetReviewsQuery = { reviews: Array<{ __typename: 'Review', type: ReactionType, content: string | null, rating: number | null }> };
+export type GetReviewsQueryVariables = Exact<{ [key: string]: never }>;
 
-export type GetReviewQueryVariables = Exact<{ [key: string]: never; }>;
+export type GetReviewsQuery = {
+  reviews: Array<{ __typename: 'Review'; type: ReactionType; content: string | null; rating: number | null }>;
+};
 
+export type GetReviewQueryVariables = Exact<{ [key: string]: never }>;
 
-export type GetReviewQuery = { review: { __typename: 'Review', type: ReactionType, content: string | null, rating: number | null } };
+export type GetReviewQuery = {
+  review: { __typename: 'Review'; type: ReactionType; content: string | null; rating: number | null };
+};
 
 export type CreateReviewMutationVariables = Exact<{
   data: CreateReview;
 }>;
 
-
-export type CreateReviewMutation = { createReview: { __typename: 'Review', content: string | null, rating: number | null } };
+export type CreateReviewMutation = { createReview: { __typename: 'Review'; content: string | null; rating: number | null } };
 
 export type UpdateReviewMutationVariables = Exact<{
   id: Scalars['ID']['input'];
   data: UpdateReview;
 }>;
 
-
-export type UpdateReviewMutation = { updateReview: { __typename: 'Review', content: string | null, rating: number | null } };
-
-export type SomeQueryQueryVariables = Exact<{ [key: string]: never; }>;
-
-
-export type SomeQueryQuery = { manyObjects: Array<{ __typename: 'SomeObject', id: string, field: string | null, xyz: number, another: { __typename: 'AnotherObject', id: string, manyObjects: Array<{ __typename: 'SomeObject', id: string, field: string | null }> } }> };
-
-export type ReverseFiltersQueryQueryVariables = Exact<{ [key: string]: never; }>;
-
-
-export type ReverseFiltersQueryQuery = { all: Array<{ __typename: 'AnotherObject', id: string, manyObjects: Array<{ __typename: 'SomeObject', float: number }> }>, withFloat0: Array<{ __typename: 'AnotherObject', id: string, manyObjects: Array<{ __typename: 'SomeObject', float: number }> }>, withFloat0_5: Array<{ __typename: 'AnotherObject', id: string, manyObjects: Array<{ __typename: 'SomeObject', float: number }> }>, noneFloat0: Array<{ __typename: 'AnotherObject', id: string, manyObjects: Array<{ __typename: 'SomeObject', float: number }> }>, noneFloat0_5: Array<{ __typename: 'AnotherObject', id: string, manyObjects: Array<{ __typename: 'SomeObject', float: number }> }>, noneFloat2: Array<{ __typename: 'AnotherObject', id: string, manyObjects: Array<{ __typename: 'SomeObject', float: number }> }> };
-
-export type NotQueryQueryVariables = Exact<{ [key: string]: never; }>;
-
-
-export type NotQueryQuery = { manyObjects: Array<{ __typename: 'SomeObject', id: string }> };
-
-export type AndQueryQueryVariables = Exact<{ [key: string]: never; }>;
-
-
-export type AndQueryQuery = { manyObjects: Array<{ __typename: 'SomeObject', id: string }> };
-
-export type OrQueryQueryVariables = Exact<{ [key: string]: never; }>;
-
-
-export type OrQueryQuery = { manyObjects: Array<{ __typename: 'SomeObject', id: string }> };
+export type UpdateReviewMutation = { updateReview: { __typename: 'Review'; content: string | null; rating: number | null } };
+
+export type SomeQueryQueryVariables = Exact<{ [key: string]: never }>;
+
+export type SomeQueryQuery = {
+  manyObjects: Array<{
+    __typename: 'SomeObject';
+    id: string;
+    field: string | null;
+    xyz: number;
+    another: {
+      __typename: 'AnotherObject';
+      id: string;
+      manyObjects: Array<{ __typename: 'SomeObject'; id: string; field: string | null }>;
+    };
+  }>;
+};
+
+export type ReverseFiltersQueryQueryVariables = Exact<{ [key: string]: never }>;
+
+export type ReverseFiltersQueryQuery = {
+  all: Array<{ __typename: 'AnotherObject'; id: string; manyObjects: Array<{ __typename: 'SomeObject'; float: number }> }>;
+  withFloat0: Array<{
+    __typename: 'AnotherObject';
+    id: string;
+    manyObjects: Array<{ __typename: 'SomeObject'; float: number }>;
+  }>;
+  withFloat0_5: Array<{
+    __typename: 'AnotherObject';
+    id: string;
+    manyObjects: Array<{ __typename: 'SomeObject'; float: number }>;
+  }>;
+  noneFloat0: Array<{
+    __typename: 'AnotherObject';
+    id: string;
+    manyObjects: Array<{ __typename: 'SomeObject'; float: number }>;
+  }>;
+  noneFloat0_5: Array<{
+    __typename: 'AnotherObject';
+    id: string;
+    manyObjects: Array<{ __typename: 'SomeObject'; float: number }>;
+  }>;
+  noneFloat2: Array<{
+    __typename: 'AnotherObject';
+    id: string;
+    manyObjects: Array<{ __typename: 'SomeObject'; float: number }>;
+  }>;
+};
+
+export type NotQueryQueryVariables = Exact<{ [key: string]: never }>;
+
+export type NotQueryQuery = { manyObjects: Array<{ __typename: 'SomeObject'; id: string }> };
+
+export type AndQueryQueryVariables = Exact<{ [key: string]: never }>;
+
+export type AndQueryQuery = { manyObjects: Array<{ __typename: 'SomeObject'; id: string }> };
+
+export type OrQueryQueryVariables = Exact<{ [key: string]: never }>;
+
+export type OrQueryQuery = { manyObjects: Array<{ __typename: 'SomeObject'; id: string }> };
 
 export type DeleteAnotherObjectMutationMutationVariables = Exact<{
   id: Scalars['ID']['input'];
 }>;
 
-
-export type DeleteAnotherObjectMutationMutation = { deleteAnotherObject: string };
+export type DeleteAnotherObjectMutationMutation = { mutated: string };
 
 export type RestoreAnotherObjectMutationMutationVariables = Exact<{
   id: Scalars['ID']['input'];
 }>;
 
-
-export type RestoreAnotherObjectMutationMutation = { restoreAnotherObject: string };
+export type RestoreAnotherObjectMutationMutation = { mutated: string };
 
 export type CreateSomeObjectMutationMutationVariables = Exact<{
   data: CreateSomeObject;
 }>;
 
-
-export type CreateSomeObjectMutationMutation = { createSomeObject: { __typename: 'SomeObject', id: string } };
+export type CreateSomeObjectMutationMutation = { mutated: { __typename: 'SomeObject'; id: string } };
 
 export type UpdateSomeObjectMutationMutationVariables = Exact<{
   id: Scalars['ID']['input'];
   data: UpdateSomeObject;
 }>;
 
-
-export type UpdateSomeObjectMutationMutation = { updateSomeObject: { __typename: 'SomeObject', id: string } };
+export type UpdateSomeObjectMutationMutation = { mutated: { __typename: 'SomeObject'; id: string } };
 
 export type DeleteSomeObjectMutationMutationVariables = Exact<{
   id: Scalars['ID']['input'];
 }>;
 
-
-export type DeleteSomeObjectMutationMutation = { deleteSomeObject: string };
+export type DeleteSomeObjectMutationMutation = { mutated: string };
 
 export type RestoreSomeObjectMutationMutationVariables = Exact<{
   id: Scalars['ID']['input'];
 }>;
 
-
-export type RestoreSomeObjectMutationMutation = { restoreSomeObject: string };
+export type RestoreSomeObjectMutationMutation = { mutated: string };
 
 export type CreateReviewMutationMutationVariables = Exact<{
   data: CreateReview;
 }>;
 
-
-export type CreateReviewMutationMutation = { createReview: { __typename: 'Review', id: string } };
+export type CreateReviewMutationMutation = { mutated: { __typename: 'Review'; id: string } };
 
 export type UpdateReviewMutationMutationVariables = Exact<{
   id: Scalars['ID']['input'];
   data: UpdateReview;
 }>;
 
-
-export type UpdateReviewMutationMutation = { updateReview: { __typename: 'Review', id: string } };
+export type UpdateReviewMutationMutation = { mutated: { __typename: 'Review'; id: string } };
 
 export type DeleteReviewMutationMutationVariables = Exact<{
   id: Scalars['ID']['input'];
 }>;
 
-
-export type DeleteReviewMutationMutation = { deleteReview: string };
+export type DeleteReviewMutationMutation = { mutated: string };
 
 export type RestoreReviewMutationMutationVariables = Exact<{
   id: Scalars['ID']['input'];
 }>;
 
-
-export type RestoreReviewMutationMutation = { restoreReview: string };
+export type RestoreReviewMutationMutation = { mutated: string };
 
 export type CreateQuestionMutationMutationVariables = Exact<{
   data: CreateQuestion;
 }>;
 
-
-export type CreateQuestionMutationMutation = { createQuestion: { __typename: 'Question', id: string } };
+export type CreateQuestionMutationMutation = { mutated: { __typename: 'Question'; id: string } };
 
 export type UpdateQuestionMutationMutationVariables = Exact<{
   id: Scalars['ID']['input'];
   data: UpdateQuestion;
 }>;
 
-
-export type UpdateQuestionMutationMutation = { updateQuestion: { __typename: 'Question', id: string } };
+export type UpdateQuestionMutationMutation = { mutated: { __typename: 'Question'; id: string } };
 
 export type DeleteQuestionMutationMutationVariables = Exact<{
   id: Scalars['ID']['input'];
 }>;
 
-
-export type DeleteQuestionMutationMutation = { deleteQuestion: string };
+export type DeleteQuestionMutationMutation = { mutated: string };
 
 export type RestoreQuestionMutationMutationVariables = Exact<{
   id: Scalars['ID']['input'];
 }>;
 
-
-export type RestoreQuestionMutationMutation = { restoreQuestion: string };
+export type RestoreQuestionMutationMutation = { mutated: string };
 
 export type CreateAnswerMutationMutationVariables = Exact<{
   data: CreateAnswer;
 }>;
 
-
-export type CreateAnswerMutationMutation = { createAnswer: { __typename: 'Answer', id: string } };
+export type CreateAnswerMutationMutation = { mutated: { __typename: 'Answer'; id: string } };
 
 export type UpdateAnswerMutationMutationVariables = Exact<{
   id: Scalars['ID']['input'];
   data: UpdateAnswer;
 }>;
 
-
-export type UpdateAnswerMutationMutation = { updateAnswer: { __typename: 'Answer', id: string } };
+export type UpdateAnswerMutationMutation = { mutated: { __typename: 'Answer'; id: string } };
 
 export type DeleteAnswerMutationMutationVariables = Exact<{
   id: Scalars['ID']['input'];
 }>;
 
-
-export type DeleteAnswerMutationMutation = { deleteAnswer: string };
+export type DeleteAnswerMutationMutation = { mutated: string };
 
 export type RestoreAnswerMutationMutationVariables = Exact<{
   id: Scalars['ID']['input'];
 }>;
 
-
-export type RestoreAnswerMutationMutation = { restoreAnswer: string };
+export type RestoreAnswerMutationMutation = { mutated: string };
 
 type DiscriminateUnion<T, U> = T extends U ? T : never;
 
@@ -1036,88 +995,107 @@ export namespace DeleteAnotherObject {
 export namespace GetAnotherObject {
   export type Variables = GetAnotherObjectQueryVariables;
   export type query = GetAnotherObjectQuery;
-  export type anotherObjects = NonNullable<(NonNullable<GetAnotherObjectQuery['anotherObjects']>)[number]>;
+  export type anotherObjects = NonNullable<NonNullable<GetAnotherObjectQuery['anotherObjects']>[number]>;
 }
 
 export namespace GetReactions {
   export type Variables = GetReactionsQueryVariables;
   export type query = GetReactionsQuery;
-  export type reactions = NonNullable<(NonNullable<GetReactionsQuery['reactions']>)[number]>;
-  export type ReviewInlineFragment = (DiscriminateUnion<NonNullable<(NonNullable<GetReactionsQuery['reactions']>)[number]>, { __typename: 'Review' }>);
+  export type reactions = NonNullable<NonNullable<GetReactionsQuery['reactions']>[number]>;
+  export type ReviewInlineFragment = DiscriminateUnion<
+    NonNullable<NonNullable<GetReactionsQuery['reactions']>[number]>,
+    { __typename: 'Review' }
+  >;
 }
 
 export namespace GetReaction {
   export type Variables = GetReactionQueryVariables;
   export type query = GetReactionQuery;
-  export type reaction = (NonNullable<GetReactionQuery['reaction']>);
-  export type ReviewInlineFragment = (DiscriminateUnion<(NonNullable<GetReactionQuery['reaction']>), { __typename: 'Review' }>);
+  export type reaction = NonNullable<GetReactionQuery['reaction']>;
+  export type ReviewInlineFragment = DiscriminateUnion<NonNullable<GetReactionQuery['reaction']>, { __typename: 'Review' }>;
 }
 
 export namespace GetReviews {
   export type Variables = GetReviewsQueryVariables;
   export type query = GetReviewsQuery;
-  export type reviews = NonNullable<(NonNullable<GetReviewsQuery['reviews']>)[number]>;
+  export type reviews = NonNullable<NonNullable<GetReviewsQuery['reviews']>[number]>;
 }
 
 export namespace GetReview {
   export type Variables = GetReviewQueryVariables;
   export type query = GetReviewQuery;
-  export type review = (NonNullable<GetReviewQuery['review']>);
+  export type review = NonNullable<GetReviewQuery['review']>;
 }
 
 export namespace CreateReview {
   export type Variables = CreateReviewMutationVariables;
   export type mutation = CreateReviewMutation;
-  export type createReview = (NonNullable<CreateReviewMutation['createReview']>);
+  export type createReview = NonNullable<CreateReviewMutation['createReview']>;
 }
 
 export namespace UpdateReview {
   export type Variables = UpdateReviewMutationVariables;
   export type mutation = UpdateReviewMutation;
-  export type updateReview = (NonNullable<UpdateReviewMutation['updateReview']>);
+  export type updateReview = NonNullable<UpdateReviewMutation['updateReview']>;
 }
 
 export namespace SomeQuery {
   export type Variables = SomeQueryQueryVariables;
   export type query = SomeQueryQuery;
-  export type manyObjects = NonNullable<(NonNullable<SomeQueryQuery['manyObjects']>)[number]>;
-  export type another = (NonNullable<NonNullable<(NonNullable<SomeQueryQuery['manyObjects']>)[number]>['another']>);
-  export type _manyObjects = NonNullable<(NonNullable<(NonNullable<NonNullable<(NonNullable<SomeQueryQuery['manyObjects']>)[number]>['another']>)['manyObjects']>)[number]>;
+  export type manyObjects = NonNullable<NonNullable<SomeQueryQuery['manyObjects']>[number]>;
+  export type another = NonNullable<NonNullable<NonNullable<SomeQueryQuery['manyObjects']>[number]>['another']>;
+  export type _manyObjects = NonNullable<
+    NonNullable<
+      NonNullable<NonNullable<NonNullable<SomeQueryQuery['manyObjects']>[number]>['another']>['manyObjects']
+    >[number]
+  >;
 }
 
 export namespace ReverseFiltersQuery {
   export type Variables = ReverseFiltersQueryQueryVariables;
   export type query = ReverseFiltersQueryQuery;
-  export type all = NonNullable<(NonNullable<ReverseFiltersQueryQuery['all']>)[number]>;
-  export type manyObjects = NonNullable<(NonNullable<NonNullable<(NonNullable<ReverseFiltersQueryQuery['all']>)[number]>['manyObjects']>)[number]>;
-  export type withFloat0 = NonNullable<(NonNullable<ReverseFiltersQueryQuery['withFloat0']>)[number]>;
-  export type _manyObjects = NonNullable<(NonNullable<NonNullable<(NonNullable<ReverseFiltersQueryQuery['withFloat0']>)[number]>['manyObjects']>)[number]>;
-  export type withFloat0_5 = NonNullable<(NonNullable<ReverseFiltersQueryQuery['withFloat0_5']>)[number]>;
-  export type __manyObjects = NonNullable<(NonNullable<NonNullable<(NonNullable<ReverseFiltersQueryQuery['withFloat0_5']>)[number]>['manyObjects']>)[number]>;
-  export type noneFloat0 = NonNullable<(NonNullable<ReverseFiltersQueryQuery['noneFloat0']>)[number]>;
-  export type ___manyObjects = NonNullable<(NonNullable<NonNullable<(NonNullable<ReverseFiltersQueryQuery['noneFloat0']>)[number]>['manyObjects']>)[number]>;
-  export type noneFloat0_5 = NonNullable<(NonNullable<ReverseFiltersQueryQuery['noneFloat0_5']>)[number]>;
-  export type ____manyObjects = NonNullable<(NonNullable<NonNullable<(NonNullable<ReverseFiltersQueryQuery['noneFloat0_5']>)[number]>['manyObjects']>)[number]>;
-  export type noneFloat2 = NonNullable<(NonNullable<ReverseFiltersQueryQuery['noneFloat2']>)[number]>;
-  export type _____manyObjects = NonNullable<(NonNullable<NonNullable<(NonNullable<ReverseFiltersQueryQuery['noneFloat2']>)[number]>['manyObjects']>)[number]>;
+  export type all = NonNullable<NonNullable<ReverseFiltersQueryQuery['all']>[number]>;
+  export type manyObjects = NonNullable<
+    NonNullable<NonNullable<NonNullable<ReverseFiltersQueryQuery['all']>[number]>['manyObjects']>[number]
+  >;
+  export type withFloat0 = NonNullable<NonNullable<ReverseFiltersQueryQuery['withFloat0']>[number]>;
+  export type _manyObjects = NonNullable<
+    NonNullable<NonNullable<NonNullable<ReverseFiltersQueryQuery['withFloat0']>[number]>['manyObjects']>[number]
+  >;
+  export type withFloat0_5 = NonNullable<NonNullable<ReverseFiltersQueryQuery['withFloat0_5']>[number]>;
+  export type __manyObjects = NonNullable<
+    NonNullable<NonNullable<NonNullable<ReverseFiltersQueryQuery['withFloat0_5']>[number]>['manyObjects']>[number]
+  >;
+  export type noneFloat0 = NonNullable<NonNullable<ReverseFiltersQueryQuery['noneFloat0']>[number]>;
+  export type ___manyObjects = NonNullable<
+    NonNullable<NonNullable<NonNullable<ReverseFiltersQueryQuery['noneFloat0']>[number]>['manyObjects']>[number]
+  >;
+  export type noneFloat0_5 = NonNullable<NonNullable<ReverseFiltersQueryQuery['noneFloat0_5']>[number]>;
+  export type ____manyObjects = NonNullable<
+    NonNullable<NonNullable<NonNullable<ReverseFiltersQueryQuery['noneFloat0_5']>[number]>['manyObjects']>[number]
+  >;
+  export type noneFloat2 = NonNullable<NonNullable<ReverseFiltersQueryQuery['noneFloat2']>[number]>;
+  export type _____manyObjects = NonNullable<
+    NonNullable<NonNullable<NonNullable<ReverseFiltersQueryQuery['noneFloat2']>[number]>['manyObjects']>[number]
+  >;
 }
 
 export namespace NotQuery {
   export type Variables = NotQueryQueryVariables;
   export type query = NotQueryQuery;
-  export type manyObjects = NonNullable<(NonNullable<NotQueryQuery['manyObjects']>)[number]>;
+  export type manyObjects = NonNullable<NonNullable<NotQueryQuery['manyObjects']>[number]>;
 }
 
 export namespace AndQuery {
   export type Variables = AndQueryQueryVariables;
   export type query = AndQueryQuery;
-  export type manyObjects = NonNullable<(NonNullable<AndQueryQuery['manyObjects']>)[number]>;
+  export type manyObjects = NonNullable<NonNullable<AndQueryQuery['manyObjects']>[number]>;
 }
 
 export namespace OrQuery {
   export type Variables = OrQueryQueryVariables;
   export type query = OrQueryQuery;
-  export type manyObjects = NonNullable<(NonNullable<OrQueryQuery['manyObjects']>)[number]>;
+  export type manyObjects = NonNullable<NonNullable<OrQueryQuery['manyObjects']>[number]>;
 }
 
 export namespace DeleteAnotherObjectMutation {
@@ -1133,13 +1111,13 @@ export namespace RestoreAnotherObjectMutation {
 export namespace CreateSomeObjectMutation {
   export type Variables = CreateSomeObjectMutationMutationVariables;
   export type mutation = CreateSomeObjectMutationMutation;
-  export type createSomeObject = (NonNullable<CreateSomeObjectMutationMutation['createSomeObject']>);
+  export type mutated = NonNullable<CreateSomeObjectMutationMutation['mutated']>;
 }
 
 export namespace UpdateSomeObjectMutation {
   export type Variables = UpdateSomeObjectMutationMutationVariables;
   export type mutation = UpdateSomeObjectMutationMutation;
-  export type updateSomeObject = (NonNullable<UpdateSomeObjectMutationMutation['updateSomeObject']>);
+  export type mutated = NonNullable<UpdateSomeObjectMutationMutation['mutated']>;
 }
 
 export namespace DeleteSomeObjectMutation {
@@ -1155,13 +1133,13 @@ export namespace RestoreSomeObjectMutation {
 export namespace CreateReviewMutation {
   export type Variables = CreateReviewMutationMutationVariables;
   export type mutation = CreateReviewMutationMutation;
-  export type createReview = (NonNullable<CreateReviewMutationMutation['createReview']>);
+  export type mutated = NonNullable<CreateReviewMutationMutation['mutated']>;
 }
 
 export namespace UpdateReviewMutation {
   export type Variables = UpdateReviewMutationMutationVariables;
   export type mutation = UpdateReviewMutationMutation;
-  export type updateReview = (NonNullable<UpdateReviewMutationMutation['updateReview']>);
+  export type mutated = NonNullable<UpdateReviewMutationMutation['mutated']>;
 }
 
 export namespace DeleteReviewMutation {
@@ -1177,13 +1155,13 @@ export namespace RestoreReviewMutation {
 export namespace CreateQuestionMutation {
   export type Variables = CreateQuestionMutationMutationVariables;
   export type mutation = CreateQuestionMutationMutation;
-  export type createQuestion = (NonNullable<CreateQuestionMutationMutation['createQuestion']>);
+  export type mutated = NonNullable<CreateQuestionMutationMutation['mutated']>;
 }
 
 export namespace UpdateQuestionMutation {
   export type Variables = UpdateQuestionMutationMutationVariables;
   export type mutation = UpdateQuestionMutationMutation;
-  export type updateQuestion = (NonNullable<UpdateQuestionMutationMutation['updateQuestion']>);
+  export type mutated = NonNullable<UpdateQuestionMutationMutation['mutated']>;
 }
 
 export namespace DeleteQuestionMutation {
@@ -1199,13 +1177,13 @@ export namespace RestoreQuestionMutation {
 export namespace CreateAnswerMutation {
   export type Variables = CreateAnswerMutationMutationVariables;
   export type mutation = CreateAnswerMutationMutation;
-  export type createAnswer = (NonNullable<CreateAnswerMutationMutation['createAnswer']>);
+  export type mutated = NonNullable<CreateAnswerMutationMutation['mutated']>;
 }
 
 export namespace UpdateAnswerMutation {
   export type Variables = UpdateAnswerMutationMutationVariables;
   export type mutation = UpdateAnswerMutationMutation;
-  export type updateAnswer = (NonNullable<UpdateAnswerMutationMutation['updateAnswer']>);
+  export type mutated = NonNullable<UpdateAnswerMutationMutation['mutated']>;
 }
 
 export namespace DeleteAnswerMutation {
diff --git a/tests/generated/client/mutations.ts b/tests/generated/client/mutations.ts
index e7d88a5..962b1dd 100644
--- a/tests/generated/client/mutations.ts
+++ b/tests/generated/client/mutations.ts
@@ -1,109 +1,162 @@
-import { gql } from "../../../src";
+import { gql } from 'graphql-request';
 
 export const DELETE_ANOTHER_OBJECT = gql`
   mutation DeleteAnotherObjectMutation($id: ID!) {
-    deleteAnotherObject(where: { id: $id })
+    mutated: deleteAnotherObject(where: { id: $id })
   }
 `;
 
 export const RESTORE_ANOTHER_OBJECT = gql`
   mutation RestoreAnotherObjectMutation($id: ID!) {
-    restoreAnotherObject(where: { id: $id })
+    mutated: restoreAnotherObject(where: { id: $id })
   }
 `;
 
 export const CREATE_SOME_OBJECT = gql`
   mutation CreateSomeObjectMutation($data: CreateSomeObject!) {
-    createSomeObject(data: $data) { id }
+    mutated: createSomeObject(data: $data) {
+      id
+    }
   }
 `;
 
 export const UPDATE_SOME_OBJECT = gql`
   mutation UpdateSomeObjectMutation($id: ID!, $data: UpdateSomeObject!) {
-    updateSomeObject(where: { id: $id }, data: $data) { id }
+    mutated: updateSomeObject(where: { id: $id }, data: $data) {
+      id
+    }
   }
 `;
 
 export const DELETE_SOME_OBJECT = gql`
   mutation DeleteSomeObjectMutation($id: ID!) {
-    deleteSomeObject(where: { id: $id })
+    mutated: deleteSomeObject(where: { id: $id })
   }
 `;
 
 export const RESTORE_SOME_OBJECT = gql`
   mutation RestoreSomeObjectMutation($id: ID!) {
-    restoreSomeObject(where: { id: $id })
+    mutated: restoreSomeObject(where: { id: $id })
   }
 `;
 
 export const CREATE_REVIEW = gql`
   mutation CreateReviewMutation($data: CreateReview!) {
-    createReview(data: $data) { id }
+    mutated: createReview(data: $data) {
+      id
+    }
   }
 `;
 
 export const UPDATE_REVIEW = gql`
   mutation UpdateReviewMutation($id: ID!, $data: UpdateReview!) {
-    updateReview(where: { id: $id }, data: $data) { id }
+    mutated: updateReview(where: { id: $id }, data: $data) {
+      id
+    }
   }
 `;
 
 export const DELETE_REVIEW = gql`
   mutation DeleteReviewMutation($id: ID!) {
-    deleteReview(where: { id: $id })
+    mutated: deleteReview(where: { id: $id })
   }
 `;
 
 export const RESTORE_REVIEW = gql`
   mutation RestoreReviewMutation($id: ID!) {
-    restoreReview(where: { id: $id })
+    mutated: restoreReview(where: { id: $id })
   }
 `;
 
 export const CREATE_QUESTION = gql`
   mutation CreateQuestionMutation($data: CreateQuestion!) {
-    createQuestion(data: $data) { id }
+    mutated: createQuestion(data: $data) {
+      id
+    }
   }
 `;
 
 export const UPDATE_QUESTION = gql`
   mutation UpdateQuestionMutation($id: ID!, $data: UpdateQuestion!) {
-    updateQuestion(where: { id: $id }, data: $data) { id }
+    mutated: updateQuestion(where: { id: $id }, data: $data) {
+      id
+    }
   }
 `;
 
 export const DELETE_QUESTION = gql`
   mutation DeleteQuestionMutation($id: ID!) {
-    deleteQuestion(where: { id: $id })
+    mutated: deleteQuestion(where: { id: $id })
   }
 `;
 
 export const RESTORE_QUESTION = gql`
   mutation RestoreQuestionMutation($id: ID!) {
-    restoreQuestion(where: { id: $id })
+    mutated: restoreQuestion(where: { id: $id })
   }
 `;
 
 export const CREATE_ANSWER = gql`
   mutation CreateAnswerMutation($data: CreateAnswer!) {
-    createAnswer(data: $data) { id }
+    mutated: createAnswer(data: $data) {
+      id
+    }
   }
 `;
 
 export const UPDATE_ANSWER = gql`
   mutation UpdateAnswerMutation($id: ID!, $data: UpdateAnswer!) {
-    updateAnswer(where: { id: $id }, data: $data) { id }
+    mutated: updateAnswer(where: { id: $id }, data: $data) {
+      id
+    }
   }
 `;
 
 export const DELETE_ANSWER = gql`
   mutation DeleteAnswerMutation($id: ID!) {
-    deleteAnswer(where: { id: $id })
+    mutated: deleteAnswer(where: { id: $id })
   }
 `;
 
 export const RESTORE_ANSWER = gql`
   mutation RestoreAnswerMutation($id: ID!) {
-    restoreAnswer(where: { id: $id })
-  }
-`;
\ No newline at end of file
+    mutated: restoreAnswer(where: { id: $id })
+  }
+`;
+
+export const MUTATIONS = {
+  User: {},
+
+  AnotherObject: {
+    delete: DELETE_ANOTHER_OBJECT,
+    restore: RESTORE_ANOTHER_OBJECT,
+  },
+
+  SomeObject: {
+    create: CREATE_SOME_OBJECT,
+    update: UPDATE_SOME_OBJECT,
+    delete: DELETE_SOME_OBJECT,
+    restore: RESTORE_SOME_OBJECT,
+  },
+
+  Review: {
+    create: CREATE_REVIEW,
+    update: UPDATE_REVIEW,
+    delete: DELETE_REVIEW,
+    restore: RESTORE_REVIEW,
+  },
+
+  Question: {
+    create: CREATE_QUESTION,
+    update: UPDATE_QUESTION,
+    delete: DELETE_QUESTION,
+    restore: RESTORE_QUESTION,
+  },
+
+  Answer: {
+    create: CREATE_ANSWER,
+    update: UPDATE_ANSWER,
+    delete: DELETE_ANSWER,
+    restore: RESTORE_ANSWER,
+  },
+};
diff --git a/tests/generated/db/index.ts b/tests/generated/db/index.ts
index 6ea9158..d48b8e0 100644
--- a/tests/generated/db/index.ts
+++ b/tests/generated/db/index.ts
@@ -7,279 +7,293 @@ export type Role = 'ADMIN' | 'USER';
 export type ReactionType = 'Review' | 'Question' | 'Answer';
 
 export type User = {
-  'id': string;
-  'username': string | null;
-  'role': Role | null;
-}
+  id: string;
+  username: string | null;
+  role: Role | null;
+};
+
+export type FullUser = User;
 
 export type UserInitializer = {
-  'id': string;
-  'username'?: string | null;
-  'role'?: Role | null;
-}
+  id: string | null;
+  username?: string | null;
+  role?: Role | null;
+};
 
 export type UserMutator = {
-  'id'?: string;
-  'username'?: string | null;
-  'role'?: Role | null;
-}
+  id?: string | null;
+  username?: string | null;
+  role?: Role | null;
+};
 
 export type UserSeed = {
-  'id': string;
-  'username'?: string | null;
-  'role'?: string | null;
-}
+  id: string;
+  username?: string | null;
+  role?: string | null;
+};
 
 export type AnotherObject = {
-  'id': string;
-  'name': string | null;
-  'myselfId': string | null;
-  'deleted': boolean;
-  'deletedAt': DateTime | null;
-  'deletedById': string | null;
-}
+  id: string;
+  name: string | null;
+  myselfId: string | null;
+  deleted: boolean;
+  deletedAt: DateTime | null;
+  deletedById: string | null;
+};
+
+export type FullAnotherObject = AnotherObject;
 
 export type AnotherObjectInitializer = {
-  'id': string;
-  'name'?: string | null;
-  'myselfId'?: string | null;
-  'deleted'?: boolean;
-  'deletedAt'?: (DateTime | string) | null;
-  'deletedById'?: string | null;
-}
+  id: string | null;
+  name?: string | null;
+  myselfId?: string | null;
+  deleted?: boolean | null;
+  deletedAt?: (DateTime | string) | null;
+  deletedById?: string | null;
+};
 
 export type AnotherObjectMutator = {
-  'id'?: string;
-  'name'?: string | null;
-  'myselfId'?: string | null;
-  'deleted'?: boolean;
-  'deletedAt'?: (DateTime | string) | null;
-  'deletedById'?: string | null;
-}
+  id?: string | null;
+  name?: string | null;
+  myselfId?: string | null;
+  deleted?: boolean | null;
+  deletedAt?: (DateTime | string) | null;
+  deletedById?: string | null;
+};
 
 export type AnotherObjectSeed = {
-  'id': string;
-  'name'?: string | null;
-  'myselfId'?: string | null;
-  'deleted'?: boolean;
-  'deletedAt'?: (DateTime | string) | null;
-  'deletedById'?: string | null;
-}
+  id: string;
+  name?: string | null;
+  myselfId?: string | null;
+  deleted?: boolean;
+  deletedAt?: (DateTime | string) | null;
+  deletedById?: string | null;
+};
 
 export type SomeObject = {
-  'id': string;
-  'field': string | null;
-  'anotherId': string;
-  'float': number;
-  'list': SomeEnum[];
-  'xyz': number;
-  'createdAt': DateTime;
-  'createdById': string;
-  'updatedAt': DateTime;
-  'updatedById': string;
-  'deleted': boolean;
-  'deletedAt': DateTime | null;
-  'deletedById': string | null;
-}
+  id: string;
+  field: string | null;
+  anotherId: string;
+  float: number;
+  list: SomeEnum[];
+  xyz: number;
+  createdAt: DateTime;
+  createdById: string;
+  updatedAt: DateTime;
+  updatedById: string;
+  deleted: boolean;
+  deletedAt: DateTime | null;
+  deletedById: string | null;
+};
+
+export type FullSomeObject = SomeObject;
 
 export type SomeObjectInitializer = {
-  'id': string;
-  'field'?: string | null;
-  'anotherId': string;
-  'float': number;
-  'list': SomeEnum[] | string;
-  'xyz': number;
-  'createdAt': (DateTime | string);
-  'createdById': string;
-  'updatedAt': (DateTime | string);
-  'updatedById': string;
-  'deleted'?: boolean;
-  'deletedAt'?: (DateTime | string) | null;
-  'deletedById'?: string | null;
-}
+  id: string | null;
+  field?: string | null;
+  anotherId: string | null;
+  float: number | null;
+  list: SomeEnum[] | string | null;
+  xyz: number | null;
+  createdAt: (DateTime | string) | null;
+  createdById: string | null;
+  updatedAt: (DateTime | string) | null;
+  updatedById: string | null;
+  deleted?: boolean | null;
+  deletedAt?: (DateTime | string) | null;
+  deletedById?: string | null;
+};
 
 export type SomeObjectMutator = {
-  'id'?: string;
-  'field'?: string | null;
-  'anotherId'?: string;
-  'float'?: number;
-  'list'?: SomeEnum[] | string;
-  'xyz'?: number;
-  'createdAt'?: (DateTime | string);
-  'createdById'?: string;
-  'updatedAt'?: (DateTime | string);
-  'updatedById'?: string;
-  'deleted'?: boolean;
-  'deletedAt'?: (DateTime | string) | null;
-  'deletedById'?: string | null;
-}
+  id?: string | null;
+  field?: string | null;
+  anotherId?: string | null;
+  float?: number | null;
+  list?: SomeEnum[] | string | null;
+  xyz?: number | null;
+  createdAt?: (DateTime | string) | null;
+  createdById?: string | null;
+  updatedAt?: (DateTime | string) | null;
+  updatedById?: string | null;
+  deleted?: boolean | null;
+  deletedAt?: (DateTime | string) | null;
+  deletedById?: string | null;
+};
 
 export type SomeObjectSeed = {
-  'id': string;
-  'field'?: string | null;
-  'anotherId': string;
-  'float': number;
-  'list': string[] | string;
-  'xyz': number;
-  'createdAt'?: (DateTime | string);
-  'createdById'?: string;
-  'updatedAt'?: (DateTime | string);
-  'updatedById'?: string;
-  'deleted'?: boolean;
-  'deletedAt'?: (DateTime | string) | null;
-  'deletedById'?: string | null;
-}
+  id: string;
+  field?: string | null;
+  anotherId: string;
+  float: number;
+  list: string[] | string;
+  xyz: number;
+  createdAt?: DateTime | string;
+  createdById?: string;
+  updatedAt?: DateTime | string;
+  updatedById?: string;
+  deleted?: boolean;
+  deletedAt?: (DateTime | string) | null;
+  deletedById?: string | null;
+};
 
 export type Reaction = {
-  'id': string;
-  'type': ReactionType;
-  'parentId': string | null;
-  'content': string | null;
-  'createdAt': DateTime;
-  'createdById': string;
-  'updatedAt': DateTime;
-  'updatedById': string;
-  'deleted': boolean;
-  'deletedAt': DateTime | null;
-  'deletedById': string | null;
-}
+  id: string;
+  type: ReactionType;
+  parentId: string | null;
+  content: string | null;
+  createdAt: DateTime;
+  createdById: string;
+  updatedAt: DateTime;
+  updatedById: string;
+  deleted: boolean;
+  deletedAt: DateTime | null;
+  deletedById: string | null;
+};
+
+export type FullReaction = Reaction;
 
 export type ReactionInitializer = {
-  'id': string;
-  'type': ReactionType;
-  'parentId'?: string | null;
-  'content'?: string | null;
-  'createdAt': (DateTime | string);
-  'createdById': string;
-  'updatedAt': (DateTime | string);
-  'updatedById': string;
-  'deleted'?: boolean;
-  'deletedAt'?: (DateTime | string) | null;
-  'deletedById'?: string | null;
-}
+  id: string | null;
+  type: ReactionType | null;
+  parentId?: string | null;
+  content?: string | null;
+  createdAt: (DateTime | string) | null;
+  createdById: string | null;
+  updatedAt: (DateTime | string) | null;
+  updatedById: string | null;
+  deleted?: boolean | null;
+  deletedAt?: (DateTime | string) | null;
+  deletedById?: string | null;
+};
 
 export type ReactionMutator = {
-  'id'?: string;
-  'type'?: ReactionType;
-  'parentId'?: string | null;
-  'content'?: string | null;
-  'createdAt'?: (DateTime | string);
-  'createdById'?: string;
-  'updatedAt'?: (DateTime | string);
-  'updatedById'?: string;
-  'deleted'?: boolean;
-  'deletedAt'?: (DateTime | string) | null;
-  'deletedById'?: string | null;
-}
+  id?: string | null;
+  type?: ReactionType | null;
+  parentId?: string | null;
+  content?: string | null;
+  createdAt?: (DateTime | string) | null;
+  createdById?: string | null;
+  updatedAt?: (DateTime | string) | null;
+  updatedById?: string | null;
+  deleted?: boolean | null;
+  deletedAt?: (DateTime | string) | null;
+  deletedById?: string | null;
+};
 
 export type Review = {
-  'id': string;
-  'type': ReactionType;
-  'parentId': string | null;
-  'content': string | null;
-  'createdAt': DateTime;
-  'createdById': string;
-  'updatedAt': DateTime;
-  'updatedById': string;
-  'deleted': boolean;
-  'deletedAt': DateTime | null;
-  'deletedById': string | null;
-  'rating': number | null;
-}
+  id: string;
+  type: ReactionType;
+  parentId: string | null;
+  content: string | null;
+  createdAt: DateTime;
+  createdById: string;
+  updatedAt: DateTime;
+  updatedById: string;
+  deleted: boolean;
+  deletedAt: DateTime | null;
+  deletedById: string | null;
+  rating: number | null;
+};
+
+export type FullReview = Review & Reaction;
 
 export type ReviewInitializer = {
-  'id': string;
-  'rating'?: number | null;
-}
+  id: string | null;
+  rating?: number | null;
+};
 
 export type ReviewMutator = {
-  'id'?: string;
-  'rating'?: number | null;
-}
+  id?: string | null;
+  rating?: number | null;
+};
 
 export type ReviewSeed = {
-  'id': string;
-  'parentId'?: string | null;
-  'content'?: string | null;
-  'createdAt'?: (DateTime | string);
-  'createdById'?: string;
-  'updatedAt'?: (DateTime | string);
-  'updatedById'?: string;
-  'deleted'?: boolean;
-  'deletedAt'?: (DateTime | string) | null;
-  'deletedById'?: string | null;
-  'rating'?: number | null;
-}
+  id: string;
+  parentId?: string | null;
+  content?: string | null;
+  createdAt?: DateTime | string;
+  createdById?: string;
+  updatedAt?: DateTime | string;
+  updatedById?: string;
+  deleted?: boolean;
+  deletedAt?: (DateTime | string) | null;
+  deletedById?: string | null;
+  rating?: number | null;
+};
 
 export type Question = {
-  'id': string;
-  'type': ReactionType;
-  'parentId': string | null;
-  'content': string | null;
-  'createdAt': DateTime;
-  'createdById': string;
-  'updatedAt': DateTime;
-  'updatedById': string;
-  'deleted': boolean;
-  'deletedAt': DateTime | null;
-  'deletedById': string | null;
-}
+  id: string;
+  type: ReactionType;
+  parentId: string | null;
+  content: string | null;
+  createdAt: DateTime;
+  createdById: string;
+  updatedAt: DateTime;
+  updatedById: string;
+  deleted: boolean;
+  deletedAt: DateTime | null;
+  deletedById: string | null;
+};
+
+export type FullQuestion = Question & Reaction;
 
 export type QuestionInitializer = {
-  'id': string;
-}
+  id: string | null;
+};
 
 export type QuestionMutator = {
-  'id'?: string;
-}
+  id?: string | null;
+};
 
 export type QuestionSeed = {
-  'id': string;
-  'parentId'?: string | null;
-  'content'?: string | null;
-  'createdAt'?: (DateTime | string);
-  'createdById'?: string;
-  'updatedAt'?: (DateTime | string);
-  'updatedById'?: string;
-  'deleted'?: boolean;
-  'deletedAt'?: (DateTime | string) | null;
-  'deletedById'?: string | null;
-}
+  id: string;
+  parentId?: string | null;
+  content?: string | null;
+  createdAt?: DateTime | string;
+  createdById?: string;
+  updatedAt?: DateTime | string;
+  updatedById?: string;
+  deleted?: boolean;
+  deletedAt?: (DateTime | string) | null;
+  deletedById?: string | null;
+};
 
 export type Answer = {
-  'id': string;
-  'type': ReactionType;
-  'parentId': string | null;
-  'content': string | null;
-  'createdAt': DateTime;
-  'createdById': string;
-  'updatedAt': DateTime;
-  'updatedById': string;
-  'deleted': boolean;
-  'deletedAt': DateTime | null;
-  'deletedById': string | null;
-}
+  id: string;
+  type: ReactionType;
+  parentId: string | null;
+  content: string | null;
+  createdAt: DateTime;
+  createdById: string;
+  updatedAt: DateTime;
+  updatedById: string;
+  deleted: boolean;
+  deletedAt: DateTime | null;
+  deletedById: string | null;
+};
+
+export type FullAnswer = Answer & Reaction;
 
 export type AnswerInitializer = {
-  'id': string;
-}
+  id: string | null;
+};
 
 export type AnswerMutator = {
-  'id'?: string;
-}
+  id?: string | null;
+};
 
 export type AnswerSeed = {
-  'id': string;
-  'parentId'?: string | null;
-  'content'?: string | null;
-  'createdAt'?: (DateTime | string);
-  'createdById'?: string;
-  'updatedAt'?: (DateTime | string);
-  'updatedById'?: string;
-  'deleted'?: boolean;
-  'deletedAt'?: (DateTime | string) | null;
-  'deletedById'?: string | null;
-}
+  id: string;
+  parentId?: string | null;
+  content?: string | null;
+  createdAt?: DateTime | string;
+  createdById?: string;
+  updatedAt?: DateTime | string;
+  updatedById?: string;
+  deleted?: boolean;
+  deletedAt?: (DateTime | string) | null;
+  deletedById?: string | null;
+};
 
 export type SeedData = {
   User: UserSeed[];
@@ -288,4 +302,4 @@ export type SeedData = {
   Review: ReviewSeed[];
   Question: QuestionSeed[];
   Answer: AnswerSeed[];
-}
\ No newline at end of file
+};
diff --git a/tests/generated/db/knex.ts b/tests/generated/db/knex.ts
index a70e52f..3749d22 100644
--- a/tests/generated/db/knex.ts
+++ b/tests/generated/db/knex.ts
@@ -1,14 +1,36 @@
 import { Knex } from 'knex';
-import { User, UserInitializer, UserMutator, AnotherObject, AnotherObjectInitializer, AnotherObjectMutator, SomeObject, SomeObjectInitializer, SomeObjectMutator, Reaction, ReactionInitializer, ReactionMutator, Review, ReviewInitializer, ReviewMutator, Question, QuestionInitializer, QuestionMutator, Answer, AnswerInitializer, AnswerMutator } from '.';
+import {
+  User,
+  UserInitializer,
+  UserMutator,
+  AnotherObject,
+  AnotherObjectInitializer,
+  AnotherObjectMutator,
+  SomeObject,
+  SomeObjectInitializer,
+  SomeObjectMutator,
+  Reaction,
+  ReactionInitializer,
+  ReactionMutator,
+  Review,
+  ReviewInitializer,
+  ReviewMutator,
+  Question,
+  QuestionInitializer,
+  QuestionMutator,
+  Answer,
+  AnswerInitializer,
+  AnswerMutator,
+} from '.';
 
 declare module 'knex/types/tables' {
   interface Tables {
-    'User': Knex.CompositeTableType<User, UserInitializer, UserMutator>,
-    'AnotherObject': Knex.CompositeTableType<AnotherObject, AnotherObjectInitializer, AnotherObjectMutator>,
-    'SomeObject': Knex.CompositeTableType<SomeObject, SomeObjectInitializer, SomeObjectMutator>,
-    'Reaction': Knex.CompositeTableType<Reaction, ReactionInitializer, ReactionMutator>,
-    'Review': Knex.CompositeTableType<Review, ReviewInitializer, ReviewMutator>,
-    'Question': Knex.CompositeTableType<Question, QuestionInitializer, QuestionMutator>,
-    'Answer': Knex.CompositeTableType<Answer, AnswerInitializer, AnswerMutator>,
+    User: Knex.CompositeTableType<User, UserInitializer, UserMutator>;
+    AnotherObject: Knex.CompositeTableType<AnotherObject, AnotherObjectInitializer, AnotherObjectMutator>;
+    SomeObject: Knex.CompositeTableType<SomeObject, SomeObjectInitializer, SomeObjectMutator>;
+    Reaction: Knex.CompositeTableType<Reaction, ReactionInitializer, ReactionMutator>;
+    Review: Knex.CompositeTableType<Review, ReviewInitializer, ReviewMutator>;
+    Question: Knex.CompositeTableType<Question, QuestionInitializer, QuestionMutator>;
+    Answer: Knex.CompositeTableType<Answer, AnswerInitializer, AnswerMutator>;
   }
-}
\ No newline at end of file
+}
diff --git a/tests/generated/resolvers/index.ts b/tests/generated/resolvers/index.ts
new file mode 100644
index 0000000..83b02e0
--- /dev/null
+++ b/tests/generated/resolvers/index.ts
@@ -0,0 +1,1250 @@
+import { GraphQLResolveInfo } from 'graphql';
+import { IncomingMessage } from 'http';
+import { v4 as uuid } from 'uuid';
+import { Knex } from 'knex';
+import * as db from '../db';
+import * as api from '../api';
+
+import { DateTime } from 'luxon';
+import {
+  Models,
+  Permissions,
+  AliasGenerator,
+  applyPermissions,
+  queryResolver,
+  getEntityToMutate,
+  resolve,
+  checkCanWrite,
+  GraphQLError,
+  ForbiddenError,
+  anyDateToLuxon,
+  EntityModel,
+} from '../../../src';
+
+import { pick } from 'lodash';
+
+export type Entity = Record<string, unknown>;
+
+export type Action = 'create' | 'update' | 'delete' | 'restore';
+
+export type MutationHook = (
+  model: EntityModel,
+  action: Action,
+  when: 'before' | 'after',
+  data: { prev: Entity; input: Entity; normalizedInput: Entity; next: Entity },
+  ctx: Context
+) => Promise<void>;
+
+export type User = { id: string; role: string };
+
+export type Context = {
+  req: IncomingMessage;
+  now: DateTime;
+  timeZone?: string;
+  knex: Knex;
+  locale: string;
+  locales: string[];
+  user?: User;
+  models: Models;
+  permissions: Permissions;
+  mutationHook?: MutationHook;
+};
+
+export type FullContext = Context & {
+  info: GraphQLResolveInfo;
+  aliases: AliasGenerator;
+};
+
+type Callbacks = (() => Promise<void>)[];
+
+type DeleteContext = {
+  model: EntityModel;
+  toDelete: { [type: string]: { [id: string]: string } };
+  toUnlink: {
+    [type: string]: {
+      [id: string]: {
+        display: string;
+        fields: string[];
+      };
+    };
+  };
+  dryRun: boolean;
+  beforeHooks: Callbacks;
+  mutations: Callbacks;
+  afterHooks: Callbacks;
+};
+
+type RestoreContext = {
+  entity: any;
+  model: EntityModel;
+  beforeHooks: Callbacks;
+  mutations: Callbacks;
+  afterHooks: Callbacks;
+};
+export const resolvers = {
+  Query: {
+    me: queryResolver,
+    someObject: queryResolver,
+    reaction: queryResolver,
+    review: queryResolver,
+    question: queryResolver,
+    answer: queryResolver,
+    anotherObjects: queryResolver,
+    manyObjects: queryResolver,
+    reactions: queryResolver,
+    reviews: queryResolver,
+    questions: queryResolver,
+    answers: queryResolver,
+  },
+  Mutation: {
+    createSomeObject: async (
+      _parent: unknown,
+      { data: input }: api.MutationCreateSomeObjectArgs,
+      partialCtx: Context,
+      info: GraphQLResolveInfo
+    ) => {
+      return await partialCtx.knex.transaction(async (knex) => {
+        const ctx: FullContext = { ...partialCtx, knex, info, aliases: new AliasGenerator() };
+        const model = ctx.models.getModel('SomeObject', 'entity');
+        const normalizedInput: Partial<db.SomeObjectInitializer & db.SomeObjectInitializer> = { ...input };
+        normalizedInput.id = uuid();
+        normalizedInput.createdAt = ctx.now;
+        normalizedInput.createdById = ctx.user?.id;
+        normalizedInput.updatedAt = ctx.now;
+        normalizedInput.updatedById = ctx.user?.id;
+        await checkCanWrite(ctx, model, normalizedInput, 'CREATE');
+        const data = { prev: {}, input, normalizedInput, next: normalizedInput };
+        await ctx.mutationHook?.(model, 'create', 'before', data, ctx);
+        await knex(model.name).insert(normalizedInput);
+        await createSomeObjectRevision(normalizedInput, ctx);
+        await ctx.mutationHook?.(model, 'create', 'after', data, ctx);
+        return await resolve(ctx, normalizedInput.id);
+      });
+    },
+
+    createReview: async (
+      _parent: unknown,
+      { data: input }: api.MutationCreateReviewArgs,
+      partialCtx: Context,
+      info: GraphQLResolveInfo
+    ) => {
+      return await partialCtx.knex.transaction(async (knex) => {
+        const ctx: FullContext = { ...partialCtx, knex, info, aliases: new AliasGenerator() };
+        const model = ctx.models.getModel('Review', 'entity');
+        const normalizedInput: Partial<db.ReactionInitializer & db.ReviewInitializer> = { ...input };
+        normalizedInput.id = uuid();
+        normalizedInput.createdAt = ctx.now;
+        normalizedInput.createdById = ctx.user?.id;
+        normalizedInput.type = 'Review';
+        normalizedInput.updatedAt = ctx.now;
+        normalizedInput.updatedById = ctx.user?.id;
+        await checkCanWrite(ctx, model, normalizedInput, 'CREATE');
+        const data = { prev: {}, input, normalizedInput, next: normalizedInput };
+        await ctx.mutationHook?.(model, 'create', 'before', data, ctx);
+        const rootInput: Partial<db.ReactionInitializer> = pick(
+          normalizedInput,
+          'id',
+          'type',
+          'parentId',
+          'content',
+          'createdAt',
+          'createdById',
+          'updatedAt',
+          'updatedById',
+          'deleted',
+          'deletedAt',
+          'deletedById'
+        );
+        const childInput: Partial<db.ReviewInitializer> = pick(normalizedInput, 'id', 'rating');
+        await knex(model.parent).insert(rootInput);
+        await knex(model.name).insert(childInput);
+        await createReviewRevision(normalizedInput, ctx);
+        await ctx.mutationHook?.(model, 'create', 'after', data, ctx);
+        return await resolve(ctx, normalizedInput.id);
+      });
+    },
+
+    createQuestion: async (
+      _parent: unknown,
+      { data: input }: api.MutationCreateQuestionArgs,
+      partialCtx: Context,
+      info: GraphQLResolveInfo
+    ) => {
+      return await partialCtx.knex.transaction(async (knex) => {
+        const ctx: FullContext = { ...partialCtx, knex, info, aliases: new AliasGenerator() };
+        const model = ctx.models.getModel('Question', 'entity');
+        const normalizedInput: Partial<db.ReactionInitializer & db.QuestionInitializer> = { ...input };
+        normalizedInput.id = uuid();
+        normalizedInput.createdAt = ctx.now;
+        normalizedInput.createdById = ctx.user?.id;
+        normalizedInput.type = 'Question';
+        normalizedInput.updatedAt = ctx.now;
+        normalizedInput.updatedById = ctx.user?.id;
+        await checkCanWrite(ctx, model, normalizedInput, 'CREATE');
+        const data = { prev: {}, input, normalizedInput, next: normalizedInput };
+        await ctx.mutationHook?.(model, 'create', 'before', data, ctx);
+        const rootInput: Partial<db.ReactionInitializer> = pick(
+          normalizedInput,
+          'id',
+          'type',
+          'parentId',
+          'content',
+          'createdAt',
+          'createdById',
+          'updatedAt',
+          'updatedById',
+          'deleted',
+          'deletedAt',
+          'deletedById'
+        );
+        const childInput: Partial<db.QuestionInitializer> = pick(normalizedInput, 'id');
+        await knex(model.parent).insert(rootInput);
+        await knex(model.name).insert(childInput);
+        await createQuestionRevision(normalizedInput, ctx);
+        await ctx.mutationHook?.(model, 'create', 'after', data, ctx);
+        return await resolve(ctx, normalizedInput.id);
+      });
+    },
+
+    createAnswer: async (
+      _parent: unknown,
+      { data: input }: api.MutationCreateAnswerArgs,
+      partialCtx: Context,
+      info: GraphQLResolveInfo
+    ) => {
+      return await partialCtx.knex.transaction(async (knex) => {
+        const ctx: FullContext = { ...partialCtx, knex, info, aliases: new AliasGenerator() };
+        const model = ctx.models.getModel('Answer', 'entity');
+        const normalizedInput: Partial<db.ReactionInitializer & db.AnswerInitializer> = { ...input };
+        normalizedInput.id = uuid();
+        normalizedInput.createdAt = ctx.now;
+        normalizedInput.createdById = ctx.user?.id;
+        normalizedInput.type = 'Answer';
+        normalizedInput.updatedAt = ctx.now;
+        normalizedInput.updatedById = ctx.user?.id;
+        await checkCanWrite(ctx, model, normalizedInput, 'CREATE');
+        const data = { prev: {}, input, normalizedInput, next: normalizedInput };
+        await ctx.mutationHook?.(model, 'create', 'before', data, ctx);
+        const rootInput: Partial<db.ReactionInitializer> = pick(
+          normalizedInput,
+          'id',
+          'type',
+          'parentId',
+          'content',
+          'createdAt',
+          'createdById',
+          'updatedAt',
+          'updatedById',
+          'deleted',
+          'deletedAt',
+          'deletedById'
+        );
+        const childInput: Partial<db.AnswerInitializer> = pick(normalizedInput, 'id');
+        await knex(model.parent).insert(rootInput);
+        await knex(model.name).insert(childInput);
+        await createAnswerRevision(normalizedInput, ctx);
+        await ctx.mutationHook?.(model, 'create', 'after', data, ctx);
+        return await resolve(ctx, normalizedInput.id);
+      });
+    },
+
+    updateSomeObject: async (
+      _parent: unknown,
+      { where, data: input }: api.MutationUpdateSomeObjectArgs,
+      partialCtx: Context,
+      info: GraphQLResolveInfo
+    ) => {
+      return await partialCtx.knex.transaction(async (knex) => {
+        const ctx: FullContext = { ...partialCtx, knex, info, aliases: new AliasGenerator() };
+        const model = ctx.models.getModel('SomeObject', 'entity');
+        if (Object.keys(where).length === 0) {
+          throw new Error(`No SomeObject specified.`);
+        }
+        const normalizedInput: Partial<db.SomeObjectMutator & db.SomeObjectMutator> = { ...input };
+        normalizedInput.updatedAt = ctx.now;
+        normalizedInput.updatedById = ctx.user?.id;
+        const prev = await getEntityToMutate(ctx, model, where, 'UPDATE');
+        for (const key of Object.keys(normalizedInput)) {
+          if (normalizedInput[key] === prev[key]) {
+            delete normalizedInput[key];
+          }
+        }
+
+        if (Object.keys(normalizedInput).length > 0) {
+          await checkCanWrite(ctx, model, normalizedInput, 'UPDATE');
+          const next = { ...prev, ...normalizedInput };
+          const data = { prev, input, normalizedInput, next };
+          await ctx.mutationHook?.(model, 'update', 'before', data, ctx);
+          await ctx.knex(model.name).where({ id: prev.id }).update(normalizedInput);
+          await createSomeObjectRevision(next, ctx);
+          await ctx.mutationHook?.(model, 'update', 'after', data, ctx);
+        }
+
+        return await resolve(ctx);
+      });
+    },
+
+    updateReview: async (
+      _parent: unknown,
+      { where, data: input }: api.MutationUpdateReviewArgs,
+      partialCtx: Context,
+      info: GraphQLResolveInfo
+    ) => {
+      return await partialCtx.knex.transaction(async (knex) => {
+        const ctx: FullContext = { ...partialCtx, knex, info, aliases: new AliasGenerator() };
+        const model = ctx.models.getModel('Review', 'entity');
+        if (Object.keys(where).length === 0) {
+          throw new Error(`No Review specified.`);
+        }
+        const normalizedInput: Partial<db.ReactionMutator & db.ReviewMutator> = { ...input };
+        normalizedInput.updatedAt = ctx.now;
+        normalizedInput.updatedById = ctx.user?.id;
+        const prev = await getEntityToMutate(ctx, model, where, 'UPDATE');
+        for (const key of Object.keys(normalizedInput)) {
+          if (normalizedInput[key] === prev[key]) {
+            delete normalizedInput[key];
+          }
+        }
+
+        if (Object.keys(normalizedInput).length > 0) {
+          await checkCanWrite(ctx, model, normalizedInput, 'UPDATE');
+          const next = { ...prev, ...normalizedInput };
+          const data = { prev, input, normalizedInput, next };
+          await ctx.mutationHook?.(model, 'update', 'before', data, ctx);
+          const rootInput: Partial<db.ReactionInitializer> = pick(
+            normalizedInput,
+            'id',
+            'type',
+            'parentId',
+            'content',
+            'createdAt',
+            'createdById',
+            'updatedAt',
+            'updatedById',
+            'deleted',
+            'deletedAt',
+            'deletedById'
+          );
+          const childInput: Partial<db.ReviewInitializer> = pick(normalizedInput, 'id', 'rating');
+          if (Object.keys(rootInput).length) {
+            await ctx.knex(model.parent).where({ id: prev.id }).update(rootInput);
+          }
+
+          if (Object.keys(childInput).length) {
+            await ctx.knex(model.name).where({ id: prev.id }).update(childInput);
+          }
+
+          await createReviewRevision(next, ctx);
+          await ctx.mutationHook?.(model, 'update', 'after', data, ctx);
+        }
+
+        return await resolve(ctx);
+      });
+    },
+
+    updateQuestion: async (
+      _parent: unknown,
+      { where, data: input }: api.MutationUpdateQuestionArgs,
+      partialCtx: Context,
+      info: GraphQLResolveInfo
+    ) => {
+      return await partialCtx.knex.transaction(async (knex) => {
+        const ctx: FullContext = { ...partialCtx, knex, info, aliases: new AliasGenerator() };
+        const model = ctx.models.getModel('Question', 'entity');
+        if (Object.keys(where).length === 0) {
+          throw new Error(`No Question specified.`);
+        }
+        const normalizedInput: Partial<db.ReactionMutator & db.QuestionMutator> = { ...input };
+        normalizedInput.updatedAt = ctx.now;
+        normalizedInput.updatedById = ctx.user?.id;
+        const prev = await getEntityToMutate(ctx, model, where, 'UPDATE');
+        for (const key of Object.keys(normalizedInput)) {
+          if (normalizedInput[key] === prev[key]) {
+            delete normalizedInput[key];
+          }
+        }
+
+        if (Object.keys(normalizedInput).length > 0) {
+          await checkCanWrite(ctx, model, normalizedInput, 'UPDATE');
+          const next = { ...prev, ...normalizedInput };
+          const data = { prev, input, normalizedInput, next };
+          await ctx.mutationHook?.(model, 'update', 'before', data, ctx);
+          const rootInput: Partial<db.ReactionInitializer> = pick(
+            normalizedInput,
+            'id',
+            'type',
+            'parentId',
+            'content',
+            'createdAt',
+            'createdById',
+            'updatedAt',
+            'updatedById',
+            'deleted',
+            'deletedAt',
+            'deletedById'
+          );
+          const childInput: Partial<db.QuestionInitializer> = pick(normalizedInput, 'id');
+          if (Object.keys(rootInput).length) {
+            await ctx.knex(model.parent).where({ id: prev.id }).update(rootInput);
+          }
+
+          if (Object.keys(childInput).length) {
+            await ctx.knex(model.name).where({ id: prev.id }).update(childInput);
+          }
+
+          await createQuestionRevision(next, ctx);
+          await ctx.mutationHook?.(model, 'update', 'after', data, ctx);
+        }
+
+        return await resolve(ctx);
+      });
+    },
+
+    updateAnswer: async (
+      _parent: unknown,
+      { where, data: input }: api.MutationUpdateAnswerArgs,
+      partialCtx: Context,
+      info: GraphQLResolveInfo
+    ) => {
+      return await partialCtx.knex.transaction(async (knex) => {
+        const ctx: FullContext = { ...partialCtx, knex, info, aliases: new AliasGenerator() };
+        const model = ctx.models.getModel('Answer', 'entity');
+        if (Object.keys(where).length === 0) {
+          throw new Error(`No Answer specified.`);
+        }
+        const normalizedInput: Partial<db.ReactionMutator & db.AnswerMutator> = { ...input };
+        normalizedInput.updatedAt = ctx.now;
+        normalizedInput.updatedById = ctx.user?.id;
+        const prev = await getEntityToMutate(ctx, model, where, 'UPDATE');
+        for (const key of Object.keys(normalizedInput)) {
+          if (normalizedInput[key] === prev[key]) {
+            delete normalizedInput[key];
+          }
+        }
+
+        if (Object.keys(normalizedInput).length > 0) {
+          await checkCanWrite(ctx, model, normalizedInput, 'UPDATE');
+          const next = { ...prev, ...normalizedInput };
+          const data = { prev, input, normalizedInput, next };
+          await ctx.mutationHook?.(model, 'update', 'before', data, ctx);
+          const rootInput: Partial<db.ReactionInitializer> = pick(
+            normalizedInput,
+            'id',
+            'type',
+            'parentId',
+            'content',
+            'createdAt',
+            'createdById',
+            'updatedAt',
+            'updatedById',
+            'deleted',
+            'deletedAt',
+            'deletedById'
+          );
+          const childInput: Partial<db.AnswerInitializer> = pick(normalizedInput, 'id');
+          if (Object.keys(rootInput).length) {
+            await ctx.knex(model.parent).where({ id: prev.id }).update(rootInput);
+          }
+
+          if (Object.keys(childInput).length) {
+            await ctx.knex(model.name).where({ id: prev.id }).update(childInput);
+          }
+
+          await createAnswerRevision(next, ctx);
+          await ctx.mutationHook?.(model, 'update', 'after', data, ctx);
+        }
+
+        return await resolve(ctx);
+      });
+    },
+
+    deleteAnotherObject: async (
+      _parent: unknown,
+      { where, dryRun }: api.MutationDeleteAnotherObjectArgs,
+      partialCtx: Context,
+      info: GraphQLResolveInfo
+    ) => {
+      return await partialCtx.knex.transaction(async (knex) => {
+        const ctx: FullContext = { ...partialCtx, knex, info, aliases: new AliasGenerator() };
+        const model = ctx.models.getModel('AnotherObject', 'entity');
+        if (Object.keys(where).length === 0) {
+          throw new Error(`No AnotherObject specified.`);
+        }
+
+        const rootModel = model.rootModel;
+        const entity = await getEntityToMutate(ctx, rootModel, where, 'DELETE');
+        if (entity.deleted) {
+          throw new ForbiddenError('Entity is already deleted.');
+        }
+
+        const deleteContext: DeleteContext = {
+          model,
+          dryRun: !!dryRun,
+          toDelete: {},
+          toUnlink: {},
+          beforeHooks: [],
+          mutations: [],
+          afterHooks: [],
+        };
+        await deleteAnotherObjectCascade(entity, ctx, deleteContext);
+        for (const callback of [...deleteContext.beforeHooks, ...deleteContext.mutations, ...deleteContext.afterHooks]) {
+          await callback();
+        }
+
+        if (dryRun) {
+          throw new GraphQLError(`Delete dry run:`, {
+            code: 'DELETE_DRY_RUN',
+            toDelete: deleteContext.toDelete,
+            toUnlink: deleteContext.toUnlink,
+          });
+        }
+
+        return entity.id;
+      });
+    },
+
+    restoreAnotherObject: async (
+      _parent: unknown,
+      { where }: api.MutationRestoreAnotherObjectArgs,
+      partialCtx: Context,
+      info: GraphQLResolveInfo
+    ) => {
+      return await partialCtx.knex.transaction(async (knex) => {
+        const ctx: FullContext = { ...partialCtx, knex, info, aliases: new AliasGenerator() };
+        const model = ctx.models.getModel('AnotherObject', 'entity');
+        if (Object.keys(where).length === 0) {
+          throw new Error(`No AnotherObject specified.`);
+        }
+
+        const rootModel = model.rootModel;
+        const entity = await getEntityToMutate(ctx, rootModel, where, 'RESTORE');
+        if (!entity.deleted) {
+          throw new ForbiddenError('Entity is not deleted.');
+        }
+
+        const restoreContext: RestoreContext = {
+          entity,
+          model,
+          beforeHooks: [],
+          mutations: [],
+          afterHooks: [],
+        };
+        await restoreAnotherObjectCascade(entity, ctx, restoreContext);
+        for (const callback of [...restoreContext.beforeHooks, ...restoreContext.mutations, ...restoreContext.afterHooks]) {
+          await callback();
+        }
+
+        return entity.id;
+      });
+    },
+
+    deleteSomeObject: async (
+      _parent: unknown,
+      { where, dryRun }: api.MutationDeleteSomeObjectArgs,
+      partialCtx: Context,
+      info: GraphQLResolveInfo
+    ) => {
+      return await partialCtx.knex.transaction(async (knex) => {
+        const ctx: FullContext = { ...partialCtx, knex, info, aliases: new AliasGenerator() };
+        const model = ctx.models.getModel('SomeObject', 'entity');
+        if (Object.keys(where).length === 0) {
+          throw new Error(`No SomeObject specified.`);
+        }
+
+        const rootModel = model.rootModel;
+        const entity = await getEntityToMutate(ctx, rootModel, where, 'DELETE');
+        if (entity.deleted) {
+          throw new ForbiddenError('Entity is already deleted.');
+        }
+
+        const deleteContext: DeleteContext = {
+          model,
+          dryRun: !!dryRun,
+          toDelete: {},
+          toUnlink: {},
+          beforeHooks: [],
+          mutations: [],
+          afterHooks: [],
+        };
+        await deleteSomeObjectCascade(entity, ctx, deleteContext);
+        for (const callback of [...deleteContext.beforeHooks, ...deleteContext.mutations, ...deleteContext.afterHooks]) {
+          await callback();
+        }
+
+        if (dryRun) {
+          throw new GraphQLError(`Delete dry run:`, {
+            code: 'DELETE_DRY_RUN',
+            toDelete: deleteContext.toDelete,
+            toUnlink: deleteContext.toUnlink,
+          });
+        }
+
+        return entity.id;
+      });
+    },
+
+    restoreSomeObject: async (
+      _parent: unknown,
+      { where }: api.MutationRestoreSomeObjectArgs,
+      partialCtx: Context,
+      info: GraphQLResolveInfo
+    ) => {
+      return await partialCtx.knex.transaction(async (knex) => {
+        const ctx: FullContext = { ...partialCtx, knex, info, aliases: new AliasGenerator() };
+        const model = ctx.models.getModel('SomeObject', 'entity');
+        if (Object.keys(where).length === 0) {
+          throw new Error(`No SomeObject specified.`);
+        }
+
+        const rootModel = model.rootModel;
+        const entity = await getEntityToMutate(ctx, rootModel, where, 'RESTORE');
+        if (!entity.deleted) {
+          throw new ForbiddenError('Entity is not deleted.');
+        }
+
+        const restoreContext: RestoreContext = {
+          entity,
+          model,
+          beforeHooks: [],
+          mutations: [],
+          afterHooks: [],
+        };
+        await restoreSomeObjectCascade(entity, ctx, restoreContext);
+        for (const callback of [...restoreContext.beforeHooks, ...restoreContext.mutations, ...restoreContext.afterHooks]) {
+          await callback();
+        }
+
+        return entity.id;
+      });
+    },
+
+    deleteReview: async (
+      _parent: unknown,
+      { where, dryRun }: api.MutationDeleteReviewArgs,
+      partialCtx: Context,
+      info: GraphQLResolveInfo
+    ) => {
+      return await partialCtx.knex.transaction(async (knex) => {
+        const ctx: FullContext = { ...partialCtx, knex, info, aliases: new AliasGenerator() };
+        const model = ctx.models.getModel('Review', 'entity');
+        if (Object.keys(where).length === 0) {
+          throw new Error(`No Review specified.`);
+        }
+
+        const rootModel = model.rootModel;
+        const entity = await getEntityToMutate(ctx, rootModel, where, 'DELETE');
+        if (entity.deleted) {
+          throw new ForbiddenError('Entity is already deleted.');
+        }
+
+        const deleteContext: DeleteContext = {
+          model,
+          dryRun: !!dryRun,
+          toDelete: {},
+          toUnlink: {},
+          beforeHooks: [],
+          mutations: [],
+          afterHooks: [],
+        };
+        await deleteReactionCascade(entity, ctx, deleteContext);
+        for (const callback of [...deleteContext.beforeHooks, ...deleteContext.mutations, ...deleteContext.afterHooks]) {
+          await callback();
+        }
+
+        if (dryRun) {
+          throw new GraphQLError(`Delete dry run:`, {
+            code: 'DELETE_DRY_RUN',
+            toDelete: deleteContext.toDelete,
+            toUnlink: deleteContext.toUnlink,
+          });
+        }
+
+        return entity.id;
+      });
+    },
+
+    restoreReview: async (
+      _parent: unknown,
+      { where }: api.MutationRestoreReviewArgs,
+      partialCtx: Context,
+      info: GraphQLResolveInfo
+    ) => {
+      return await partialCtx.knex.transaction(async (knex) => {
+        const ctx: FullContext = { ...partialCtx, knex, info, aliases: new AliasGenerator() };
+        const model = ctx.models.getModel('Review', 'entity');
+        if (Object.keys(where).length === 0) {
+          throw new Error(`No Review specified.`);
+        }
+
+        const rootModel = model.rootModel;
+        const entity = await getEntityToMutate(ctx, rootModel, where, 'RESTORE');
+        if (!entity.deleted) {
+          throw new ForbiddenError('Entity is not deleted.');
+        }
+
+        const restoreContext: RestoreContext = {
+          entity,
+          model,
+          beforeHooks: [],
+          mutations: [],
+          afterHooks: [],
+        };
+        await restoreReactionCascade(entity, ctx, restoreContext);
+        for (const callback of [...restoreContext.beforeHooks, ...restoreContext.mutations, ...restoreContext.afterHooks]) {
+          await callback();
+        }
+
+        return entity.id;
+      });
+    },
+
+    deleteQuestion: async (
+      _parent: unknown,
+      { where, dryRun }: api.MutationDeleteQuestionArgs,
+      partialCtx: Context,
+      info: GraphQLResolveInfo
+    ) => {
+      return await partialCtx.knex.transaction(async (knex) => {
+        const ctx: FullContext = { ...partialCtx, knex, info, aliases: new AliasGenerator() };
+        const model = ctx.models.getModel('Question', 'entity');
+        if (Object.keys(where).length === 0) {
+          throw new Error(`No Question specified.`);
+        }
+
+        const rootModel = model.rootModel;
+        const entity = await getEntityToMutate(ctx, rootModel, where, 'DELETE');
+        if (entity.deleted) {
+          throw new ForbiddenError('Entity is already deleted.');
+        }
+
+        const deleteContext: DeleteContext = {
+          model,
+          dryRun: !!dryRun,
+          toDelete: {},
+          toUnlink: {},
+          beforeHooks: [],
+          mutations: [],
+          afterHooks: [],
+        };
+        await deleteReactionCascade(entity, ctx, deleteContext);
+        for (const callback of [...deleteContext.beforeHooks, ...deleteContext.mutations, ...deleteContext.afterHooks]) {
+          await callback();
+        }
+
+        if (dryRun) {
+          throw new GraphQLError(`Delete dry run:`, {
+            code: 'DELETE_DRY_RUN',
+            toDelete: deleteContext.toDelete,
+            toUnlink: deleteContext.toUnlink,
+          });
+        }
+
+        return entity.id;
+      });
+    },
+
+    restoreQuestion: async (
+      _parent: unknown,
+      { where }: api.MutationRestoreQuestionArgs,
+      partialCtx: Context,
+      info: GraphQLResolveInfo
+    ) => {
+      return await partialCtx.knex.transaction(async (knex) => {
+        const ctx: FullContext = { ...partialCtx, knex, info, aliases: new AliasGenerator() };
+        const model = ctx.models.getModel('Question', 'entity');
+        if (Object.keys(where).length === 0) {
+          throw new Error(`No Question specified.`);
+        }
+
+        const rootModel = model.rootModel;
+        const entity = await getEntityToMutate(ctx, rootModel, where, 'RESTORE');
+        if (!entity.deleted) {
+          throw new ForbiddenError('Entity is not deleted.');
+        }
+
+        const restoreContext: RestoreContext = {
+          entity,
+          model,
+          beforeHooks: [],
+          mutations: [],
+          afterHooks: [],
+        };
+        await restoreReactionCascade(entity, ctx, restoreContext);
+        for (const callback of [...restoreContext.beforeHooks, ...restoreContext.mutations, ...restoreContext.afterHooks]) {
+          await callback();
+        }
+
+        return entity.id;
+      });
+    },
+
+    deleteAnswer: async (
+      _parent: unknown,
+      { where, dryRun }: api.MutationDeleteAnswerArgs,
+      partialCtx: Context,
+      info: GraphQLResolveInfo
+    ) => {
+      return await partialCtx.knex.transaction(async (knex) => {
+        const ctx: FullContext = { ...partialCtx, knex, info, aliases: new AliasGenerator() };
+        const model = ctx.models.getModel('Answer', 'entity');
+        if (Object.keys(where).length === 0) {
+          throw new Error(`No Answer specified.`);
+        }
+
+        const rootModel = model.rootModel;
+        const entity = await getEntityToMutate(ctx, rootModel, where, 'DELETE');
+        if (entity.deleted) {
+          throw new ForbiddenError('Entity is already deleted.');
+        }
+
+        const deleteContext: DeleteContext = {
+          model,
+          dryRun: !!dryRun,
+          toDelete: {},
+          toUnlink: {},
+          beforeHooks: [],
+          mutations: [],
+          afterHooks: [],
+        };
+        await deleteReactionCascade(entity, ctx, deleteContext);
+        for (const callback of [...deleteContext.beforeHooks, ...deleteContext.mutations, ...deleteContext.afterHooks]) {
+          await callback();
+        }
+
+        if (dryRun) {
+          throw new GraphQLError(`Delete dry run:`, {
+            code: 'DELETE_DRY_RUN',
+            toDelete: deleteContext.toDelete,
+            toUnlink: deleteContext.toUnlink,
+          });
+        }
+
+        return entity.id;
+      });
+    },
+
+    restoreAnswer: async (
+      _parent: unknown,
+      { where }: api.MutationRestoreAnswerArgs,
+      partialCtx: Context,
+      info: GraphQLResolveInfo
+    ) => {
+      return await partialCtx.knex.transaction(async (knex) => {
+        const ctx: FullContext = { ...partialCtx, knex, info, aliases: new AliasGenerator() };
+        const model = ctx.models.getModel('Answer', 'entity');
+        if (Object.keys(where).length === 0) {
+          throw new Error(`No Answer specified.`);
+        }
+
+        const rootModel = model.rootModel;
+        const entity = await getEntityToMutate(ctx, rootModel, where, 'RESTORE');
+        if (!entity.deleted) {
+          throw new ForbiddenError('Entity is not deleted.');
+        }
+
+        const restoreContext: RestoreContext = {
+          entity,
+          model,
+          beforeHooks: [],
+          mutations: [],
+          afterHooks: [],
+        };
+        await restoreReactionCascade(entity, ctx, restoreContext);
+        for (const callback of [...restoreContext.beforeHooks, ...restoreContext.mutations, ...restoreContext.afterHooks]) {
+          await callback();
+        }
+
+        return entity.id;
+      });
+    },
+  },
+  Reaction: {
+    __resolveType: ({ TYPE }) => TYPE,
+  },
+};
+
+const deleteAnotherObjectCascade = async (entity: db.FullAnotherObject, ctx: FullContext, deleteCtx: DeleteContext) => {
+  const currentModel = ctx.models.getModel('AnotherObject', 'entity');
+  if (entity.deleted) {
+    return;
+  }
+  if (!('AnotherObject' in deleteCtx.toDelete)) {
+    deleteCtx.toDelete['AnotherObject'] = {};
+  }
+  if ((entity.id as string) in deleteCtx.toDelete['AnotherObject']) {
+    return;
+  }
+
+  deleteCtx.toDelete['AnotherObject'][entity.id as string] = (entity.name || entity.id) as unknown as string;
+
+  if (!deleteCtx.dryRun) {
+    const normalizedInput = { deleted: true, deletedAt: ctx.now, deletedById: ctx.user?.id };
+    const data = { prev: entity, input: {}, normalizedInput, next: { ...entity, ...normalizedInput } };
+    if (ctx.mutationHook) {
+      deleteCtx.beforeHooks.push(async () => {
+        await ctx.mutationHook?.(currentModel, 'delete', 'before', data, ctx);
+      });
+    }
+    deleteCtx.mutations.push(async () => {
+      await ctx.knex('AnotherObject').where({ id: entity.id }).update(normalizedInput);
+      await createAnotherObjectRevision({ ...entity, deleted: true }, ctx);
+    });
+    if (ctx.mutationHook) {
+      deleteCtx.afterHooks.push(async () => {
+        await ctx.mutationHook?.(currentModel, 'delete', 'after', data, ctx);
+      });
+    }
+  }
+
+  {
+    const query = ctx.knex('AnotherObject').where({ ['myselfId']: entity.id });
+
+    applyPermissions(ctx, 'AnotherObject', 'AnotherObject', query, 'DELETE');
+    const descendants = await query;
+
+    for (const descendant of descendants) {
+      await deleteAnotherObjectCascade(descendant, ctx, deleteCtx);
+    }
+  }
+  {
+    const query = ctx.knex('SomeObject').where({ ['anotherId']: entity.id });
+
+    applyPermissions(ctx, 'SomeObject', 'SomeObject', query, 'DELETE');
+    const descendants = await query;
+
+    for (const descendant of descendants) {
+      await deleteSomeObjectCascade(descendant, ctx, deleteCtx);
+    }
+  }
+};
+
+export const restoreAnotherObjectCascade = async (
+  relatedEntity: db.AnotherObject,
+  ctx: FullContext,
+  restoreCtx: RestoreContext
+) => {
+  const currentModel = ctx.models.getModel('AnotherObject', 'entity');
+  if (
+    !relatedEntity.deleted ||
+    !relatedEntity.deletedAt ||
+    !anyDateToLuxon(relatedEntity.deletedAt, ctx.timeZone)!.equals(
+      anyDateToLuxon(restoreCtx.entity.deletedAt, ctx.timeZone)!
+    )
+  ) {
+    return;
+  }
+
+  const normalizedInput: Partial<db.AnotherObjectMutator> = { deleted: false, deletedAt: null, deletedById: null };
+  const data = { prev: relatedEntity, input: {}, normalizedInput, next: { ...relatedEntity, ...normalizedInput } };
+  if (ctx.mutationHook) {
+    restoreCtx.beforeHooks.push(async () => {
+      await ctx.mutationHook?.(currentModel, 'restore', 'before', data, ctx);
+    });
+  }
+  restoreCtx.mutations.push(async () => {
+    await ctx.knex(currentModel.name).where({ id: relatedEntity.id }).update(normalizedInput);
+    await createAnotherObjectRevision({ ...relatedEntity, deleted: false }, ctx);
+  });
+  if (ctx.mutationHook) {
+    restoreCtx.afterHooks.push(async () => {
+      await ctx.mutationHook?.(currentModel, 'restore', 'after', data, ctx);
+    });
+  }
+
+  {
+    const query = ctx.knex('AnotherObject').where({ ['myselfId']: relatedEntity.id });
+    applyPermissions(ctx, 'AnotherObject', 'AnotherObject', query, 'RESTORE');
+    const descendants = await query;
+    for (const descendant of descendants) {
+      await restoreAnotherObjectCascade(descendant, ctx, restoreCtx);
+    }
+  }
+
+  {
+    const query = ctx.knex('SomeObject').where({ ['anotherId']: relatedEntity.id });
+    applyPermissions(ctx, 'SomeObject', 'SomeObject', query, 'RESTORE');
+    const descendants = await query;
+    for (const descendant of descendants) {
+      await restoreSomeObjectCascade(descendant, ctx, restoreCtx);
+    }
+  }
+};
+
+const deleteSomeObjectCascade = async (entity: db.FullSomeObject, ctx: FullContext, deleteCtx: DeleteContext) => {
+  const currentModel = ctx.models.getModel('SomeObject', 'entity');
+  if (entity.deleted) {
+    return;
+  }
+  if (!('SomeObject' in deleteCtx.toDelete)) {
+    deleteCtx.toDelete['SomeObject'] = {};
+  }
+  if ((entity.id as string) in deleteCtx.toDelete['SomeObject']) {
+    return;
+  }
+
+  deleteCtx.toDelete['SomeObject'][entity.id as string] = entity.id as unknown as string;
+
+  if (!deleteCtx.dryRun) {
+    const normalizedInput = { deleted: true, deletedAt: ctx.now, deletedById: ctx.user?.id };
+    const data = { prev: entity, input: {}, normalizedInput, next: { ...entity, ...normalizedInput } };
+    if (ctx.mutationHook) {
+      deleteCtx.beforeHooks.push(async () => {
+        await ctx.mutationHook?.(currentModel, 'delete', 'before', data, ctx);
+      });
+    }
+    deleteCtx.mutations.push(async () => {
+      await ctx.knex('SomeObject').where({ id: entity.id }).update(normalizedInput);
+      await createSomeObjectRevision({ ...entity, deleted: true }, ctx);
+    });
+    if (ctx.mutationHook) {
+      deleteCtx.afterHooks.push(async () => {
+        await ctx.mutationHook?.(currentModel, 'delete', 'after', data, ctx);
+      });
+    }
+  }
+};
+
+export const restoreSomeObjectCascade = async (
+  relatedEntity: db.SomeObject,
+  ctx: FullContext,
+  restoreCtx: RestoreContext
+) => {
+  const currentModel = ctx.models.getModel('SomeObject', 'entity');
+  if (
+    !relatedEntity.deleted ||
+    !relatedEntity.deletedAt ||
+    !anyDateToLuxon(relatedEntity.deletedAt, ctx.timeZone)!.equals(
+      anyDateToLuxon(restoreCtx.entity.deletedAt, ctx.timeZone)!
+    )
+  ) {
+    return;
+  }
+
+  const normalizedInput: Partial<db.SomeObjectMutator> = { deleted: false, deletedAt: null, deletedById: null };
+  const data = { prev: relatedEntity, input: {}, normalizedInput, next: { ...relatedEntity, ...normalizedInput } };
+  if (ctx.mutationHook) {
+    restoreCtx.beforeHooks.push(async () => {
+      await ctx.mutationHook?.(currentModel, 'restore', 'before', data, ctx);
+    });
+  }
+  restoreCtx.mutations.push(async () => {
+    await ctx.knex(currentModel.name).where({ id: relatedEntity.id }).update(normalizedInput);
+    await createSomeObjectRevision({ ...relatedEntity, deleted: false }, ctx);
+  });
+  if (ctx.mutationHook) {
+    restoreCtx.afterHooks.push(async () => {
+      await ctx.mutationHook?.(currentModel, 'restore', 'after', data, ctx);
+    });
+  }
+};
+
+const deleteReactionCascade = async (entity: db.FullReaction, ctx: FullContext, deleteCtx: DeleteContext) => {
+  const currentModel = ctx.models.getModel('Reaction', 'entity');
+  if (entity.deleted) {
+    return;
+  }
+  if (!('Reaction' in deleteCtx.toDelete)) {
+    deleteCtx.toDelete['Reaction'] = {};
+  }
+  if ((entity.id as string) in deleteCtx.toDelete['Reaction']) {
+    return;
+  }
+
+  deleteCtx.toDelete['Reaction'][entity.id as string] = entity.id as unknown as string;
+
+  if (!deleteCtx.dryRun) {
+    const normalizedInput = { deleted: true, deletedAt: ctx.now, deletedById: ctx.user?.id };
+    const data = { prev: entity, input: {}, normalizedInput, next: { ...entity, ...normalizedInput } };
+    if (ctx.mutationHook) {
+      deleteCtx.beforeHooks.push(async () => {
+        await ctx.mutationHook?.(currentModel, 'delete', 'before', data, ctx);
+      });
+    }
+    deleteCtx.mutations.push(async () => {
+      await ctx.knex('Reaction').where({ id: entity.id }).update(normalizedInput);
+      await createReactionRevision({ ...entity, deleted: true }, ctx);
+    });
+    if (ctx.mutationHook) {
+      deleteCtx.afterHooks.push(async () => {
+        await ctx.mutationHook?.(currentModel, 'delete', 'after', data, ctx);
+      });
+    }
+  }
+
+  {
+    const query = ctx.knex('Reaction').where({ ['parentId']: entity.id });
+
+    applyPermissions(ctx, 'Reaction', 'Reaction', query, 'DELETE');
+    const descendants = await query;
+
+    for (const descendant of descendants) {
+      await deleteReactionCascade(descendant, ctx, deleteCtx);
+    }
+  }
+};
+
+export const restoreReactionCascade = async (relatedEntity: db.Reaction, ctx: FullContext, restoreCtx: RestoreContext) => {
+  const currentModel = ctx.models.getModel('Reaction', 'entity');
+  if (
+    !relatedEntity.deleted ||
+    !relatedEntity.deletedAt ||
+    !anyDateToLuxon(relatedEntity.deletedAt, ctx.timeZone)!.equals(
+      anyDateToLuxon(restoreCtx.entity.deletedAt, ctx.timeZone)!
+    )
+  ) {
+    return;
+  }
+
+  const normalizedInput: Partial<db.ReactionMutator> = { deleted: false, deletedAt: null, deletedById: null };
+  const data = { prev: relatedEntity, input: {}, normalizedInput, next: { ...relatedEntity, ...normalizedInput } };
+  if (ctx.mutationHook) {
+    restoreCtx.beforeHooks.push(async () => {
+      await ctx.mutationHook?.(currentModel, 'restore', 'before', data, ctx);
+    });
+  }
+  restoreCtx.mutations.push(async () => {
+    await ctx.knex(currentModel.name).where({ id: relatedEntity.id }).update(normalizedInput);
+    await createReactionRevision({ ...relatedEntity, deleted: false }, ctx);
+  });
+  if (ctx.mutationHook) {
+    restoreCtx.afterHooks.push(async () => {
+      await ctx.mutationHook?.(currentModel, 'restore', 'after', data, ctx);
+    });
+  }
+
+  {
+    const query = ctx.knex('Reaction').where({ ['parentId']: relatedEntity.id });
+    applyPermissions(ctx, 'Reaction', 'Reaction', query, 'RESTORE');
+    const descendants = await query;
+    for (const descendant of descendants) {
+      await restoreReactionCascade(descendant, ctx, restoreCtx);
+    }
+  }
+};
+
+export const createAnotherObjectRevision = async (
+  data: db.FullAnotherObject,
+  ctx: Pick<Context, 'knex' | 'now' | 'user'>
+) => {
+  // TODO: revisions for models that are deletable but not updatable...
+};
+
+export const createSomeObjectRevision = async (data: db.FullSomeObject, ctx: Pick<Context, 'knex' | 'now' | 'user'>) => {
+  const revisionId = uuid();
+  const rootRevisionData: Entity = {
+    id: revisionId,
+    ['someObjectId']: data.id,
+    createdAt: ctx.now,
+    createdById: ctx.user?.id,
+  };
+
+  rootRevisionData.deleted = data.deleted || false;
+  {
+    let value;
+    if (!('anotherId' in data)) {
+      throw new Error();
+    } else {
+      value = data['anotherId'];
+    }
+
+    rootRevisionData['anotherId'] = value;
+  }
+  {
+    let value;
+    if (!('xyz' in data)) {
+      throw new Error();
+    } else {
+      value = data['xyz'];
+    }
+
+    rootRevisionData['xyz'] = value;
+  }
+  await ctx.knex('SomeObjectRevision').insert(rootRevisionData);
+};
+
+export const createReactionRevision = async (data: db.FullReaction, ctx: Pick<Context, 'knex' | 'now' | 'user'>) => {
+  const revisionId = uuid();
+  const rootRevisionData: Entity = {
+    id: revisionId,
+    ['reactionId']: data.id,
+    createdAt: ctx.now,
+    createdById: ctx.user?.id,
+  };
+
+  rootRevisionData.deleted = data.deleted || false;
+  {
+    const value = data['content'];
+    rootRevisionData['content'] = value;
+  }
+  await ctx.knex('ReactionRevision').insert(rootRevisionData);
+};
+
+export const createReviewRevision = async (data: db.FullReview, ctx: Pick<Context, 'knex' | 'now' | 'user'>) => {
+  const revisionId = uuid();
+  const rootRevisionData: Entity = {
+    id: revisionId,
+    ['reactionId']: data.id,
+    createdAt: ctx.now,
+    createdById: ctx.user?.id,
+  };
+
+  rootRevisionData.deleted = data.deleted || false;
+
+  const childRevisionData = { id: revisionId };
+
+  {
+    const value = data['content'];
+    rootRevisionData['content'] = value;
+  }
+  {
+    const value = data['rating'];
+    childRevisionData['rating'] = value;
+  }
+
+  await ctx.knex('ReactionRevision').insert(rootRevisionData);
+  await ctx.knex('ReviewRevision').insert(childRevisionData);
+};
+
+export const createQuestionRevision = async (data: db.FullQuestion, ctx: Pick<Context, 'knex' | 'now' | 'user'>) => {
+  const revisionId = uuid();
+  const rootRevisionData: Entity = {
+    id: revisionId,
+    ['reactionId']: data.id,
+    createdAt: ctx.now,
+    createdById: ctx.user?.id,
+  };
+
+  rootRevisionData.deleted = data.deleted || false;
+
+  const childRevisionData = { id: revisionId };
+
+  {
+    const value = data['content'];
+    rootRevisionData['content'] = value;
+  }
+
+  await ctx.knex('ReactionRevision').insert(rootRevisionData);
+  await ctx.knex('QuestionRevision').insert(childRevisionData);
+};
+
+export const createAnswerRevision = async (data: db.FullAnswer, ctx: Pick<Context, 'knex' | 'now' | 'user'>) => {
+  const revisionId = uuid();
+  const rootRevisionData: Entity = {
+    id: revisionId,
+    ['reactionId']: data.id,
+    createdAt: ctx.now,
+    createdById: ctx.user?.id,
+  };
+
+  rootRevisionData.deleted = data.deleted || false;
+
+  const childRevisionData = { id: revisionId };
+
+  {
+    const value = data['content'];
+    rootRevisionData['content'] = value;
+  }
+
+  await ctx.knex('ReactionRevision').insert(rootRevisionData);
+  await ctx.knex('AnswerRevision').insert(childRevisionData);
+};
diff --git a/tests/generated/schema/index.ts b/tests/generated/schema/index.ts
new file mode 100644
index 0000000..a4890a6
--- /dev/null
+++ b/tests/generated/schema/index.ts
@@ -0,0 +1,389 @@
+import { gql } from 'graphql-request';
+
+export const typeDefs = gql`
+  type AnotherObject {
+    id: ID!
+    name: String
+    myself: AnotherObject
+    deleted: Boolean!
+    deletedAt: DateTime
+    deletedBy: User
+    self(where: AnotherObjectWhere, orderBy: [AnotherObjectOrderBy!], limit: Int, offset: Int): AnotherObject
+    manyObjects(
+      where: SomeObjectWhere
+      search: String
+      orderBy: [SomeObjectOrderBy!]
+      limit: Int
+      offset: Int
+    ): [SomeObject!]!
+  }
+
+  input AnotherObjectOrderBy {
+    name: Order
+    deletedAt: Order
+  }
+
+  input AnotherObjectWhere {
+    id: [ID!]
+    deleted: [Boolean!]
+    manyObjects_SOME: SomeObjectWhere
+    manyObjects_NONE: SomeObjectWhere
+    NOT: AnotherObjectWhere
+    AND: [AnotherObjectWhere!]
+    OR: [AnotherObjectWhere!]
+  }
+
+  input AnotherObjectWhereUnique {
+    id: ID
+  }
+
+  type Answer implements Reaction {
+    id: ID!
+    type: ReactionType!
+    parent: Reaction
+    content: String
+    createdAt: DateTime!
+    createdBy: User!
+    updatedAt: DateTime!
+    updatedBy: User!
+    deleted: Boolean!
+    deletedAt: DateTime
+    deletedBy: User
+    childReactions(where: ReactionWhere, orderBy: [ReactionOrderBy!], limit: Int, offset: Int): [Reaction!]!
+    childReviews(where: ReviewWhere, orderBy: [ReviewOrderBy!], limit: Int, offset: Int): [Review!]!
+    childQuestions(where: QuestionWhere, orderBy: [QuestionOrderBy!], limit: Int, offset: Int): [Question!]!
+    childAnswers(where: AnswerWhere, orderBy: [AnswerOrderBy!], limit: Int, offset: Int): [Answer!]!
+  }
+
+  input AnswerOrderBy {
+    createdAt: Order
+    updatedAt: Order
+    deletedAt: Order
+  }
+
+  input AnswerWhere {
+    id: [ID!]
+    deleted: [Boolean!]
+    NOT: AnswerWhere
+    AND: [AnswerWhere!]
+    OR: [AnswerWhere!]
+  }
+
+  input AnswerWhereUnique {
+    id: ID
+  }
+
+  input CreateAnswer {
+    content: String
+  }
+
+  input CreateQuestion {
+    content: String
+  }
+
+  input CreateReview {
+    content: String
+    rating: Float
+  }
+
+  input CreateSomeObject {
+    xyz: Int!
+  }
+
+  scalar DateTime
+
+  type Mutation {
+    deleteAnotherObject(where: AnotherObjectWhereUnique!, dryRun: Boolean): ID!
+    restoreAnotherObject(where: AnotherObjectWhereUnique!): ID!
+    createSomeObject(data: CreateSomeObject!): SomeObject!
+    updateSomeObject(where: SomeObjectWhereUnique!, data: UpdateSomeObject!): SomeObject!
+    deleteSomeObject(where: SomeObjectWhereUnique!, dryRun: Boolean): ID!
+    restoreSomeObject(where: SomeObjectWhereUnique!): ID!
+    createReview(data: CreateReview!): Review!
+    updateReview(where: ReviewWhereUnique!, data: UpdateReview!): Review!
+    deleteReview(where: ReviewWhereUnique!, dryRun: Boolean): ID!
+    restoreReview(where: ReviewWhereUnique!): ID!
+    createQuestion(data: CreateQuestion!): Question!
+    updateQuestion(where: QuestionWhereUnique!, data: UpdateQuestion!): Question!
+    deleteQuestion(where: QuestionWhereUnique!, dryRun: Boolean): ID!
+    restoreQuestion(where: QuestionWhereUnique!): ID!
+    createAnswer(data: CreateAnswer!): Answer!
+    updateAnswer(where: AnswerWhereUnique!, data: UpdateAnswer!): Answer!
+    deleteAnswer(where: AnswerWhereUnique!, dryRun: Boolean): ID!
+    restoreAnswer(where: AnswerWhereUnique!): ID!
+  }
+
+  enum Order {
+    ASC
+    DESC
+  }
+
+  type Query {
+    me: User
+    someObject(where: SomeObjectWhereUnique!): SomeObject!
+    reaction(where: ReactionWhereUnique!): Reaction!
+    review(where: ReviewWhereUnique!): Review!
+    question(where: QuestionWhereUnique!): Question!
+    answer(where: AnswerWhereUnique!): Answer!
+    anotherObjects(where: AnotherObjectWhere, orderBy: [AnotherObjectOrderBy!], limit: Int, offset: Int): [AnotherObject!]!
+    manyObjects(
+      where: SomeObjectWhere
+      search: String
+      orderBy: [SomeObjectOrderBy!]
+      limit: Int
+      offset: Int
+    ): [SomeObject!]!
+    reactions(where: ReactionWhere, orderBy: [ReactionOrderBy!], limit: Int, offset: Int): [Reaction!]!
+    reviews(where: ReviewWhere, orderBy: [ReviewOrderBy!], limit: Int, offset: Int): [Review!]!
+    questions(where: QuestionWhere, orderBy: [QuestionOrderBy!], limit: Int, offset: Int): [Question!]!
+    answers(where: AnswerWhere, orderBy: [AnswerOrderBy!], limit: Int, offset: Int): [Answer!]!
+  }
+
+  type Question implements Reaction {
+    id: ID!
+    type: ReactionType!
+    parent: Reaction
+    content: String
+    createdAt: DateTime!
+    createdBy: User!
+    updatedAt: DateTime!
+    updatedBy: User!
+    deleted: Boolean!
+    deletedAt: DateTime
+    deletedBy: User
+    childReactions(where: ReactionWhere, orderBy: [ReactionOrderBy!], limit: Int, offset: Int): [Reaction!]!
+    childReviews(where: ReviewWhere, orderBy: [ReviewOrderBy!], limit: Int, offset: Int): [Review!]!
+    childQuestions(where: QuestionWhere, orderBy: [QuestionOrderBy!], limit: Int, offset: Int): [Question!]!
+    childAnswers(where: AnswerWhere, orderBy: [AnswerOrderBy!], limit: Int, offset: Int): [Answer!]!
+  }
+
+  input QuestionOrderBy {
+    createdAt: Order
+    updatedAt: Order
+    deletedAt: Order
+  }
+
+  input QuestionWhere {
+    id: [ID!]
+    deleted: [Boolean!]
+    NOT: QuestionWhere
+    AND: [QuestionWhere!]
+    OR: [QuestionWhere!]
+  }
+
+  input QuestionWhereUnique {
+    id: ID
+  }
+
+  interface Reaction {
+    id: ID!
+    type: ReactionType!
+    parent: Reaction
+    content: String
+    createdAt: DateTime!
+    createdBy: User!
+    updatedAt: DateTime!
+    updatedBy: User!
+    deleted: Boolean!
+    deletedAt: DateTime
+    deletedBy: User
+    childReactions(where: ReactionWhere, orderBy: [ReactionOrderBy!], limit: Int, offset: Int): [Reaction!]!
+    childReviews(where: ReviewWhere, orderBy: [ReviewOrderBy!], limit: Int, offset: Int): [Review!]!
+    childQuestions(where: QuestionWhere, orderBy: [QuestionOrderBy!], limit: Int, offset: Int): [Question!]!
+    childAnswers(where: AnswerWhere, orderBy: [AnswerOrderBy!], limit: Int, offset: Int): [Answer!]!
+  }
+
+  input ReactionOrderBy {
+    createdAt: Order
+    updatedAt: Order
+    deletedAt: Order
+  }
+
+  enum ReactionType {
+    Review
+    Question
+    Answer
+  }
+
+  input ReactionWhere {
+    id: [ID!]
+    deleted: [Boolean!]
+    NOT: ReactionWhere
+    AND: [ReactionWhere!]
+    OR: [ReactionWhere!]
+  }
+
+  input ReactionWhereUnique {
+    id: ID
+  }
+
+  type Review implements Reaction {
+    id: ID!
+    type: ReactionType!
+    parent: Reaction
+    content: String
+    createdAt: DateTime!
+    createdBy: User!
+    updatedAt: DateTime!
+    updatedBy: User!
+    deleted: Boolean!
+    deletedAt: DateTime
+    deletedBy: User
+    rating: Float
+    childReactions(where: ReactionWhere, orderBy: [ReactionOrderBy!], limit: Int, offset: Int): [Reaction!]!
+    childReviews(where: ReviewWhere, orderBy: [ReviewOrderBy!], limit: Int, offset: Int): [Review!]!
+    childQuestions(where: QuestionWhere, orderBy: [QuestionOrderBy!], limit: Int, offset: Int): [Question!]!
+    childAnswers(where: AnswerWhere, orderBy: [AnswerOrderBy!], limit: Int, offset: Int): [Answer!]!
+  }
+
+  input ReviewOrderBy {
+    createdAt: Order
+    updatedAt: Order
+    deletedAt: Order
+  }
+
+  input ReviewWhere {
+    id: [ID!]
+    deleted: [Boolean!]
+    rating_GT: Float
+    rating_GTE: Float
+    rating_LT: Float
+    rating_LTE: Float
+    NOT: ReviewWhere
+    AND: [ReviewWhere!]
+    OR: [ReviewWhere!]
+  }
+
+  input ReviewWhereUnique {
+    id: ID
+  }
+
+  enum Role {
+    ADMIN
+    USER
+  }
+
+  enum SomeEnum {
+    A
+    B
+    C
+  }
+
+  type SomeObject {
+    id: ID!
+    field: String
+    another: AnotherObject!
+    float: Float!
+    list(magic: Boolean): [SomeEnum!]!
+    xyz: Int!
+    createdAt: DateTime!
+    createdBy: User!
+    updatedAt: DateTime!
+    updatedBy: User!
+    deleted: Boolean!
+    deletedAt: DateTime
+    deletedBy: User
+  }
+
+  input SomeObjectOrderBy {
+    xyz: Order
+    createdAt: Order
+    updatedAt: Order
+    deletedAt: Order
+  }
+
+  input SomeObjectWhere {
+    id: [ID!]
+    float: [Float!]
+    xyz: [Int!]
+    deleted: [Boolean!]
+    another: AnotherObjectWhere
+    NOT: SomeObjectWhere
+    AND: [SomeObjectWhere!]
+    OR: [SomeObjectWhere!]
+  }
+
+  input SomeObjectWhereUnique {
+    id: ID
+  }
+
+  type SomeRawObject {
+    field: String
+  }
+
+  input UpdateAnswer {
+    content: String
+  }
+
+  input UpdateQuestion {
+    content: String
+  }
+
+  input UpdateReview {
+    content: String
+    rating: Float
+  }
+
+  input UpdateSomeObject {
+    anotherId: ID
+    xyz: Int
+  }
+
+  scalar Upload
+
+  type User {
+    id: ID!
+    username: String
+    role: Role
+    deletedAnotherObjects(
+      where: AnotherObjectWhere
+      orderBy: [AnotherObjectOrderBy!]
+      limit: Int
+      offset: Int
+    ): [AnotherObject!]!
+    createdManyObjects(
+      where: SomeObjectWhere
+      search: String
+      orderBy: [SomeObjectOrderBy!]
+      limit: Int
+      offset: Int
+    ): [SomeObject!]!
+    updatedManyObjects(
+      where: SomeObjectWhere
+      search: String
+      orderBy: [SomeObjectOrderBy!]
+      limit: Int
+      offset: Int
+    ): [SomeObject!]!
+    deletedManyObjects(
+      where: SomeObjectWhere
+      search: String
+      orderBy: [SomeObjectOrderBy!]
+      limit: Int
+      offset: Int
+    ): [SomeObject!]!
+    createdReactions(where: ReactionWhere, orderBy: [ReactionOrderBy!], limit: Int, offset: Int): [Reaction!]!
+    updatedReactions(where: ReactionWhere, orderBy: [ReactionOrderBy!], limit: Int, offset: Int): [Reaction!]!
+    deletedReactions(where: ReactionWhere, orderBy: [ReactionOrderBy!], limit: Int, offset: Int): [Reaction!]!
+    createdReviews(where: ReviewWhere, orderBy: [ReviewOrderBy!], limit: Int, offset: Int): [Review!]!
+    updatedReviews(where: ReviewWhere, orderBy: [ReviewOrderBy!], limit: Int, offset: Int): [Review!]!
+    deletedReviews(where: ReviewWhere, orderBy: [ReviewOrderBy!], limit: Int, offset: Int): [Review!]!
+    createdQuestions(where: QuestionWhere, orderBy: [QuestionOrderBy!], limit: Int, offset: Int): [Question!]!
+    updatedQuestions(where: QuestionWhere, orderBy: [QuestionOrderBy!], limit: Int, offset: Int): [Question!]!
+    deletedQuestions(where: QuestionWhere, orderBy: [QuestionOrderBy!], limit: Int, offset: Int): [Question!]!
+    createdAnswers(where: AnswerWhere, orderBy: [AnswerOrderBy!], limit: Int, offset: Int): [Answer!]!
+    updatedAnswers(where: AnswerWhere, orderBy: [AnswerOrderBy!], limit: Int, offset: Int): [Answer!]!
+    deletedAnswers(where: AnswerWhere, orderBy: [AnswerOrderBy!], limit: Int, offset: Int): [Answer!]!
+  }
+
+  input UserWhere {
+    id: [ID!]
+    NOT: UserWhere
+    AND: [UserWhere!]
+    OR: [UserWhere!]
+  }
+
+  input UserWhereUnique {
+    id: ID
+  }
+`;
diff --git a/tests/unit/__snapshots__/queries.spec.ts.snap b/tests/unit/__snapshots__/queries.spec.ts.snap
deleted file mode 100644
index aaf904b..0000000
--- a/tests/unit/__snapshots__/queries.spec.ts.snap
+++ /dev/null
@@ -1,10 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`queries getEntityRelationsQuery applies filters 1`] = `
-"query SelectSomeObjectRelations($anotherWhere: AnotherObjectWhere, $anotherLimit: Int) {
-      another: anotherObjects(where: $anotherWhere, limit: $anotherLimit, orderBy: [{ name: ASC }]) {
-            id
-            display: name
-          }
-    }"
-`;
diff --git a/tests/unit/__snapshots__/resolve.spec.ts.snap b/tests/unit/__snapshots__/resolve.spec.ts.snap
deleted file mode 100644
index fbce204..0000000
--- a/tests/unit/__snapshots__/resolve.spec.ts.snap
+++ /dev/null
@@ -1,43 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`resolvers are generated correctly 1`] = `
-{
-  "Mutation": {
-    "createAnswer": [Function],
-    "createQuestion": [Function],
-    "createReview": [Function],
-    "createSomeObject": [Function],
-    "deleteAnotherObject": [Function],
-    "deleteAnswer": [Function],
-    "deleteQuestion": [Function],
-    "deleteReview": [Function],
-    "deleteSomeObject": [Function],
-    "restoreAnotherObject": [Function],
-    "restoreAnswer": [Function],
-    "restoreQuestion": [Function],
-    "restoreReview": [Function],
-    "restoreSomeObject": [Function],
-    "updateAnswer": [Function],
-    "updateQuestion": [Function],
-    "updateReview": [Function],
-    "updateSomeObject": [Function],
-  },
-  "Query": {
-    "anotherObjects": [Function],
-    "answer": [Function],
-    "answers": [Function],
-    "manyObjects": [Function],
-    "me": [Function],
-    "question": [Function],
-    "questions": [Function],
-    "reaction": [Function],
-    "reactions": [Function],
-    "review": [Function],
-    "reviews": [Function],
-    "someObject": [Function],
-  },
-  "Reaction": {
-    "__resolveType": [Function],
-  },
-}
-`;
diff --git a/tests/unit/queries.spec.ts b/tests/unit/queries.spec.ts
deleted file mode 100644
index 00ce2af..0000000
--- a/tests/unit/queries.spec.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-import { getActionableRelations, getSelectEntityRelationsQuery } from '../../src';
-import { models } from '../utils/models';
-
-describe('queries', () => {
-  describe('getEntityRelationsQuery', () => {
-    it('applies filters', () => {
-      const model = models.getModel('SomeObject', 'entity');
-      expect(getSelectEntityRelationsQuery(model, getActionableRelations(model, 'update'))).toMatchSnapshot();
-    });
-  });
-});
diff --git a/tests/unit/resolve.spec.ts b/tests/unit/resolve.spec.ts
deleted file mode 100644
index 734943a..0000000
--- a/tests/unit/resolve.spec.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-import { getResolvers } from '../../src/resolvers';
-import { models } from '../utils/models';
-
-describe('resolvers', () => {
-  it('are generated correctly', () => {
-    expect(getResolvers(models)).toMatchSnapshot();
-  });
-});
diff --git a/tests/utils/server.ts b/tests/utils/server.ts
index ad72650..52919af 100644
--- a/tests/utils/server.ts
+++ b/tests/utils/server.ts
@@ -1,9 +1,12 @@
-import { TypedQueryDocumentNode } from 'graphql';
+import { makeExecutableSchema } from '@graphql-tools/schema';
+import { execute, GraphQLResolveInfo, parse, Source, TypedQueryDocumentNode } from 'graphql';
 import graphqlRequest, { RequestDocument, Variables } from 'graphql-request';
-import { RequestListener, createServer } from 'http';
+import { createServer, RequestListener } from 'http';
 import { Knex } from 'knex';
 import { up } from '../../migrations/20230912185644_setup';
-import { execute } from '../../src';
+import { Context, get } from '../../src';
+import { resolvers } from '../generated/resolvers';
+import { typeDefs } from '../generated/schema';
 import { getKnex } from './database/knex';
 import { ADMIN_ID, setupSeed } from './database/seed';
 import { models, permissions } from './models';
@@ -50,7 +53,8 @@ export const withServer = async (
             res(JSON.parse(Buffer.concat(chunks).toString()));
           });
       });
-      const result = await execute({
+
+      const contextValue: Context = {
         req,
         knex,
         locale: 'en',
@@ -59,7 +63,22 @@ export const withServer = async (
         models,
         permissions,
         now,
-        body,
+      };
+      const result = await execute({
+        schema: makeExecutableSchema({
+          typeDefs,
+          resolvers,
+        }),
+        document: parse(new Source(body.query, 'GraphQL request')),
+        contextValue,
+        variableValues: body.variables,
+        operationName: body.operationName,
+        fieldResolver: (parent, _args, _ctx, info: GraphQLResolveInfo) => {
+          const node = get(info.fieldNodes, 0);
+          const alias = node.alias;
+
+          return parent[alias ? alias.value : node.name.value];
+        },
       });
 
       res.writeHead(200, { 'Content-Type': 'application/json' });