From 00c81d5f96493d05e8f84f0e88b00b4405a018a4 Mon Sep 17 00:00:00 2001
From: Cameron Sechrist <cameron@bestreamlined.io>
Date: Sat, 14 Oct 2023 12:00:22 -0400
Subject: [PATCH 1/2] feat: add the prisma client import option

---
 README.md                         | 6 ++++++
 package.json                      | 2 ++
 src/handlers/input-type.ts        | 2 +-
 src/helpers/create-config.spec.ts | 9 +++++++++
 src/helpers/create-config.ts      | 6 ++++++
 src/test/compatibility.ts         | 2 +-
 6 files changed, 25 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index b59759c3..9f813702 100644
--- a/README.md
+++ b/README.md
@@ -70,6 +70,12 @@ Path to `tsconfig.json` (absolute path or relative to current working directory)
 Type: `string | undefined`  
 Default: `tsconfig.json` if exists, `undefined` otherwise
 
+#### `prismaClientImport`
+
+The path to use to import the Prisma Client package
+Type: `string | undefined`
+Default: `@prisma/client`
+
 #### `combineScalarFilters`
 
 Combine nested/nullable scalar filters to single  
diff --git a/package.json b/package.json
index 622c4dac..75800618 100644
--- a/package.json
+++ b/package.json
@@ -52,8 +52,10 @@
     "eslint:fix": "npm run eslint -- --fix",
     "build": "sh Taskfile build",
     "prisma:g": "node node_modules/prisma/build/index.js generate",
+    "prisma:custom:g": "node node_modules/prisma/build/index.js generate --schema=./custom-package-generator/schema.prisma",
     "format": "npx prettier ./@generated --write",
     "regen": "rm -rf @generated && npm run prisma:g && npm run format",
+    "regen:custom": "rm -rf @generated-custom && npm run prisma:custom:g && npm run format",
     "rt": "npm run regen && npm test",
     "example": "node-dev example/main.ts",
     "clean_cache": "rm -rf node_modules/.cache",
diff --git a/src/handlers/input-type.ts b/src/handlers/input-type.ts
index 9260b61e..fafab96a 100644
--- a/src/handlers/input-type.ts
+++ b/src/handlers/input-type.ts
@@ -138,7 +138,7 @@ export function inputType(
       // TODO: Deprecated and should be removed
       importDeclarations.add('Decimal', '@prisma/client/runtime/library');
     } else if (propertyType.some(p => p.startsWith('Prisma.'))) {
-      importDeclarations.add('Prisma', '@prisma/client');
+      importDeclarations.add('Prisma', config.prismaClientImport);
     }
 
     // Get graphql type
diff --git a/src/helpers/create-config.spec.ts b/src/helpers/create-config.spec.ts
index 5af0ee0d..d9225b91 100644
--- a/src/helpers/create-config.spec.ts
+++ b/src/helpers/create-config.spec.ts
@@ -14,6 +14,7 @@ describe('createConfig', () => {
     expect(result.noAtomicOperations).toEqual(false);
     expect(result.$warnings).toEqual([]);
     expect(result.reExport).toEqual(ReExport.None);
+    expect(result.prismaClientImport).toEqual('@prisma/client');
   });
 
   it('filename with parent reference should be not valid', () => {
@@ -146,4 +147,12 @@ describe('createConfig', () => {
 
     expect(result.unsafeCompatibleWhereUniqueInput).toEqual(true);
   });
+
+  it('prismaClientImport', () => {
+    const result = createConfig({
+      prismaClientImport: '@prisma/client/testing',
+    });
+
+    expect(result.prismaClientImport).toEqual('@prisma/client/testing');
+  });
 });
diff --git a/src/helpers/create-config.ts b/src/helpers/create-config.ts
index 7e77ddc2..7b8f419e 100644
--- a/src/helpers/create-config.ts
+++ b/src/helpers/create-config.ts
@@ -99,6 +99,7 @@ export function createConfig(data: Record<string, unknown>) {
   return {
     outputFilePattern,
     tsConfigFilePath: createTsConfigFilePathValue(config.tsConfigFilePath),
+    prismaClientImport: createPrismaImport(config.prismaClientImport),
     combineScalarFilters: toBoolean(config.combineScalarFilters),
     noAtomicOperations: toBoolean(config.noAtomicOperations),
     reExport: (ReExport[String(config.reExport)] || ReExport.None) as ReExport,
@@ -140,6 +141,11 @@ function createTsConfigFilePathValue(value: unknown): string | undefined {
   if (tsConfigFileExists('tsconfig.json')) return 'tsconfig.json';
 }
 
+function createPrismaImport(value: unknown): string {
+  if (typeof value === 'string') return value;
+  return '@prisma/client';
+}
+
 function createUseInputType(data?: Record<string, ConfigInputItem>) {
   if (!data) {
     return [];
diff --git a/src/test/compatibility.ts b/src/test/compatibility.ts
index 80ea3093..81b666ba 100644
--- a/src/test/compatibility.ts
+++ b/src/test/compatibility.ts
@@ -1,4 +1,5 @@
 /* eslint-disable prefer-const, unicorn/no-null */
+import { Field } from '@nestjs/graphql';
 import { Prisma, PrismaClient } from '@prisma/client';
 import * as P from '@prisma/client';
 
@@ -21,7 +22,6 @@ import { UserMaxOrderByAggregateInput } from '../../@generated/user/user-max-ord
 import { UserScalarFieldEnum } from '../../@generated/user/user-scalar-field.enum';
 import { UserWhereInput } from '../../@generated/user/user-where.input';
 import { UserWhereUniqueInput } from '../../@generated/user/user-where-unique.input';
-import { Field } from '@nestjs/graphql';
 
 let $prisma = new PrismaClient();
 

From 37ae802591f777e04b2f0a50c5256fc3390418fa Mon Sep 17 00:00:00 2001
From: Cameron Sechrist <cameron@bestreamlined.io>
Date: Thu, 2 Nov 2023 13:28:31 -0400
Subject: [PATCH 2/2] [fix]: resolve Decimal imports

---
 .../article/aggregate-article.output.ts       |  21 ++--
 @generated/article/article-aggregate.args.ts  |  45 ++++----
 .../article/article-avg-aggregate.input.ts    |   5 +-
 .../article/article-avg-aggregate.output.ts   |   5 +-
 .../article-avg-order-by-aggregate.input.ts   |   5 +-
 .../article/article-count-aggregate.input.ts  |  45 ++++----
 .../article/article-count-aggregate.output.ts |  45 ++++----
 .../article-count-order-by-aggregate.input.ts |  41 +++----
 @generated/article/article-count.output.ts    |  13 ++-
 ...create-many-author-input-envelope.input.ts |  11 +-
 .../article-create-many-author.input.ts       |  37 +++---
 .../article/article-create-many.input.ts      |  41 +++----
 ...create-nested-many-without-author.input.ts |  27 ++---
 ...-nested-many-without-favorited-by.input.ts |  21 ++--
 ...e-create-nested-many-without-tags.input.ts |  21 ++--
 ...reate-nested-one-without-comments.input.ts |  21 ++--
 ...-create-or-connect-without-author.input.ts |  15 +--
 ...reate-or-connect-without-comments.input.ts |  15 +--
 ...e-or-connect-without-favorited-by.input.ts |  15 +--
 ...le-create-or-connect-without-tags.input.ts |  15 +--
 .../article-create-without-author.input.ts    |  53 ++++-----
 .../article-create-without-comments.input.ts  |  53 ++++-----
 ...ticle-create-without-favorited-by.input.ts |  53 ++++-----
 .../article-create-without-tags.input.ts      |  55 ++++-----
 @generated/article/article-create.input.ts    |  59 +++++-----
 @generated/article/article-group-by.args.ts   |  47 ++++----
 @generated/article/article-group-by.output.ts |  61 +++++-----
 .../article-list-relation-filter.input.ts     |  13 ++-
 .../article/article-max-aggregate.input.ts    |  41 +++----
 .../article/article-max-aggregate.output.ts   |  41 +++----
 .../article-max-order-by-aggregate.input.ts   |  41 +++----
 .../article/article-min-aggregate.input.ts    |  41 +++----
 .../article/article-min-aggregate.output.ts   |  41 +++----
 .../article-min-order-by-aggregate.input.ts   |  41 +++----
 .../article-nullable-relation-filter.input.ts |   9 +-
 ...ticle-order-by-relation-aggregate.input.ts |   5 +-
 .../article-order-by-relevance-field.enum.ts  |  18 ++-
 .../article-order-by-relevance.input.ts       |  13 ++-
 ...article-order-by-with-aggregation.input.ts |  61 +++++-----
 ...ith-relation-and-search-relevance.input.ts |  67 +++++------
 .../article/article-scalar-field.enum.ts      |  26 ++---
 ...icle-scalar-where-with-aggregates.input.ts |  53 ++++-----
 .../article/article-scalar-where.input.ts     |  53 ++++-----
 .../article/article-sum-aggregate.input.ts    |   5 +-
 .../article/article-sum-aggregate.output.ts   |   5 +-
 .../article-sum-order-by-aggregate.input.ts   |   5 +-
 ...create-nested-many-without-author.input.ts |  27 ++---
 ...-nested-many-without-favorited-by.input.ts |  21 ++--
 ...d-create-nested-many-without-tags.input.ts |  21 ++--
 ...e-unchecked-create-without-author.input.ts |  55 +++++----
 ...unchecked-create-without-comments.input.ts |  53 +++++----
 ...ecked-create-without-favorited-by.input.ts |  51 +++++----
 ...cle-unchecked-create-without-tags.input.ts |  55 +++++----
 .../article/article-unchecked-create.input.ts |  59 +++++-----
 ...update-many-without-author-nested.input.ts |  69 +++++------
 ...hecked-update-many-without-author.input.ts |  37 +++---
 ...-many-without-favorited-by-nested.input.ts |  85 +++++++-------
 ...-update-many-without-favorited-by.input.ts |  41 +++----
 ...d-update-many-without-tags-nested.input.ts |  63 ++++++-----
 ...nchecked-update-many-without-tags.input.ts |  41 +++----
 .../article-unchecked-update-many.input.ts    |  41 +++----
 ...e-unchecked-update-without-author.input.ts |  55 +++++----
 ...unchecked-update-without-comments.input.ts |  53 +++++----
 ...ecked-update-without-favorited-by.input.ts |  51 +++++----
 ...cle-unchecked-update-without-tags.input.ts |  55 +++++----
 .../article/article-unchecked-update.input.ts |  59 +++++-----
 .../article-update-many-mutation.input.ts     |  37 +++---
 ...te-many-with-where-without-author.input.ts |  13 ++-
 ...y-with-where-without-favorited-by.input.ts |  13 ++-
 ...date-many-with-where-without-tags.input.ts |  13 ++-
 ...update-many-without-author-nested.input.ts |  69 +++++------
 ...-many-without-favorited-by-nested.input.ts |  85 +++++++-------
 ...e-update-many-without-tags-nested.input.ts |  63 ++++++-----
 ...pdate-one-without-comments-nested.input.ts |  45 ++++----
 ...o-one-with-where-without-comments.input.ts |  13 ++-
 ...-with-where-unique-without-author.input.ts |  15 +--
 ...where-unique-without-favorited-by.input.ts |  15 +--
 ...te-with-where-unique-without-tags.input.ts |  15 +--
 .../article-update-without-author.input.ts    |  53 ++++-----
 .../article-update-without-comments.input.ts  |  53 ++++-----
 ...ticle-update-without-favorited-by.input.ts |  53 ++++-----
 .../article-update-without-tags.input.ts      |  55 ++++-----
 @generated/article/article-update.input.ts    |  59 +++++-----
 ...-with-where-unique-without-author.input.ts |  21 ++--
 ...where-unique-without-favorited-by.input.ts |  21 ++--
 ...rt-with-where-unique-without-tags.input.ts |  21 ++--
 .../article-upsert-without-comments.input.ts  |  19 ++--
 .../article/article-where-unique.input.ts     |  75 ++++++------
 @generated/article/article-where.input.ts     |  75 ++++++------
 @generated/article/article.model.ts           |  61 +++++-----
 .../article/create-many-article.args.ts       |  11 +-
 @generated/article/create-one-article.args.ts |   7 +-
 .../article/delete-many-article.args.ts       |   7 +-
 @generated/article/delete-one-article.args.ts |   9 +-
 .../find-first-article-or-throw.args.ts       |  29 ++---
 @generated/article/find-first-article.args.ts |  29 ++---
 @generated/article/find-many-article.args.ts  |  29 ++---
 .../find-unique-article-or-throw.args.ts      |   9 +-
 .../article/find-unique-article.args.ts       |   9 +-
 .../article/update-many-article.args.ts       |  13 ++-
 @generated/article/update-one-article.args.ts |  15 +--
 @generated/article/upsert-one-article.args.ts |  21 ++--
 .../comment/aggregate-comment.output.ts       |  13 ++-
 @generated/comment/comment-aggregate.args.ts  |  37 +++---
 .../comment/comment-count-aggregate.input.ts  |  29 ++---
 .../comment/comment-count-aggregate.output.ts |  29 ++---
 .../comment-count-order-by-aggregate.input.ts |  25 ++--
 ...reate-many-article-input-envelope.input.ts |  11 +-
 .../comment-create-many-article.input.ts      |  21 ++--
 ...create-many-author-input-envelope.input.ts |  11 +-
 .../comment-create-many-author.input.ts       |  21 ++--
 .../comment/comment-create-many.input.ts      |  25 ++--
 ...reate-nested-many-without-article.input.ts |  27 ++---
 ...create-nested-many-without-author.input.ts |  27 ++---
 ...create-or-connect-without-article.input.ts |  15 +--
 ...-create-or-connect-without-author.input.ts |  15 +--
 .../comment-create-without-article.input.ts   |  23 ++--
 .../comment-create-without-author.input.ts    |  23 ++--
 @generated/comment/comment-create.input.ts    |  29 ++---
 @generated/comment/comment-group-by.args.ts   |  39 +++----
 @generated/comment/comment-group-by.output.ts |  37 +++---
 .../comment-list-relation-filter.input.ts     |  13 ++-
 .../comment/comment-max-aggregate.input.ts    |  25 ++--
 .../comment/comment-max-aggregate.output.ts   |  25 ++--
 .../comment-max-order-by-aggregate.input.ts   |  25 ++--
 .../comment/comment-min-aggregate.input.ts    |  25 ++--
 .../comment/comment-min-aggregate.output.ts   |  25 ++--
 .../comment-min-order-by-aggregate.input.ts   |  25 ++--
 ...mment-order-by-relation-aggregate.input.ts |   5 +-
 .../comment-order-by-relevance-field.enum.ts  |  14 +--
 .../comment-order-by-relevance.input.ts       |  13 ++-
 ...comment-order-by-with-aggregation.input.ts |  37 +++---
 ...ith-relation-and-search-relevance.input.ts |  41 +++----
 .../comment/comment-scalar-field.enum.ts      |  18 ++-
 ...ment-scalar-where-with-aggregates.input.ts |  37 +++---
 .../comment/comment-scalar-where.input.ts     |  37 +++---
 ...reate-nested-many-without-article.input.ts |  27 ++---
 ...create-nested-many-without-author.input.ts |  27 ++---
 ...-unchecked-create-without-article.input.ts |  21 ++--
 ...t-unchecked-create-without-author.input.ts |  21 ++--
 .../comment/comment-unchecked-create.input.ts |  25 ++--
 ...pdate-many-without-article-nested.input.ts |  69 +++++------
 ...ecked-update-many-without-article.input.ts |  21 ++--
 ...update-many-without-author-nested.input.ts |  69 +++++------
 ...hecked-update-many-without-author.input.ts |  21 ++--
 .../comment-unchecked-update-many.input.ts    |  25 ++--
 ...-unchecked-update-without-article.input.ts |  21 ++--
 ...t-unchecked-update-without-author.input.ts |  21 ++--
 .../comment/comment-unchecked-update.input.ts |  25 ++--
 .../comment-update-many-mutation.input.ts     |  17 +--
 ...e-many-with-where-without-article.input.ts |  13 ++-
 ...te-many-with-where-without-author.input.ts |  13 ++-
 ...pdate-many-without-article-nested.input.ts |  69 +++++------
 ...update-many-without-author-nested.input.ts |  69 +++++------
 ...with-where-unique-without-article.input.ts |  15 +--
 ...-with-where-unique-without-author.input.ts |  15 +--
 .../comment-update-without-article.input.ts   |  23 ++--
 .../comment-update-without-author.input.ts    |  23 ++--
 @generated/comment/comment-update.input.ts    |  29 ++---
 ...with-where-unique-without-article.input.ts |  21 ++--
 ...-with-where-unique-without-author.input.ts |  21 ++--
 .../comment/comment-where-unique.input.ts     |  49 ++++----
 @generated/comment/comment-where.input.ts     |  49 ++++----
 @generated/comment/comment.model.ts           |  33 +++---
 .../comment/create-many-comment.args.ts       |  11 +-
 @generated/comment/create-one-comment.args.ts |   7 +-
 .../comment/delete-many-comment.args.ts       |   7 +-
 @generated/comment/delete-one-comment.args.ts |   9 +-
 .../find-first-comment-or-throw.args.ts       |  29 ++---
 @generated/comment/find-first-comment.args.ts |  29 ++---
 @generated/comment/find-many-comment.args.ts  |  29 ++---
 .../find-unique-comment-or-throw.args.ts      |   9 +-
 .../comment/find-unique-comment.args.ts       |   9 +-
 .../comment/update-many-comment.args.ts       |  13 ++-
 @generated/comment/update-one-comment.args.ts |  15 +--
 @generated/comment/upsert-one-comment.args.ts |  21 ++--
 @generated/dummy/aggregate-dummy.output.ts    |  21 ++--
 @generated/dummy/create-many-dummy.args.ts    |  11 +-
 @generated/dummy/create-one-dummy.args.ts     |   7 +-
 @generated/dummy/delete-many-dummy.args.ts    |   7 +-
 @generated/dummy/delete-one-dummy.args.ts     |   9 +-
 @generated/dummy/dummy-aggregate.args.ts      |  59 +++++-----
 @generated/dummy/dummy-avg-aggregate.input.ts |  21 ++--
 .../dummy/dummy-avg-aggregate.output.ts       |  23 ++--
 .../dummy-avg-order-by-aggregate.input.ts     |  21 ++--
 .../dummy/dummy-count-aggregate.input.ts      |  45 ++++----
 .../dummy/dummy-count-aggregate.output.ts     |  45 ++++----
 .../dummy-count-order-by-aggregate.input.ts   |  41 +++----
 @generated/dummy/dummy-create-many.input.ts   |  51 +++++----
 @generated/dummy/dummy-create.input.ts        |  51 +++++----
 .../dummy/dummy-createdecimals.input.ts       |  11 +-
 @generated/dummy/dummy-createfriends.input.ts |   5 +-
 @generated/dummy/dummy-group-by.args.ts       |  61 +++++-----
 @generated/dummy/dummy-group-by.output.ts     |  63 ++++++-----
 @generated/dummy/dummy-max-aggregate.input.ts |  29 ++---
 .../dummy/dummy-max-aggregate.output.ts       |  31 ++---
 .../dummy-max-order-by-aggregate.input.ts     |  29 ++---
 @generated/dummy/dummy-min-aggregate.input.ts |  29 ++---
 .../dummy/dummy-min-aggregate.output.ts       |  31 ++---
 .../dummy-min-order-by-aggregate.input.ts     |  29 ++---
 .../dummy-order-by-relevance-field.enum.ts    |  10 +-
 .../dummy/dummy-order-by-relevance.input.ts   |  13 ++-
 .../dummy-order-by-with-aggregation.input.ts  |  71 ++++++------
 ...ith-relation-and-search-relevance.input.ts |  47 ++++----
 @generated/dummy/dummy-scalar-field.enum.ts   |  26 ++---
 ...ummy-scalar-where-with-aggregates.input.ts |  63 ++++++-----
 @generated/dummy/dummy-sum-aggregate.input.ts |  21 ++--
 .../dummy/dummy-sum-aggregate.output.ts       |  23 ++--
 .../dummy-sum-order-by-aggregate.input.ts     |  21 ++--
 .../dummy/dummy-unchecked-create.input.ts     |  51 +++++----
 .../dummy-unchecked-update-many.input.ts      |  47 ++++----
 .../dummy/dummy-unchecked-update.input.ts     |  47 ++++----
 .../dummy/dummy-update-many-mutation.input.ts |  47 ++++----
 @generated/dummy/dummy-update.input.ts        |  47 ++++----
 .../dummy/dummy-updatedecimals.input.ts       |  19 ++--
 @generated/dummy/dummy-updatefriends.input.ts |   9 +-
 @generated/dummy/dummy-where-unique.input.ts  |  63 ++++++-----
 @generated/dummy/dummy-where.input.ts         |  63 ++++++-----
 @generated/dummy/dummy.model.ts               |  43 +++----
 .../dummy/find-first-dummy-or-throw.args.ts   |  33 +++---
 @generated/dummy/find-first-dummy.args.ts     |  33 +++---
 @generated/dummy/find-many-dummy.args.ts      |  33 +++---
 .../dummy/find-unique-dummy-or-throw.args.ts  |   9 +-
 @generated/dummy/find-unique-dummy.args.ts    |   9 +-
 @generated/dummy/update-many-dummy.args.ts    |  13 ++-
 @generated/dummy/update-one-dummy.args.ts     |  15 +--
 @generated/dummy/upsert-one-dummy.args.ts     |  21 ++--
 @generated/prisma/affected-rows.output.ts     |   5 +-
 .../prisma/big-int-nullable-filter.input.ts   |  33 +++---
 ...t-nullable-with-aggregates-filter.input.ts |  53 ++++-----
 .../prisma/bool-nullable-filter.input.ts      |   9 +-
 ...l-nullable-with-aggregates-filter.input.ts |  21 ++--
 .../prisma/bytes-nullable-filter.input.ts     |  17 +--
 ...s-nullable-with-aggregates-filter.input.ts |  29 ++---
 ...date-time-field-update-operations.input.ts |   5 +-
 @generated/prisma/date-time-filter.input.ts   |  33 +++---
 .../prisma/date-time-nullable-filter.input.ts |  33 +++---
 ...e-nullable-with-aggregates-filter.input.ts |  45 ++++----
 .../date-time-with-aggregates-filter.input.ts |  45 ++++----
 .../decimal-field-update-operations.input.ts  |  43 +++----
 @generated/prisma/decimal-filter.input.ts     |  77 ++++++-------
 .../prisma/decimal-nullable-filter.input.ts   |  77 ++++++-------
 .../decimal-nullable-list-filter.input.ts     |  39 +++----
 ...l-nullable-with-aggregates-filter.input.ts |  83 +++++++-------
 .../decimal-with-aggregates-filter.input.ts   |  83 +++++++-------
 .../prisma/enum-role-nullable-filter.input.ts |  17 +--
 ...e-nullable-with-aggregates-filter.input.ts |  29 ++---
 .../prisma/float-nullable-filter.input.ts     |  33 +++---
 ...t-nullable-with-aggregates-filter.input.ts |  53 ++++-----
 .../int-field-update-operations.input.ts      |  21 ++--
 @generated/prisma/int-filter.input.ts         |  33 +++---
 .../prisma/int-nullable-filter.input.ts       |  33 +++---
 ...t-nullable-with-aggregates-filter.input.ts |  53 ++++-----
 .../int-with-aggregates-filter.input.ts       |  53 ++++-----
 .../prisma/json-null-value-filter.enum.ts     |  12 +-
 .../prisma/json-nullable-filter.input.ts      |  53 ++++-----
 ...n-nullable-with-aggregates-filter.input.ts |  65 +++++------
 .../nested-big-int-nullable-filter.input.ts   |  33 +++---
 ...t-nullable-with-aggregates-filter.input.ts |  53 ++++-----
 .../nested-bool-nullable-filter.input.ts      |   9 +-
 ...l-nullable-with-aggregates-filter.input.ts |  21 ++--
 .../nested-bytes-nullable-filter.input.ts     |  17 +--
 ...s-nullable-with-aggregates-filter.input.ts |  29 ++---
 .../prisma/nested-date-time-filter.input.ts   |  33 +++---
 .../nested-date-time-nullable-filter.input.ts |  33 +++---
 ...e-nullable-with-aggregates-filter.input.ts |  45 ++++----
 ...-date-time-with-aggregates-filter.input.ts |  45 ++++----
 .../prisma/nested-decimal-filter.input.ts     |  77 ++++++-------
 .../nested-decimal-nullable-filter.input.ts   |  77 ++++++-------
 ...l-nullable-with-aggregates-filter.input.ts |  83 +++++++-------
 ...ed-decimal-with-aggregates-filter.input.ts |  83 +++++++-------
 .../nested-enum-role-nullable-filter.input.ts |  17 +--
 ...e-nullable-with-aggregates-filter.input.ts |  29 ++---
 .../prisma/nested-float-filter.input.ts       |  33 +++---
 .../nested-float-nullable-filter.input.ts     |  33 +++---
 ...t-nullable-with-aggregates-filter.input.ts |  53 ++++-----
 @generated/prisma/nested-int-filter.input.ts  |  33 +++---
 .../nested-int-nullable-filter.input.ts       |  33 +++---
 ...t-nullable-with-aggregates-filter.input.ts |  53 ++++-----
 ...nested-int-with-aggregates-filter.input.ts |  53 ++++-----
 .../nested-json-nullable-filter.input.ts      |  53 ++++-----
 .../prisma/nested-string-filter.input.ts      |  49 ++++----
 .../nested-string-nullable-filter.input.ts    |  49 ++++----
 ...g-nullable-with-aggregates-filter.input.ts |  61 +++++-----
 ...ted-string-with-aggregates-filter.input.ts |  61 +++++-----
 ...e-big-int-field-update-operations.input.ts |  21 ++--
 ...able-bool-field-update-operations.input.ts |   5 +-
 ...ble-bytes-field-update-operations.input.ts |   5 +-
 ...date-time-field-update-operations.input.ts |   5 +-
 ...e-decimal-field-update-operations.input.ts |  43 +++----
 ...enum-role-field-update-operations.input.ts |   5 +-
 ...ble-float-field-update-operations.input.ts |  21 ++--
 ...lable-int-field-update-operations.input.ts |  21 ++--
 .../nullable-json-null-value-input.enum.ts    |  10 +-
 ...le-string-field-update-operations.input.ts |   5 +-
 @generated/prisma/nulls-order.enum.ts         |   7 +-
 @generated/prisma/query-mode.enum.ts          |   7 +-
 @generated/prisma/role.enum.ts                |   5 +-
 @generated/prisma/sort-order.enum.ts          |   7 +-
 @generated/prisma/sort-order.input.ts         |   9 +-
 .../string-field-update-operations.input.ts   |   5 +-
 @generated/prisma/string-filter.input.ts      |  53 ++++-----
 .../prisma/string-nullable-filter.input.ts    |  53 ++++-----
 .../string-nullable-list-filter.input.ts      |  21 ++--
 ...g-nullable-with-aggregates-filter.input.ts |  65 +++++------
 .../string-with-aggregates-filter.input.ts    |  65 +++++------
 .../transaction-isolation-level.enum.ts       |  14 +--
 .../profile/aggregate-profile.output.ts       |  21 ++--
 .../profile/create-many-profile.args.ts       |  11 +-
 @generated/profile/create-one-profile.args.ts |   7 +-
 .../profile/delete-many-profile.args.ts       |   7 +-
 @generated/profile/delete-one-profile.args.ts |   9 +-
 .../find-first-profile-or-throw.args.ts       |  29 ++---
 @generated/profile/find-first-profile.args.ts |  29 ++---
 @generated/profile/find-many-profile.args.ts  |  29 ++---
 .../find-unique-profile-or-throw.args.ts      |   9 +-
 .../profile/find-unique-profile.args.ts       |   9 +-
 @generated/profile/profile-aggregate.args.ts  |  45 ++++----
 .../profile/profile-avg-aggregate.input.ts    |   5 +-
 .../profile/profile-avg-aggregate.output.ts   |   5 +-
 .../profile-avg-order-by-aggregate.input.ts   |   5 +-
 .../profile/profile-count-aggregate.input.ts  |  17 +--
 .../profile/profile-count-aggregate.output.ts |  17 +--
 .../profile-count-order-by-aggregate.input.ts |  13 ++-
 .../profile/profile-create-many.input.ts      |  13 ++-
 ...le-create-nested-one-without-user.input.ts |  21 ++--
 ...le-create-or-connect-without-user.input.ts |  15 +--
 .../profile-create-without-user.input.ts      |   5 +-
 @generated/profile/profile-create.input.ts    |  11 +-
 @generated/profile/profile-group-by.args.ts   |  47 ++++----
 @generated/profile/profile-group-by.output.ts |  33 +++---
 .../profile/profile-max-aggregate.input.ts    |  13 ++-
 .../profile/profile-max-aggregate.output.ts   |  13 ++-
 .../profile-max-order-by-aggregate.input.ts   |  13 ++-
 .../profile/profile-min-aggregate.input.ts    |  13 ++-
 .../profile/profile-min-aggregate.output.ts   |  13 ++-
 .../profile-min-order-by-aggregate.input.ts   |  13 ++-
 .../profile-nullable-relation-filter.input.ts |   9 +-
 .../profile-order-by-relevance-field.enum.ts  |  10 +-
 .../profile-order-by-relevance.input.ts       |  13 ++-
 ...profile-order-by-with-aggregation.input.ts |  33 +++---
 ...ith-relation-and-search-relevance.input.ts |  23 ++--
 .../profile/profile-scalar-field.enum.ts      |  12 +-
 ...file-scalar-where-with-aggregates.input.ts |  25 ++--
 .../profile/profile-sum-aggregate.input.ts    |   5 +-
 .../profile/profile-sum-aggregate.output.ts   |   5 +-
 .../profile-sum-order-by-aggregate.input.ts   |   5 +-
 ...ed-create-nested-one-without-user.input.ts |  17 +--
 ...ile-unchecked-create-without-user.input.ts |   9 +-
 .../profile/profile-unchecked-create.input.ts |  13 ++-
 .../profile-unchecked-update-many.input.ts    |  13 ++-
 ...ed-update-one-without-user-nested.input.ts |  45 ++++----
 ...ile-unchecked-update-without-user.input.ts |   9 +-
 .../profile/profile-unchecked-update.input.ts |  13 ++-
 .../profile-update-many-mutation.input.ts     |   5 +-
 ...le-update-one-without-user-nested.input.ts |  45 ++++----
 ...te-to-one-with-where-without-user.input.ts |  13 ++-
 .../profile-update-without-user.input.ts      |   5 +-
 @generated/profile/profile-update.input.ts    |  11 +-
 .../profile-upsert-without-user.input.ts      |  19 ++--
 .../profile/profile-where-unique.input.ts     |  31 ++---
 @generated/profile/profile-where.input.ts     |  31 ++---
 @generated/profile/profile.model.ts           |  17 +--
 .../profile/update-many-profile.args.ts       |  13 ++-
 @generated/profile/update-one-profile.args.ts |  15 +--
 @generated/profile/upsert-one-profile.args.ts |  21 ++--
 @generated/tag/aggregate-tag.output.ts        |  13 ++-
 @generated/tag/create-many-tag.args.ts        |  11 +-
 @generated/tag/create-one-tag.args.ts         |   7 +-
 @generated/tag/delete-many-tag.args.ts        |   7 +-
 @generated/tag/delete-one-tag.args.ts         |   9 +-
 .../tag/find-first-tag-or-throw.args.ts       |  29 ++---
 @generated/tag/find-first-tag.args.ts         |  29 ++---
 @generated/tag/find-many-tag.args.ts          |  29 ++---
 .../tag/find-unique-tag-or-throw.args.ts      |   9 +-
 @generated/tag/find-unique-tag.args.ts        |   9 +-
 @generated/tag/tag-aggregate.args.ts          |  37 +++---
 @generated/tag/tag-count-aggregate.input.ts   |  13 ++-
 @generated/tag/tag-count-aggregate.output.ts  |  13 ++-
 .../tag/tag-count-order-by-aggregate.input.ts |   9 +-
 @generated/tag/tag-count.output.ts            |   5 +-
 @generated/tag/tag-create-many.input.ts       |   9 +-
 ...eate-nested-many-without-articles.input.ts |  21 ++--
 ...reate-or-connect-without-articles.input.ts |  15 +--
 .../tag/tag-create-without-articles.input.ts  |   9 +-
 @generated/tag/tag-create.input.ts            |  15 +--
 @generated/tag/tag-group-by.args.ts           |  39 +++----
 @generated/tag/tag-group-by.output.ts         |  21 ++--
 .../tag/tag-list-relation-filter.input.ts     |  13 ++-
 @generated/tag/tag-max-aggregate.input.ts     |   9 +-
 @generated/tag/tag-max-aggregate.output.ts    |   9 +-
 .../tag/tag-max-order-by-aggregate.input.ts   |   9 +-
 @generated/tag/tag-min-aggregate.input.ts     |   9 +-
 @generated/tag/tag-min-aggregate.output.ts    |   9 +-
 .../tag/tag-min-order-by-aggregate.input.ts   |   9 +-
 .../tag-order-by-relation-aggregate.input.ts  |   5 +-
 .../tag/tag-order-by-relevance-field.enum.ts  |  10 +-
 .../tag/tag-order-by-relevance.input.ts       |  13 ++-
 .../tag-order-by-with-aggregation.input.ts    |  21 ++--
 ...ith-relation-and-search-relevance.input.ts |  19 ++--
 @generated/tag/tag-scalar-field.enum.ts       |  10 +-
 .../tag-scalar-where-with-aggregates.input.ts |  21 ++--
 @generated/tag/tag-scalar-where.input.ts      |  21 ++--
 ...eate-nested-many-without-articles.input.ts |  21 ++--
 ...unchecked-create-without-articles.input.ts |   9 +-
 @generated/tag/tag-unchecked-create.input.ts  |  15 +--
 ...date-many-without-articles-nested.input.ts |  63 ++++++-----
 ...cked-update-many-without-articles.input.ts |   9 +-
 .../tag/tag-unchecked-update-many.input.ts    |   9 +-
 ...unchecked-update-without-articles.input.ts |   9 +-
 @generated/tag/tag-unchecked-update.input.ts  |  15 +--
 .../tag/tag-update-many-mutation.input.ts     |   9 +-
 ...-many-with-where-without-articles.input.ts |  13 ++-
 ...date-many-without-articles-nested.input.ts |  63 ++++++-----
 ...ith-where-unique-without-articles.input.ts |  15 +--
 .../tag/tag-update-without-articles.input.ts  |   9 +-
 @generated/tag/tag-update.input.ts            |  15 +--
 ...ith-where-unique-without-articles.input.ts |  21 ++--
 @generated/tag/tag-where-unique.input.ts      |  27 ++---
 @generated/tag/tag-where.input.ts             |  27 ++---
 @generated/tag/tag.model.ts                   |  17 +--
 @generated/tag/update-many-tag.args.ts        |  13 ++-
 @generated/tag/update-one-tag.args.ts         |  15 +--
 @generated/tag/upsert-one-tag.args.ts         |  21 ++--
 @generated/user/aggregate-user.output.ts      |  21 ++--
 @generated/user/create-many-user.args.ts      |  15 +--
 @generated/user/create-one-user.args.ts       |  11 +-
 @generated/user/delete-many-user.args.ts      |   7 +-
 @generated/user/delete-one-user.args.ts       |   9 +-
 .../user/find-first-user-or-throw.args.ts     |  33 +++---
 @generated/user/find-first-user.args.ts       |  33 +++---
 @generated/user/find-many-user.args.ts        |  33 +++---
 .../user/find-unique-user-or-throw.args.ts    |   9 +-
 @generated/user/find-unique-user.args.ts      |   9 +-
 @generated/user/update-many-user.args.ts      |  13 ++-
 @generated/user/update-one-user.args.ts       |  15 +--
 @generated/user/upsert-one-user.args.ts       |  21 ++--
 @generated/user/user-aggregate.args.ts        |  59 +++++-----
 @generated/user/user-avg-aggregate.input.ts   |  13 ++-
 @generated/user/user-avg-aggregate.output.ts  |  15 +--
 .../user/user-avg-order-by-aggregate.input.ts |  13 ++-
 @generated/user/user-count-aggregate.input.ts |  45 ++++----
 .../user/user-count-aggregate.output.ts       |  45 ++++----
 .../user-count-order-by-aggregate.input.ts    |  41 +++----
 @generated/user/user-count.output.ts          |  21 ++--
 @generated/user/user-create-many.input.ts     |  51 +++++----
 ...ed-many-without-favorite-articles.input.ts |  23 ++--
 ...ate-nested-many-without-followers.input.ts |  23 ++--
 ...ate-nested-many-without-following.input.ts |  23 ++--
 ...reate-nested-one-without-articles.input.ts |  24 ++--
 ...reate-nested-one-without-comments.input.ts |  24 ++--
 ...create-nested-one-without-profile.input.ts |  24 ++--
 ...reate-or-connect-without-articles.input.ts |  15 +--
 ...reate-or-connect-without-comments.input.ts |  15 +--
 ...connect-without-favorite-articles.input.ts |  15 +--
 ...eate-or-connect-without-followers.input.ts |  15 +--
 ...eate-or-connect-without-following.input.ts |  15 +--
 ...create-or-connect-without-profile.input.ts |  15 +--
 .../user-create-without-articles.input.ts     |  81 ++++++-------
 .../user-create-without-comments.input.ts     |  81 ++++++-------
 ...-create-without-favorite-articles.input.ts |  81 ++++++-------
 .../user-create-without-followers.input.ts    |  81 ++++++-------
 .../user-create-without-following.input.ts    |  81 ++++++-------
 .../user/user-create-without-profile.input.ts |  81 ++++++-------
 @generated/user/user-create.input.ts          |  87 +++++++-------
 .../user-email-name-compound-unique.input.ts  |  13 ++-
 @generated/user/user-group-by.args.ts         |  61 +++++-----
 @generated/user/user-group-by.output.ts       |  63 ++++++-----
 .../user/user-list-relation-filter.input.ts   |  19 ++--
 @generated/user/user-max-aggregate.input.ts   |  41 +++----
 @generated/user/user-max-aggregate.output.ts  |  43 +++----
 .../user/user-max-order-by-aggregate.input.ts |  41 +++----
 @generated/user/user-min-aggregate.input.ts   |  41 +++----
 @generated/user/user-min-aggregate.output.ts  |  43 +++----
 .../user/user-min-order-by-aggregate.input.ts |  41 +++----
 .../user-order-by-relation-aggregate.input.ts |   5 +-
 .../user-order-by-relevance-field.enum.ts     |  18 ++-
 .../user/user-order-by-relevance.input.ts     |  13 ++-
 .../user-order-by-with-aggregation.input.ts   |  73 ++++++------
 ...ith-relation-and-search-relevance.input.ts |  85 +++++++-------
 @generated/user/user-relation-filter.input.ts |  13 ++-
 @generated/user/user-scalar-field.enum.ts     |  26 ++---
 ...user-scalar-where-with-aggregates.input.ts |  61 +++++-----
 @generated/user/user-scalar-where.input.ts    |  61 +++++-----
 @generated/user/user-sum-aggregate.input.ts   |  13 ++-
 @generated/user/user-sum-aggregate.output.ts  |  15 +--
 .../user/user-sum-order-by-aggregate.input.ts |  13 ++-
 ...ed-many-without-favorite-articles.input.ts |  23 ++--
 ...ate-nested-many-without-followers.input.ts |  23 ++--
 ...ate-nested-many-without-following.input.ts |  23 ++--
 ...unchecked-create-without-articles.input.ts |  83 +++++++-------
 ...unchecked-create-without-comments.input.ts |  83 +++++++-------
 ...-create-without-favorite-articles.input.ts |  81 ++++++-------
 ...nchecked-create-without-followers.input.ts |  83 +++++++-------
 ...nchecked-create-without-following.input.ts |  83 +++++++-------
 ...-unchecked-create-without-profile.input.ts |  83 +++++++-------
 .../user/user-unchecked-create.input.ts       |  89 +++++++--------
 ...-without-favorite-articles-nested.input.ts |  77 ++++++-------
 ...te-many-without-favorite-articles.input.ts |  43 +++----
 ...ate-many-without-followers-nested.input.ts |  89 +++++++--------
 ...ked-update-many-without-followers.input.ts |  43 +++----
 ...ate-many-without-following-nested.input.ts |  89 +++++++--------
 ...ked-update-many-without-following.input.ts |  43 +++----
 .../user/user-unchecked-update-many.input.ts  |  43 +++----
 ...unchecked-update-without-articles.input.ts |  75 ++++++------
 ...unchecked-update-without-comments.input.ts |  75 ++++++------
 ...-update-without-favorite-articles.input.ts |  73 ++++++------
 ...nchecked-update-without-followers.input.ts |  75 ++++++------
 ...nchecked-update-without-following.input.ts |  75 ++++++------
 ...-unchecked-update-without-profile.input.ts |  75 ++++++------
 .../user/user-unchecked-update.input.ts       |  81 +++++++------
 .../user/user-update-many-mutation.input.ts   |  43 +++----
 ...h-where-without-favorite-articles.input.ts |  13 ++-
 ...many-with-where-without-followers.input.ts |  13 ++-
 ...many-with-where-without-following.input.ts |  13 ++-
 ...-without-favorite-articles-nested.input.ts |  77 ++++++-------
 ...ate-many-without-followers-nested.input.ts |  89 +++++++--------
 ...ate-many-without-following-nested.input.ts |  89 +++++++--------
 ...-required-without-articles-nested.input.ts |  36 +++---
 ...-required-without-comments-nested.input.ts |  36 +++---
 ...e-required-without-profile-nested.input.ts |  36 +++---
 ...o-one-with-where-without-articles.input.ts |  13 ++-
 ...o-one-with-where-without-comments.input.ts |  13 ++-
 ...to-one-with-where-without-profile.input.ts |  13 ++-
 ...-unique-without-favorite-articles.input.ts |  15 +--
 ...th-where-unique-without-followers.input.ts |  15 +--
 ...th-where-unique-without-following.input.ts |  15 +--
 .../user-update-without-articles.input.ts     |  73 ++++++------
 .../user-update-without-comments.input.ts     |  73 ++++++------
 ...-update-without-favorite-articles.input.ts |  73 ++++++------
 .../user-update-without-followers.input.ts    |  73 ++++++------
 .../user-update-without-following.input.ts    |  73 ++++++------
 .../user/user-update-without-profile.input.ts |  73 ++++++------
 @generated/user/user-update.input.ts          |  79 ++++++-------
 ...-unique-without-favorite-articles.input.ts |  21 ++--
 ...th-where-unique-without-followers.input.ts |  21 ++--
 ...th-where-unique-without-following.input.ts |  21 ++--
 .../user-upsert-without-articles.input.ts     |  19 ++--
 .../user-upsert-without-comments.input.ts     |  19 ++--
 .../user/user-upsert-without-profile.input.ts |  19 ++--
 @generated/user/user-where-unique.input.ts    | 107 +++++++++---------
 @generated/user/user-where.input.ts           |  97 ++++++++--------
 @generated/user/user.model.ts                 |  79 ++++++-------
 src/handlers/input-type.ts                    |   2 +-
 src/handlers/model-output-type.ts             |   2 +-
 src/handlers/output-type.ts                   |   2 +-
 546 files changed, 8719 insertions(+), 8359 deletions(-)

diff --git a/@generated/article/aggregate-article.output.ts b/@generated/article/aggregate-article.output.ts
index d5e310c5..2724636a 100644
--- a/@generated/article/aggregate-article.output.ts
+++ b/@generated/article/aggregate-article.output.ts
@@ -8,18 +8,19 @@ import { ArticleMaxAggregate } from './article-max-aggregate.output';
 
 @ObjectType()
 export class AggregateArticle {
-  @Field(() => ArticleCountAggregate, { nullable: true })
-  _count?: ArticleCountAggregate;
 
-  @Field(() => ArticleAvgAggregate, { nullable: true })
-  _avg?: ArticleAvgAggregate;
+    @Field(() => ArticleCountAggregate, {nullable:true})
+    _count?: ArticleCountAggregate;
 
-  @Field(() => ArticleSumAggregate, { nullable: true })
-  _sum?: ArticleSumAggregate;
+    @Field(() => ArticleAvgAggregate, {nullable:true})
+    _avg?: ArticleAvgAggregate;
 
-  @Field(() => ArticleMinAggregate, { nullable: true })
-  _min?: ArticleMinAggregate;
+    @Field(() => ArticleSumAggregate, {nullable:true})
+    _sum?: ArticleSumAggregate;
 
-  @Field(() => ArticleMaxAggregate, { nullable: true })
-  _max?: ArticleMaxAggregate;
+    @Field(() => ArticleMinAggregate, {nullable:true})
+    _min?: ArticleMinAggregate;
+
+    @Field(() => ArticleMaxAggregate, {nullable:true})
+    _max?: ArticleMaxAggregate;
 }
diff --git a/@generated/article/article-aggregate.args.ts b/@generated/article/article-aggregate.args.ts
index 30be32c1..e3912458 100644
--- a/@generated/article/article-aggregate.args.ts
+++ b/@generated/article/article-aggregate.args.ts
@@ -3,7 +3,7 @@ import { ArgsType } from '@nestjs/graphql';
 import { ArticleWhereInput } from './article-where.input';
 import { Type } from 'class-transformer';
 import { ArticleOrderByWithRelationAndSearchRelevanceInput } from './article-order-by-with-relation-and-search-relevance.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 import { Int } from '@nestjs/graphql';
 import { ArticleCountAggregateInput } from './article-count-aggregate.input';
@@ -14,34 +14,35 @@ import { ArticleMaxAggregateInput } from './article-max-aggregate.input';
 
 @ArgsType()
 export class ArticleAggregateArgs {
-  @Field(() => ArticleWhereInput, { nullable: true })
-  @Type(() => ArticleWhereInput)
-  where?: ArticleWhereInput;
 
-  @Field(() => [ArticleOrderByWithRelationAndSearchRelevanceInput], { nullable: true })
-  orderBy?: Array<ArticleOrderByWithRelationAndSearchRelevanceInput>;
+    @Field(() => ArticleWhereInput, {nullable:true})
+    @Type(() => ArticleWhereInput)
+    where?: ArticleWhereInput;
 
-  @Field(() => ArticleWhereUniqueInput, { nullable: true })
-  cursor?: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
+    @Field(() => [ArticleOrderByWithRelationAndSearchRelevanceInput], {nullable:true})
+    orderBy?: Array<ArticleOrderByWithRelationAndSearchRelevanceInput>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => ArticleWhereUniqueInput, {nullable:true})
+    cursor?: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => ArticleCountAggregateInput, { nullable: true })
-  _count?: ArticleCountAggregateInput;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
 
-  @Field(() => ArticleAvgAggregateInput, { nullable: true })
-  _avg?: ArticleAvgAggregateInput;
+    @Field(() => ArticleCountAggregateInput, {nullable:true})
+    _count?: ArticleCountAggregateInput;
 
-  @Field(() => ArticleSumAggregateInput, { nullable: true })
-  _sum?: ArticleSumAggregateInput;
+    @Field(() => ArticleAvgAggregateInput, {nullable:true})
+    _avg?: ArticleAvgAggregateInput;
 
-  @Field(() => ArticleMinAggregateInput, { nullable: true })
-  _min?: ArticleMinAggregateInput;
+    @Field(() => ArticleSumAggregateInput, {nullable:true})
+    _sum?: ArticleSumAggregateInput;
 
-  @Field(() => ArticleMaxAggregateInput, { nullable: true })
-  _max?: ArticleMaxAggregateInput;
+    @Field(() => ArticleMinAggregateInput, {nullable:true})
+    _min?: ArticleMinAggregateInput;
+
+    @Field(() => ArticleMaxAggregateInput, {nullable:true})
+    _max?: ArticleMaxAggregateInput;
 }
diff --git a/@generated/article/article-avg-aggregate.input.ts b/@generated/article/article-avg-aggregate.input.ts
index 2a425696..ac5988c8 100644
--- a/@generated/article/article-avg-aggregate.input.ts
+++ b/@generated/article/article-avg-aggregate.input.ts
@@ -3,6 +3,7 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class ArticleAvgAggregateInput {
-  @Field(() => Boolean, { nullable: true })
-  favoritesCount?: true;
+
+    @Field(() => Boolean, {nullable:true})
+    favoritesCount?: true;
 }
diff --git a/@generated/article/article-avg-aggregate.output.ts b/@generated/article/article-avg-aggregate.output.ts
index b21f6f5b..d9f7c1a5 100644
--- a/@generated/article/article-avg-aggregate.output.ts
+++ b/@generated/article/article-avg-aggregate.output.ts
@@ -4,6 +4,7 @@ import { Float } from '@nestjs/graphql';
 
 @ObjectType()
 export class ArticleAvgAggregate {
-  @Field(() => Float, { nullable: true })
-  favoritesCount?: number;
+
+    @Field(() => Float, {nullable:true})
+    favoritesCount?: number;
 }
diff --git a/@generated/article/article-avg-order-by-aggregate.input.ts b/@generated/article/article-avg-order-by-aggregate.input.ts
index 74e268ee..93eb2716 100644
--- a/@generated/article/article-avg-order-by-aggregate.input.ts
+++ b/@generated/article/article-avg-order-by-aggregate.input.ts
@@ -4,6 +4,7 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class ArticleAvgOrderByAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  favoritesCount?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    favoritesCount?: keyof typeof SortOrder;
 }
diff --git a/@generated/article/article-count-aggregate.input.ts b/@generated/article/article-count-aggregate.input.ts
index 75d2aa06..95191a15 100644
--- a/@generated/article/article-count-aggregate.input.ts
+++ b/@generated/article/article-count-aggregate.input.ts
@@ -3,36 +3,37 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class ArticleCountAggregateInput {
-  @Field(() => Boolean, { nullable: true })
-  id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  slug?: true;
+    @Field(() => Boolean, {nullable:true})
+    id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  title?: true;
+    @Field(() => Boolean, {nullable:true})
+    slug?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  description?: true;
+    @Field(() => Boolean, {nullable:true})
+    title?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  body?: true;
+    @Field(() => Boolean, {nullable:true})
+    description?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  createdAt?: true;
+    @Field(() => Boolean, {nullable:true})
+    body?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  updatedAt?: true;
+    @Field(() => Boolean, {nullable:true})
+    createdAt?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  favoritesCount?: true;
+    @Field(() => Boolean, {nullable:true})
+    updatedAt?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  authorId?: true;
+    @Field(() => Boolean, {nullable:true})
+    favoritesCount?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  active?: true;
+    @Field(() => Boolean, {nullable:true})
+    authorId?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  _all?: true;
+    @Field(() => Boolean, {nullable:true})
+    active?: true;
+
+    @Field(() => Boolean, {nullable:true})
+    _all?: true;
 }
diff --git a/@generated/article/article-count-aggregate.output.ts b/@generated/article/article-count-aggregate.output.ts
index b6804d27..9c360ddd 100644
--- a/@generated/article/article-count-aggregate.output.ts
+++ b/@generated/article/article-count-aggregate.output.ts
@@ -4,36 +4,37 @@ import { Int } from '@nestjs/graphql';
 
 @ObjectType()
 export class ArticleCountAggregate {
-  @Field(() => Int, { nullable: false })
-  id!: number;
 
-  @Field(() => Int, { nullable: false })
-  slug!: number;
+    @Field(() => Int, {nullable:false})
+    id!: number;
 
-  @Field(() => Int, { nullable: false })
-  title!: number;
+    @Field(() => Int, {nullable:false})
+    slug!: number;
 
-  @Field(() => Int, { nullable: false })
-  description!: number;
+    @Field(() => Int, {nullable:false})
+    title!: number;
 
-  @Field(() => Int, { nullable: false })
-  body!: number;
+    @Field(() => Int, {nullable:false})
+    description!: number;
 
-  @Field(() => Int, { nullable: false })
-  createdAt!: number;
+    @Field(() => Int, {nullable:false})
+    body!: number;
 
-  @Field(() => Int, { nullable: false })
-  updatedAt!: number;
+    @Field(() => Int, {nullable:false})
+    createdAt!: number;
 
-  @Field(() => Int, { nullable: false })
-  favoritesCount!: number;
+    @Field(() => Int, {nullable:false})
+    updatedAt!: number;
 
-  @Field(() => Int, { nullable: false })
-  authorId!: number;
+    @Field(() => Int, {nullable:false})
+    favoritesCount!: number;
 
-  @Field(() => Int, { nullable: false })
-  active!: number;
+    @Field(() => Int, {nullable:false})
+    authorId!: number;
 
-  @Field(() => Int, { nullable: false })
-  _all!: number;
+    @Field(() => Int, {nullable:false})
+    active!: number;
+
+    @Field(() => Int, {nullable:false})
+    _all!: number;
 }
diff --git a/@generated/article/article-count-order-by-aggregate.input.ts b/@generated/article/article-count-order-by-aggregate.input.ts
index de0fb11b..a1294e6d 100644
--- a/@generated/article/article-count-order-by-aggregate.input.ts
+++ b/@generated/article/article-count-order-by-aggregate.input.ts
@@ -4,33 +4,34 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class ArticleCountOrderByAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  slug?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  title?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    slug?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  description?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    title?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  body?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    description?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  createdAt?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    body?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  updatedAt?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    createdAt?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  favoritesCount?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    updatedAt?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  authorId?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    favoritesCount?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  active?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    authorId?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    active?: keyof typeof SortOrder;
 }
diff --git a/@generated/article/article-count.output.ts b/@generated/article/article-count.output.ts
index 96d8aa3a..bd1ea167 100644
--- a/@generated/article/article-count.output.ts
+++ b/@generated/article/article-count.output.ts
@@ -4,12 +4,13 @@ import { Int } from '@nestjs/graphql';
 
 @ObjectType()
 export class ArticleCount {
-  @Field(() => Int, { nullable: false })
-  tags?: number;
 
-  @Field(() => Int, { nullable: false })
-  favoritedBy?: number;
+    @Field(() => Int, {nullable:false})
+    tags?: number;
 
-  @Field(() => Int, { nullable: false })
-  comments?: number;
+    @Field(() => Int, {nullable:false})
+    favoritedBy?: number;
+
+    @Field(() => Int, {nullable:false})
+    comments?: number;
 }
diff --git a/@generated/article/article-create-many-author-input-envelope.input.ts b/@generated/article/article-create-many-author-input-envelope.input.ts
index 07a8c661..c2de7eae 100644
--- a/@generated/article/article-create-many-author-input-envelope.input.ts
+++ b/@generated/article/article-create-many-author-input-envelope.input.ts
@@ -5,10 +5,11 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class ArticleCreateManyAuthorInputEnvelope {
-  @Field(() => [ArticleCreateManyAuthorInput], { nullable: false })
-  @Type(() => ArticleCreateManyAuthorInput)
-  data!: Array<ArticleCreateManyAuthorInput>;
 
-  @Field(() => Boolean, { nullable: true })
-  skipDuplicates?: boolean;
+    @Field(() => [ArticleCreateManyAuthorInput], {nullable:false})
+    @Type(() => ArticleCreateManyAuthorInput)
+    data!: Array<ArticleCreateManyAuthorInput>;
+
+    @Field(() => Boolean, {nullable:true})
+    skipDuplicates?: boolean;
 }
diff --git a/@generated/article/article-create-many-author.input.ts b/@generated/article/article-create-many-author.input.ts
index 91e5fca9..fac6f50b 100644
--- a/@generated/article/article-create-many-author.input.ts
+++ b/@generated/article/article-create-many-author.input.ts
@@ -5,30 +5,31 @@ import { Int } from '@nestjs/graphql';
 
 @InputType()
 export class ArticleCreateManyAuthorInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => String, { nullable: false })
-  slug!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: false })
-  title!: string;
+    @Field(() => String, {nullable:false})
+    slug!: string;
 
-  @Field(() => String, { nullable: false })
-  description!: string;
+    @Field(() => String, {nullable:false})
+    title!: string;
 
-  @Field(() => String, { nullable: false })
-  body!: string;
+    @Field(() => String, {nullable:false})
+    description!: string;
 
-  @HideField()
-  createdAt?: Date | string;
+    @Field(() => String, {nullable:false})
+    body!: string;
 
-  @Field(() => Date, { nullable: true })
-  updatedAt?: Date | string;
+    @HideField()
+    createdAt?: Date | string;
 
-  @Field(() => Int, { nullable: true })
-  favoritesCount?: number;
+    @Field(() => Date, {nullable:true})
+    updatedAt?: Date | string;
 
-  @Field(() => Boolean, { nullable: true })
-  active?: boolean;
+    @Field(() => Int, {nullable:true})
+    favoritesCount?: number;
+
+    @Field(() => Boolean, {nullable:true})
+    active?: boolean;
 }
diff --git a/@generated/article/article-create-many.input.ts b/@generated/article/article-create-many.input.ts
index 859b204a..05825735 100644
--- a/@generated/article/article-create-many.input.ts
+++ b/@generated/article/article-create-many.input.ts
@@ -5,33 +5,34 @@ import { Int } from '@nestjs/graphql';
 
 @InputType()
 export class ArticleCreateManyInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => String, { nullable: false })
-  slug!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: false })
-  title!: string;
+    @Field(() => String, {nullable:false})
+    slug!: string;
 
-  @Field(() => String, { nullable: false })
-  description!: string;
+    @Field(() => String, {nullable:false})
+    title!: string;
 
-  @Field(() => String, { nullable: false })
-  body!: string;
+    @Field(() => String, {nullable:false})
+    description!: string;
 
-  @HideField()
-  createdAt?: Date | string;
+    @Field(() => String, {nullable:false})
+    body!: string;
 
-  @Field(() => Date, { nullable: true })
-  updatedAt?: Date | string;
+    @HideField()
+    createdAt?: Date | string;
 
-  @Field(() => Int, { nullable: true })
-  favoritesCount?: number;
+    @Field(() => Date, {nullable:true})
+    updatedAt?: Date | string;
 
-  @Field(() => String, { nullable: false })
-  authorId!: string;
+    @Field(() => Int, {nullable:true})
+    favoritesCount?: number;
 
-  @Field(() => Boolean, { nullable: true })
-  active?: boolean;
+    @Field(() => String, {nullable:false})
+    authorId!: string;
+
+    @Field(() => Boolean, {nullable:true})
+    active?: boolean;
 }
diff --git a/@generated/article/article-create-nested-many-without-author.input.ts b/@generated/article/article-create-nested-many-without-author.input.ts
index 736fab8f..64c2aa74 100644
--- a/@generated/article/article-create-nested-many-without-author.input.ts
+++ b/@generated/article/article-create-nested-many-without-author.input.ts
@@ -4,24 +4,25 @@ import { ArticleCreateWithoutAuthorInput } from './article-create-without-author
 import { Type } from 'class-transformer';
 import { ArticleCreateOrConnectWithoutAuthorInput } from './article-create-or-connect-without-author.input';
 import { ArticleCreateManyAuthorInputEnvelope } from './article-create-many-author-input-envelope.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 
 @InputType()
 export class ArticleCreateNestedManyWithoutAuthorInput {
-  @Field(() => [ArticleCreateWithoutAuthorInput], { nullable: true })
-  @Type(() => ArticleCreateWithoutAuthorInput)
-  create?: Array<ArticleCreateWithoutAuthorInput>;
 
-  @Field(() => [ArticleCreateOrConnectWithoutAuthorInput], { nullable: true })
-  @Type(() => ArticleCreateOrConnectWithoutAuthorInput)
-  connectOrCreate?: Array<ArticleCreateOrConnectWithoutAuthorInput>;
+    @Field(() => [ArticleCreateWithoutAuthorInput], {nullable:true})
+    @Type(() => ArticleCreateWithoutAuthorInput)
+    create?: Array<ArticleCreateWithoutAuthorInput>;
 
-  @Field(() => ArticleCreateManyAuthorInputEnvelope, { nullable: true })
-  @Type(() => ArticleCreateManyAuthorInputEnvelope)
-  createMany?: ArticleCreateManyAuthorInputEnvelope;
+    @Field(() => [ArticleCreateOrConnectWithoutAuthorInput], {nullable:true})
+    @Type(() => ArticleCreateOrConnectWithoutAuthorInput)
+    connectOrCreate?: Array<ArticleCreateOrConnectWithoutAuthorInput>;
 
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  connect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+    @Field(() => ArticleCreateManyAuthorInputEnvelope, {nullable:true})
+    @Type(() => ArticleCreateManyAuthorInputEnvelope)
+    createMany?: ArticleCreateManyAuthorInputEnvelope;
+
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
 }
diff --git a/@generated/article/article-create-nested-many-without-favorited-by.input.ts b/@generated/article/article-create-nested-many-without-favorited-by.input.ts
index 61cf2736..aee09ef3 100644
--- a/@generated/article/article-create-nested-many-without-favorited-by.input.ts
+++ b/@generated/article/article-create-nested-many-without-favorited-by.input.ts
@@ -3,20 +3,21 @@ import { InputType } from '@nestjs/graphql';
 import { ArticleCreateWithoutFavoritedByInput } from './article-create-without-favorited-by.input';
 import { Type } from 'class-transformer';
 import { ArticleCreateOrConnectWithoutFavoritedByInput } from './article-create-or-connect-without-favorited-by.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 
 @InputType()
 export class ArticleCreateNestedManyWithoutFavoritedByInput {
-  @Field(() => [ArticleCreateWithoutFavoritedByInput], { nullable: true })
-  @Type(() => ArticleCreateWithoutFavoritedByInput)
-  create?: Array<ArticleCreateWithoutFavoritedByInput>;
 
-  @Field(() => [ArticleCreateOrConnectWithoutFavoritedByInput], { nullable: true })
-  @Type(() => ArticleCreateOrConnectWithoutFavoritedByInput)
-  connectOrCreate?: Array<ArticleCreateOrConnectWithoutFavoritedByInput>;
+    @Field(() => [ArticleCreateWithoutFavoritedByInput], {nullable:true})
+    @Type(() => ArticleCreateWithoutFavoritedByInput)
+    create?: Array<ArticleCreateWithoutFavoritedByInput>;
 
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  connect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+    @Field(() => [ArticleCreateOrConnectWithoutFavoritedByInput], {nullable:true})
+    @Type(() => ArticleCreateOrConnectWithoutFavoritedByInput)
+    connectOrCreate?: Array<ArticleCreateOrConnectWithoutFavoritedByInput>;
+
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
 }
diff --git a/@generated/article/article-create-nested-many-without-tags.input.ts b/@generated/article/article-create-nested-many-without-tags.input.ts
index a1c1cc33..4a254545 100644
--- a/@generated/article/article-create-nested-many-without-tags.input.ts
+++ b/@generated/article/article-create-nested-many-without-tags.input.ts
@@ -3,20 +3,21 @@ import { InputType } from '@nestjs/graphql';
 import { ArticleCreateWithoutTagsInput } from './article-create-without-tags.input';
 import { Type } from 'class-transformer';
 import { ArticleCreateOrConnectWithoutTagsInput } from './article-create-or-connect-without-tags.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 
 @InputType()
 export class ArticleCreateNestedManyWithoutTagsInput {
-  @Field(() => [ArticleCreateWithoutTagsInput], { nullable: true })
-  @Type(() => ArticleCreateWithoutTagsInput)
-  create?: Array<ArticleCreateWithoutTagsInput>;
 
-  @Field(() => [ArticleCreateOrConnectWithoutTagsInput], { nullable: true })
-  @Type(() => ArticleCreateOrConnectWithoutTagsInput)
-  connectOrCreate?: Array<ArticleCreateOrConnectWithoutTagsInput>;
+    @Field(() => [ArticleCreateWithoutTagsInput], {nullable:true})
+    @Type(() => ArticleCreateWithoutTagsInput)
+    create?: Array<ArticleCreateWithoutTagsInput>;
 
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  connect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+    @Field(() => [ArticleCreateOrConnectWithoutTagsInput], {nullable:true})
+    @Type(() => ArticleCreateOrConnectWithoutTagsInput)
+    connectOrCreate?: Array<ArticleCreateOrConnectWithoutTagsInput>;
+
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
 }
diff --git a/@generated/article/article-create-nested-one-without-comments.input.ts b/@generated/article/article-create-nested-one-without-comments.input.ts
index 3e3d7299..28e8c670 100644
--- a/@generated/article/article-create-nested-one-without-comments.input.ts
+++ b/@generated/article/article-create-nested-one-without-comments.input.ts
@@ -3,20 +3,21 @@ import { InputType } from '@nestjs/graphql';
 import { ArticleCreateWithoutCommentsInput } from './article-create-without-comments.input';
 import { Type } from 'class-transformer';
 import { ArticleCreateOrConnectWithoutCommentsInput } from './article-create-or-connect-without-comments.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 
 @InputType()
 export class ArticleCreateNestedOneWithoutCommentsInput {
-  @Field(() => ArticleCreateWithoutCommentsInput, { nullable: true })
-  @Type(() => ArticleCreateWithoutCommentsInput)
-  create?: ArticleCreateWithoutCommentsInput;
 
-  @Field(() => ArticleCreateOrConnectWithoutCommentsInput, { nullable: true })
-  @Type(() => ArticleCreateOrConnectWithoutCommentsInput)
-  connectOrCreate?: ArticleCreateOrConnectWithoutCommentsInput;
+    @Field(() => ArticleCreateWithoutCommentsInput, {nullable:true})
+    @Type(() => ArticleCreateWithoutCommentsInput)
+    create?: ArticleCreateWithoutCommentsInput;
 
-  @Field(() => ArticleWhereUniqueInput, { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  connect?: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
+    @Field(() => ArticleCreateOrConnectWithoutCommentsInput, {nullable:true})
+    @Type(() => ArticleCreateOrConnectWithoutCommentsInput)
+    connectOrCreate?: ArticleCreateOrConnectWithoutCommentsInput;
+
+    @Field(() => ArticleWhereUniqueInput, {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    connect?: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
 }
diff --git a/@generated/article/article-create-or-connect-without-author.input.ts b/@generated/article/article-create-or-connect-without-author.input.ts
index 60db2993..fe43868a 100644
--- a/@generated/article/article-create-or-connect-without-author.input.ts
+++ b/@generated/article/article-create-or-connect-without-author.input.ts
@@ -1,17 +1,18 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 import { Type } from 'class-transformer';
 import { ArticleCreateWithoutAuthorInput } from './article-create-without-author.input';
 
 @InputType()
 export class ArticleCreateOrConnectWithoutAuthorInput {
-  @Field(() => ArticleWhereUniqueInput, { nullable: false })
-  @Type(() => ArticleWhereUniqueInput)
-  where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
 
-  @Field(() => ArticleCreateWithoutAuthorInput, { nullable: false })
-  @Type(() => ArticleCreateWithoutAuthorInput)
-  create!: ArticleCreateWithoutAuthorInput;
+    @Field(() => ArticleWhereUniqueInput, {nullable:false})
+    @Type(() => ArticleWhereUniqueInput)
+    where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
+
+    @Field(() => ArticleCreateWithoutAuthorInput, {nullable:false})
+    @Type(() => ArticleCreateWithoutAuthorInput)
+    create!: ArticleCreateWithoutAuthorInput;
 }
diff --git a/@generated/article/article-create-or-connect-without-comments.input.ts b/@generated/article/article-create-or-connect-without-comments.input.ts
index 2683d381..e55376ff 100644
--- a/@generated/article/article-create-or-connect-without-comments.input.ts
+++ b/@generated/article/article-create-or-connect-without-comments.input.ts
@@ -1,17 +1,18 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 import { Type } from 'class-transformer';
 import { ArticleCreateWithoutCommentsInput } from './article-create-without-comments.input';
 
 @InputType()
 export class ArticleCreateOrConnectWithoutCommentsInput {
-  @Field(() => ArticleWhereUniqueInput, { nullable: false })
-  @Type(() => ArticleWhereUniqueInput)
-  where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
 
-  @Field(() => ArticleCreateWithoutCommentsInput, { nullable: false })
-  @Type(() => ArticleCreateWithoutCommentsInput)
-  create!: ArticleCreateWithoutCommentsInput;
+    @Field(() => ArticleWhereUniqueInput, {nullable:false})
+    @Type(() => ArticleWhereUniqueInput)
+    where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
+
+    @Field(() => ArticleCreateWithoutCommentsInput, {nullable:false})
+    @Type(() => ArticleCreateWithoutCommentsInput)
+    create!: ArticleCreateWithoutCommentsInput;
 }
diff --git a/@generated/article/article-create-or-connect-without-favorited-by.input.ts b/@generated/article/article-create-or-connect-without-favorited-by.input.ts
index 48e364c9..c4a7888e 100644
--- a/@generated/article/article-create-or-connect-without-favorited-by.input.ts
+++ b/@generated/article/article-create-or-connect-without-favorited-by.input.ts
@@ -1,17 +1,18 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 import { Type } from 'class-transformer';
 import { ArticleCreateWithoutFavoritedByInput } from './article-create-without-favorited-by.input';
 
 @InputType()
 export class ArticleCreateOrConnectWithoutFavoritedByInput {
-  @Field(() => ArticleWhereUniqueInput, { nullable: false })
-  @Type(() => ArticleWhereUniqueInput)
-  where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
 
-  @Field(() => ArticleCreateWithoutFavoritedByInput, { nullable: false })
-  @Type(() => ArticleCreateWithoutFavoritedByInput)
-  create!: ArticleCreateWithoutFavoritedByInput;
+    @Field(() => ArticleWhereUniqueInput, {nullable:false})
+    @Type(() => ArticleWhereUniqueInput)
+    where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
+
+    @Field(() => ArticleCreateWithoutFavoritedByInput, {nullable:false})
+    @Type(() => ArticleCreateWithoutFavoritedByInput)
+    create!: ArticleCreateWithoutFavoritedByInput;
 }
diff --git a/@generated/article/article-create-or-connect-without-tags.input.ts b/@generated/article/article-create-or-connect-without-tags.input.ts
index 68c57dbc..e916aab3 100644
--- a/@generated/article/article-create-or-connect-without-tags.input.ts
+++ b/@generated/article/article-create-or-connect-without-tags.input.ts
@@ -1,17 +1,18 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 import { Type } from 'class-transformer';
 import { ArticleCreateWithoutTagsInput } from './article-create-without-tags.input';
 
 @InputType()
 export class ArticleCreateOrConnectWithoutTagsInput {
-  @Field(() => ArticleWhereUniqueInput, { nullable: false })
-  @Type(() => ArticleWhereUniqueInput)
-  where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
 
-  @Field(() => ArticleCreateWithoutTagsInput, { nullable: false })
-  @Type(() => ArticleCreateWithoutTagsInput)
-  create!: ArticleCreateWithoutTagsInput;
+    @Field(() => ArticleWhereUniqueInput, {nullable:false})
+    @Type(() => ArticleWhereUniqueInput)
+    where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
+
+    @Field(() => ArticleCreateWithoutTagsInput, {nullable:false})
+    @Type(() => ArticleCreateWithoutTagsInput)
+    create!: ArticleCreateWithoutTagsInput;
 }
diff --git a/@generated/article/article-create-without-author.input.ts b/@generated/article/article-create-without-author.input.ts
index 856a9bb3..7dd2a90e 100644
--- a/@generated/article/article-create-without-author.input.ts
+++ b/@generated/article/article-create-without-author.input.ts
@@ -9,41 +9,42 @@ import { CommentCreateNestedManyWithoutArticleInput } from '../comment/comment-c
 
 @InputType()
 export class ArticleCreateWithoutAuthorInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => String, { nullable: false })
-  slug!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: false })
-  title!: string;
+    @Field(() => String, {nullable:false})
+    slug!: string;
 
-  @Field(() => String, { nullable: false })
-  description!: string;
+    @Field(() => String, {nullable:false})
+    title!: string;
 
-  @Field(() => String, { nullable: false })
-  body!: string;
+    @Field(() => String, {nullable:false})
+    description!: string;
 
-  @HideField()
-  createdAt?: Date | string;
+    @Field(() => String, {nullable:false})
+    body!: string;
 
-  @Field(() => Date, { nullable: true })
-  updatedAt?: Date | string;
+    @HideField()
+    createdAt?: Date | string;
 
-  @Field(() => Int, { nullable: true })
-  favoritesCount?: number;
+    @Field(() => Date, {nullable:true})
+    updatedAt?: Date | string;
 
-  @Field(() => Boolean, { nullable: true })
-  active?: boolean;
+    @Field(() => Int, {nullable:true})
+    favoritesCount?: number;
 
-  @Field(() => TagCreateNestedManyWithoutArticlesInput, { nullable: true })
-  tags?: TagCreateNestedManyWithoutArticlesInput;
+    @Field(() => Boolean, {nullable:true})
+    active?: boolean;
 
-  @Field(() => UserCreateNestedManyWithoutFavoriteArticlesInput, { nullable: true })
-  @Type(() => UserCreateNestedManyWithoutFavoriteArticlesInput)
-  favoritedBy?: UserCreateNestedManyWithoutFavoriteArticlesInput;
+    @Field(() => TagCreateNestedManyWithoutArticlesInput, {nullable:true})
+    tags?: TagCreateNestedManyWithoutArticlesInput;
 
-  @Field(() => CommentCreateNestedManyWithoutArticleInput, { nullable: true })
-  @Type(() => CommentCreateNestedManyWithoutArticleInput)
-  comments?: CommentCreateNestedManyWithoutArticleInput;
+    @Field(() => UserCreateNestedManyWithoutFavoriteArticlesInput, {nullable:true})
+    @Type(() => UserCreateNestedManyWithoutFavoriteArticlesInput)
+    favoritedBy?: UserCreateNestedManyWithoutFavoriteArticlesInput;
+
+    @Field(() => CommentCreateNestedManyWithoutArticleInput, {nullable:true})
+    @Type(() => CommentCreateNestedManyWithoutArticleInput)
+    comments?: CommentCreateNestedManyWithoutArticleInput;
 }
diff --git a/@generated/article/article-create-without-comments.input.ts b/@generated/article/article-create-without-comments.input.ts
index 394a24cb..4ac3c09c 100644
--- a/@generated/article/article-create-without-comments.input.ts
+++ b/@generated/article/article-create-without-comments.input.ts
@@ -9,41 +9,42 @@ import { UserCreateNestedManyWithoutFavoriteArticlesInput } from '../user/user-c
 
 @InputType()
 export class ArticleCreateWithoutCommentsInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => String, { nullable: false })
-  slug!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: false })
-  title!: string;
+    @Field(() => String, {nullable:false})
+    slug!: string;
 
-  @Field(() => String, { nullable: false })
-  description!: string;
+    @Field(() => String, {nullable:false})
+    title!: string;
 
-  @Field(() => String, { nullable: false })
-  body!: string;
+    @Field(() => String, {nullable:false})
+    description!: string;
 
-  @HideField()
-  createdAt?: Date | string;
+    @Field(() => String, {nullable:false})
+    body!: string;
 
-  @Field(() => Date, { nullable: true })
-  updatedAt?: Date | string;
+    @HideField()
+    createdAt?: Date | string;
 
-  @Field(() => Int, { nullable: true })
-  favoritesCount?: number;
+    @Field(() => Date, {nullable:true})
+    updatedAt?: Date | string;
 
-  @Field(() => Boolean, { nullable: true })
-  active?: boolean;
+    @Field(() => Int, {nullable:true})
+    favoritesCount?: number;
 
-  @Field(() => TagCreateNestedManyWithoutArticlesInput, { nullable: true })
-  tags?: TagCreateNestedManyWithoutArticlesInput;
+    @Field(() => Boolean, {nullable:true})
+    active?: boolean;
 
-  @Field(() => UserCreateNestedOneWithoutArticlesInput, { nullable: false })
-  @Type(() => UserCreateNestedOneWithoutArticlesInput)
-  author!: UserCreateNestedOneWithoutArticlesInput;
+    @Field(() => TagCreateNestedManyWithoutArticlesInput, {nullable:true})
+    tags?: TagCreateNestedManyWithoutArticlesInput;
 
-  @Field(() => UserCreateNestedManyWithoutFavoriteArticlesInput, { nullable: true })
-  @Type(() => UserCreateNestedManyWithoutFavoriteArticlesInput)
-  favoritedBy?: UserCreateNestedManyWithoutFavoriteArticlesInput;
+    @Field(() => UserCreateNestedOneWithoutArticlesInput, {nullable:false})
+    @Type(() => UserCreateNestedOneWithoutArticlesInput)
+    author!: UserCreateNestedOneWithoutArticlesInput;
+
+    @Field(() => UserCreateNestedManyWithoutFavoriteArticlesInput, {nullable:true})
+    @Type(() => UserCreateNestedManyWithoutFavoriteArticlesInput)
+    favoritedBy?: UserCreateNestedManyWithoutFavoriteArticlesInput;
 }
diff --git a/@generated/article/article-create-without-favorited-by.input.ts b/@generated/article/article-create-without-favorited-by.input.ts
index b53d4148..e8e09070 100644
--- a/@generated/article/article-create-without-favorited-by.input.ts
+++ b/@generated/article/article-create-without-favorited-by.input.ts
@@ -9,41 +9,42 @@ import { CommentCreateNestedManyWithoutArticleInput } from '../comment/comment-c
 
 @InputType()
 export class ArticleCreateWithoutFavoritedByInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => String, { nullable: false })
-  slug!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: false })
-  title!: string;
+    @Field(() => String, {nullable:false})
+    slug!: string;
 
-  @Field(() => String, { nullable: false })
-  description!: string;
+    @Field(() => String, {nullable:false})
+    title!: string;
 
-  @Field(() => String, { nullable: false })
-  body!: string;
+    @Field(() => String, {nullable:false})
+    description!: string;
 
-  @HideField()
-  createdAt?: Date | string;
+    @Field(() => String, {nullable:false})
+    body!: string;
 
-  @Field(() => Date, { nullable: true })
-  updatedAt?: Date | string;
+    @HideField()
+    createdAt?: Date | string;
 
-  @Field(() => Int, { nullable: true })
-  favoritesCount?: number;
+    @Field(() => Date, {nullable:true})
+    updatedAt?: Date | string;
 
-  @Field(() => Boolean, { nullable: true })
-  active?: boolean;
+    @Field(() => Int, {nullable:true})
+    favoritesCount?: number;
 
-  @Field(() => TagCreateNestedManyWithoutArticlesInput, { nullable: true })
-  tags?: TagCreateNestedManyWithoutArticlesInput;
+    @Field(() => Boolean, {nullable:true})
+    active?: boolean;
 
-  @Field(() => UserCreateNestedOneWithoutArticlesInput, { nullable: false })
-  @Type(() => UserCreateNestedOneWithoutArticlesInput)
-  author!: UserCreateNestedOneWithoutArticlesInput;
+    @Field(() => TagCreateNestedManyWithoutArticlesInput, {nullable:true})
+    tags?: TagCreateNestedManyWithoutArticlesInput;
 
-  @Field(() => CommentCreateNestedManyWithoutArticleInput, { nullable: true })
-  @Type(() => CommentCreateNestedManyWithoutArticleInput)
-  comments?: CommentCreateNestedManyWithoutArticleInput;
+    @Field(() => UserCreateNestedOneWithoutArticlesInput, {nullable:false})
+    @Type(() => UserCreateNestedOneWithoutArticlesInput)
+    author!: UserCreateNestedOneWithoutArticlesInput;
+
+    @Field(() => CommentCreateNestedManyWithoutArticleInput, {nullable:true})
+    @Type(() => CommentCreateNestedManyWithoutArticleInput)
+    comments?: CommentCreateNestedManyWithoutArticleInput;
 }
diff --git a/@generated/article/article-create-without-tags.input.ts b/@generated/article/article-create-without-tags.input.ts
index 4063c5a9..86c87ee6 100644
--- a/@generated/article/article-create-without-tags.input.ts
+++ b/@generated/article/article-create-without-tags.input.ts
@@ -9,42 +9,43 @@ import { CommentCreateNestedManyWithoutArticleInput } from '../comment/comment-c
 
 @InputType()
 export class ArticleCreateWithoutTagsInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => String, { nullable: false })
-  slug!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: false })
-  title!: string;
+    @Field(() => String, {nullable:false})
+    slug!: string;
 
-  @Field(() => String, { nullable: false })
-  description!: string;
+    @Field(() => String, {nullable:false})
+    title!: string;
 
-  @Field(() => String, { nullable: false })
-  body!: string;
+    @Field(() => String, {nullable:false})
+    description!: string;
 
-  @HideField()
-  createdAt?: Date | string;
+    @Field(() => String, {nullable:false})
+    body!: string;
 
-  @Field(() => Date, { nullable: true })
-  updatedAt?: Date | string;
+    @HideField()
+    createdAt?: Date | string;
 
-  @Field(() => Int, { nullable: true })
-  favoritesCount?: number;
+    @Field(() => Date, {nullable:true})
+    updatedAt?: Date | string;
 
-  @Field(() => Boolean, { nullable: true })
-  active?: boolean;
+    @Field(() => Int, {nullable:true})
+    favoritesCount?: number;
 
-  @Field(() => UserCreateNestedOneWithoutArticlesInput, { nullable: false })
-  @Type(() => UserCreateNestedOneWithoutArticlesInput)
-  author!: UserCreateNestedOneWithoutArticlesInput;
+    @Field(() => Boolean, {nullable:true})
+    active?: boolean;
 
-  @Field(() => UserCreateNestedManyWithoutFavoriteArticlesInput, { nullable: true })
-  @Type(() => UserCreateNestedManyWithoutFavoriteArticlesInput)
-  favoritedBy?: UserCreateNestedManyWithoutFavoriteArticlesInput;
+    @Field(() => UserCreateNestedOneWithoutArticlesInput, {nullable:false})
+    @Type(() => UserCreateNestedOneWithoutArticlesInput)
+    author!: UserCreateNestedOneWithoutArticlesInput;
 
-  @Field(() => CommentCreateNestedManyWithoutArticleInput, { nullable: true })
-  @Type(() => CommentCreateNestedManyWithoutArticleInput)
-  comments?: CommentCreateNestedManyWithoutArticleInput;
+    @Field(() => UserCreateNestedManyWithoutFavoriteArticlesInput, {nullable:true})
+    @Type(() => UserCreateNestedManyWithoutFavoriteArticlesInput)
+    favoritedBy?: UserCreateNestedManyWithoutFavoriteArticlesInput;
+
+    @Field(() => CommentCreateNestedManyWithoutArticleInput, {nullable:true})
+    @Type(() => CommentCreateNestedManyWithoutArticleInput)
+    comments?: CommentCreateNestedManyWithoutArticleInput;
 }
diff --git a/@generated/article/article-create.input.ts b/@generated/article/article-create.input.ts
index e8ebc5f4..40fe5f80 100644
--- a/@generated/article/article-create.input.ts
+++ b/@generated/article/article-create.input.ts
@@ -10,45 +10,46 @@ import { CommentCreateNestedManyWithoutArticleInput } from '../comment/comment-c
 
 @InputType()
 export class ArticleCreateInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => String, { nullable: false })
-  slug!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: false })
-  title!: string;
+    @Field(() => String, {nullable:false})
+    slug!: string;
 
-  @Field(() => String, { nullable: false })
-  description!: string;
+    @Field(() => String, {nullable:false})
+    title!: string;
 
-  @Field(() => String, { nullable: false })
-  body!: string;
+    @Field(() => String, {nullable:false})
+    description!: string;
 
-  @HideField()
-  createdAt?: Date | string;
+    @Field(() => String, {nullable:false})
+    body!: string;
 
-  @Field(() => Date, { nullable: true })
-  updatedAt?: Date | string;
+    @HideField()
+    createdAt?: Date | string;
 
-  @Field(() => Int, { nullable: true })
-  favoritesCount?: number;
+    @Field(() => Date, {nullable:true})
+    updatedAt?: Date | string;
 
-  @Field(() => Boolean, { nullable: true })
-  active?: boolean;
+    @Field(() => Int, {nullable:true})
+    favoritesCount?: number;
 
-  @Field(() => TagCreateNestedManyWithoutArticlesInput, { nullable: true })
-  tags?: TagCreateNestedManyWithoutArticlesInput;
+    @Field(() => Boolean, {nullable:true})
+    active?: boolean;
 
-  @Field(() => UserCreateNestedOneWithoutArticlesInput, { nullable: false })
-  @Type(() => UserCreateNestedOneWithoutArticlesInput)
-  author!: UserCreateNestedOneWithoutArticlesInput;
+    @Field(() => TagCreateNestedManyWithoutArticlesInput, {nullable:true})
+    tags?: TagCreateNestedManyWithoutArticlesInput;
 
-  @Field(() => UserCreateNestedManyWithoutFavoriteArticlesInput, { nullable: true })
-  @Type(() => UserCreateNestedManyWithoutFavoriteArticlesInput)
-  favoritedBy?: UserCreateNestedManyWithoutFavoriteArticlesInput;
+    @Field(() => UserCreateNestedOneWithoutArticlesInput, {nullable:false})
+    @Type(() => UserCreateNestedOneWithoutArticlesInput)
+    author!: UserCreateNestedOneWithoutArticlesInput;
 
-  @Field(() => CommentCreateNestedManyWithoutArticleInput, { nullable: true })
-  @Type(() => CommentCreateNestedManyWithoutArticleInput)
-  comments?: CommentCreateNestedManyWithoutArticleInput;
+    @Field(() => UserCreateNestedManyWithoutFavoriteArticlesInput, {nullable:true})
+    @Type(() => UserCreateNestedManyWithoutFavoriteArticlesInput)
+    favoritedBy?: UserCreateNestedManyWithoutFavoriteArticlesInput;
+
+    @Field(() => CommentCreateNestedManyWithoutArticleInput, {nullable:true})
+    @Type(() => CommentCreateNestedManyWithoutArticleInput)
+    comments?: CommentCreateNestedManyWithoutArticleInput;
 }
diff --git a/@generated/article/article-group-by.args.ts b/@generated/article/article-group-by.args.ts
index e4cb550b..b564a719 100644
--- a/@generated/article/article-group-by.args.ts
+++ b/@generated/article/article-group-by.args.ts
@@ -14,37 +14,38 @@ import { ArticleMaxAggregateInput } from './article-max-aggregate.input';
 
 @ArgsType()
 export class ArticleGroupByArgs {
-  @Field(() => ArticleWhereInput, { nullable: true })
-  @Type(() => ArticleWhereInput)
-  where?: ArticleWhereInput;
 
-  @Field(() => [ArticleOrderByWithAggregationInput], { nullable: true })
-  orderBy?: Array<ArticleOrderByWithAggregationInput>;
+    @Field(() => ArticleWhereInput, {nullable:true})
+    @Type(() => ArticleWhereInput)
+    where?: ArticleWhereInput;
 
-  @Field(() => [ArticleScalarFieldEnum], { nullable: false })
-  by!: Array<keyof typeof ArticleScalarFieldEnum>;
+    @Field(() => [ArticleOrderByWithAggregationInput], {nullable:true})
+    orderBy?: Array<ArticleOrderByWithAggregationInput>;
 
-  @Field(() => ArticleScalarWhereWithAggregatesInput, { nullable: true })
-  having?: ArticleScalarWhereWithAggregatesInput;
+    @Field(() => [ArticleScalarFieldEnum], {nullable:false})
+    by!: Array<keyof typeof ArticleScalarFieldEnum>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => ArticleScalarWhereWithAggregatesInput, {nullable:true})
+    having?: ArticleScalarWhereWithAggregatesInput;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => ArticleCountAggregateInput, { nullable: true })
-  _count?: ArticleCountAggregateInput;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
 
-  @Field(() => ArticleAvgAggregateInput, { nullable: true })
-  _avg?: ArticleAvgAggregateInput;
+    @Field(() => ArticleCountAggregateInput, {nullable:true})
+    _count?: ArticleCountAggregateInput;
 
-  @Field(() => ArticleSumAggregateInput, { nullable: true })
-  _sum?: ArticleSumAggregateInput;
+    @Field(() => ArticleAvgAggregateInput, {nullable:true})
+    _avg?: ArticleAvgAggregateInput;
 
-  @Field(() => ArticleMinAggregateInput, { nullable: true })
-  _min?: ArticleMinAggregateInput;
+    @Field(() => ArticleSumAggregateInput, {nullable:true})
+    _sum?: ArticleSumAggregateInput;
 
-  @Field(() => ArticleMaxAggregateInput, { nullable: true })
-  _max?: ArticleMaxAggregateInput;
+    @Field(() => ArticleMinAggregateInput, {nullable:true})
+    _min?: ArticleMinAggregateInput;
+
+    @Field(() => ArticleMaxAggregateInput, {nullable:true})
+    _max?: ArticleMaxAggregateInput;
 }
diff --git a/@generated/article/article-group-by.output.ts b/@generated/article/article-group-by.output.ts
index e468c495..0f0794df 100644
--- a/@generated/article/article-group-by.output.ts
+++ b/@generated/article/article-group-by.output.ts
@@ -9,48 +9,49 @@ import { ArticleMaxAggregate } from './article-max-aggregate.output';
 
 @ObjectType()
 export class ArticleGroupBy {
-  @Field(() => String, { nullable: false })
-  id!: string;
 
-  @Field(() => String, { nullable: false })
-  slug!: string;
+    @Field(() => String, {nullable:false})
+    id!: string;
 
-  @Field(() => String, { nullable: false })
-  title!: string;
+    @Field(() => String, {nullable:false})
+    slug!: string;
 
-  @Field(() => String, { nullable: false })
-  description!: string;
+    @Field(() => String, {nullable:false})
+    title!: string;
 
-  @Field(() => String, { nullable: false })
-  body!: string;
+    @Field(() => String, {nullable:false})
+    description!: string;
 
-  @Field(() => Date, { nullable: false })
-  createdAt!: Date | string;
+    @Field(() => String, {nullable:false})
+    body!: string;
 
-  @Field(() => Date, { nullable: false })
-  updatedAt!: Date | string;
+    @Field(() => Date, {nullable:false})
+    createdAt!: Date | string;
 
-  @Field(() => Int, { nullable: false })
-  favoritesCount!: number;
+    @Field(() => Date, {nullable:false})
+    updatedAt!: Date | string;
 
-  @Field(() => String, { nullable: false })
-  authorId!: string;
+    @Field(() => Int, {nullable:false})
+    favoritesCount!: number;
 
-  @Field(() => Boolean, { nullable: true })
-  active?: boolean;
+    @Field(() => String, {nullable:false})
+    authorId!: string;
 
-  @Field(() => ArticleCountAggregate, { nullable: true })
-  _count?: ArticleCountAggregate;
+    @Field(() => Boolean, {nullable:true})
+    active?: boolean;
 
-  @Field(() => ArticleAvgAggregate, { nullable: true })
-  _avg?: ArticleAvgAggregate;
+    @Field(() => ArticleCountAggregate, {nullable:true})
+    _count?: ArticleCountAggregate;
 
-  @Field(() => ArticleSumAggregate, { nullable: true })
-  _sum?: ArticleSumAggregate;
+    @Field(() => ArticleAvgAggregate, {nullable:true})
+    _avg?: ArticleAvgAggregate;
 
-  @Field(() => ArticleMinAggregate, { nullable: true })
-  _min?: ArticleMinAggregate;
+    @Field(() => ArticleSumAggregate, {nullable:true})
+    _sum?: ArticleSumAggregate;
 
-  @Field(() => ArticleMaxAggregate, { nullable: true })
-  _max?: ArticleMaxAggregate;
+    @Field(() => ArticleMinAggregate, {nullable:true})
+    _min?: ArticleMinAggregate;
+
+    @Field(() => ArticleMaxAggregate, {nullable:true})
+    _max?: ArticleMaxAggregate;
 }
diff --git a/@generated/article/article-list-relation-filter.input.ts b/@generated/article/article-list-relation-filter.input.ts
index bf21c6f8..fde169d7 100644
--- a/@generated/article/article-list-relation-filter.input.ts
+++ b/@generated/article/article-list-relation-filter.input.ts
@@ -4,12 +4,13 @@ import { ArticleWhereInput } from './article-where.input';
 
 @InputType()
 export class ArticleListRelationFilter {
-  @Field(() => ArticleWhereInput, { nullable: true })
-  every?: ArticleWhereInput;
 
-  @Field(() => ArticleWhereInput, { nullable: true })
-  some?: ArticleWhereInput;
+    @Field(() => ArticleWhereInput, {nullable:true})
+    every?: ArticleWhereInput;
 
-  @Field(() => ArticleWhereInput, { nullable: true })
-  none?: ArticleWhereInput;
+    @Field(() => ArticleWhereInput, {nullable:true})
+    some?: ArticleWhereInput;
+
+    @Field(() => ArticleWhereInput, {nullable:true})
+    none?: ArticleWhereInput;
 }
diff --git a/@generated/article/article-max-aggregate.input.ts b/@generated/article/article-max-aggregate.input.ts
index d113282b..165caeae 100644
--- a/@generated/article/article-max-aggregate.input.ts
+++ b/@generated/article/article-max-aggregate.input.ts
@@ -3,33 +3,34 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class ArticleMaxAggregateInput {
-  @Field(() => Boolean, { nullable: true })
-  id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  slug?: true;
+    @Field(() => Boolean, {nullable:true})
+    id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  title?: true;
+    @Field(() => Boolean, {nullable:true})
+    slug?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  description?: true;
+    @Field(() => Boolean, {nullable:true})
+    title?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  body?: true;
+    @Field(() => Boolean, {nullable:true})
+    description?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  createdAt?: true;
+    @Field(() => Boolean, {nullable:true})
+    body?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  updatedAt?: true;
+    @Field(() => Boolean, {nullable:true})
+    createdAt?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  favoritesCount?: true;
+    @Field(() => Boolean, {nullable:true})
+    updatedAt?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  authorId?: true;
+    @Field(() => Boolean, {nullable:true})
+    favoritesCount?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  active?: true;
+    @Field(() => Boolean, {nullable:true})
+    authorId?: true;
+
+    @Field(() => Boolean, {nullable:true})
+    active?: true;
 }
diff --git a/@generated/article/article-max-aggregate.output.ts b/@generated/article/article-max-aggregate.output.ts
index 1d02ebed..1fb8cbd9 100644
--- a/@generated/article/article-max-aggregate.output.ts
+++ b/@generated/article/article-max-aggregate.output.ts
@@ -4,33 +4,34 @@ import { Int } from '@nestjs/graphql';
 
 @ObjectType()
 export class ArticleMaxAggregate {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => String, { nullable: true })
-  slug?: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: true })
-  title?: string;
+    @Field(() => String, {nullable:true})
+    slug?: string;
 
-  @Field(() => String, { nullable: true })
-  description?: string;
+    @Field(() => String, {nullable:true})
+    title?: string;
 
-  @Field(() => String, { nullable: true })
-  body?: string;
+    @Field(() => String, {nullable:true})
+    description?: string;
 
-  @Field(() => Date, { nullable: true })
-  createdAt?: Date | string;
+    @Field(() => String, {nullable:true})
+    body?: string;
 
-  @Field(() => Date, { nullable: true })
-  updatedAt?: Date | string;
+    @Field(() => Date, {nullable:true})
+    createdAt?: Date | string;
 
-  @Field(() => Int, { nullable: true })
-  favoritesCount?: number;
+    @Field(() => Date, {nullable:true})
+    updatedAt?: Date | string;
 
-  @Field(() => String, { nullable: true })
-  authorId?: string;
+    @Field(() => Int, {nullable:true})
+    favoritesCount?: number;
 
-  @Field(() => Boolean, { nullable: true })
-  active?: boolean;
+    @Field(() => String, {nullable:true})
+    authorId?: string;
+
+    @Field(() => Boolean, {nullable:true})
+    active?: boolean;
 }
diff --git a/@generated/article/article-max-order-by-aggregate.input.ts b/@generated/article/article-max-order-by-aggregate.input.ts
index e9e948aa..b394a41e 100644
--- a/@generated/article/article-max-order-by-aggregate.input.ts
+++ b/@generated/article/article-max-order-by-aggregate.input.ts
@@ -4,33 +4,34 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class ArticleMaxOrderByAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  slug?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  title?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    slug?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  description?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    title?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  body?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    description?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  createdAt?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    body?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  updatedAt?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    createdAt?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  favoritesCount?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    updatedAt?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  authorId?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    favoritesCount?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  active?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    authorId?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    active?: keyof typeof SortOrder;
 }
diff --git a/@generated/article/article-min-aggregate.input.ts b/@generated/article/article-min-aggregate.input.ts
index f440acb6..6127615f 100644
--- a/@generated/article/article-min-aggregate.input.ts
+++ b/@generated/article/article-min-aggregate.input.ts
@@ -3,33 +3,34 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class ArticleMinAggregateInput {
-  @Field(() => Boolean, { nullable: true })
-  id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  slug?: true;
+    @Field(() => Boolean, {nullable:true})
+    id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  title?: true;
+    @Field(() => Boolean, {nullable:true})
+    slug?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  description?: true;
+    @Field(() => Boolean, {nullable:true})
+    title?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  body?: true;
+    @Field(() => Boolean, {nullable:true})
+    description?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  createdAt?: true;
+    @Field(() => Boolean, {nullable:true})
+    body?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  updatedAt?: true;
+    @Field(() => Boolean, {nullable:true})
+    createdAt?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  favoritesCount?: true;
+    @Field(() => Boolean, {nullable:true})
+    updatedAt?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  authorId?: true;
+    @Field(() => Boolean, {nullable:true})
+    favoritesCount?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  active?: true;
+    @Field(() => Boolean, {nullable:true})
+    authorId?: true;
+
+    @Field(() => Boolean, {nullable:true})
+    active?: true;
 }
diff --git a/@generated/article/article-min-aggregate.output.ts b/@generated/article/article-min-aggregate.output.ts
index d427daba..ee8094d1 100644
--- a/@generated/article/article-min-aggregate.output.ts
+++ b/@generated/article/article-min-aggregate.output.ts
@@ -4,33 +4,34 @@ import { Int } from '@nestjs/graphql';
 
 @ObjectType()
 export class ArticleMinAggregate {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => String, { nullable: true })
-  slug?: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: true })
-  title?: string;
+    @Field(() => String, {nullable:true})
+    slug?: string;
 
-  @Field(() => String, { nullable: true })
-  description?: string;
+    @Field(() => String, {nullable:true})
+    title?: string;
 
-  @Field(() => String, { nullable: true })
-  body?: string;
+    @Field(() => String, {nullable:true})
+    description?: string;
 
-  @Field(() => Date, { nullable: true })
-  createdAt?: Date | string;
+    @Field(() => String, {nullable:true})
+    body?: string;
 
-  @Field(() => Date, { nullable: true })
-  updatedAt?: Date | string;
+    @Field(() => Date, {nullable:true})
+    createdAt?: Date | string;
 
-  @Field(() => Int, { nullable: true })
-  favoritesCount?: number;
+    @Field(() => Date, {nullable:true})
+    updatedAt?: Date | string;
 
-  @Field(() => String, { nullable: true })
-  authorId?: string;
+    @Field(() => Int, {nullable:true})
+    favoritesCount?: number;
 
-  @Field(() => Boolean, { nullable: true })
-  active?: boolean;
+    @Field(() => String, {nullable:true})
+    authorId?: string;
+
+    @Field(() => Boolean, {nullable:true})
+    active?: boolean;
 }
diff --git a/@generated/article/article-min-order-by-aggregate.input.ts b/@generated/article/article-min-order-by-aggregate.input.ts
index 6cd0e3eb..56948c20 100644
--- a/@generated/article/article-min-order-by-aggregate.input.ts
+++ b/@generated/article/article-min-order-by-aggregate.input.ts
@@ -4,33 +4,34 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class ArticleMinOrderByAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  slug?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  title?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    slug?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  description?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    title?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  body?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    description?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  createdAt?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    body?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  updatedAt?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    createdAt?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  favoritesCount?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    updatedAt?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  authorId?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    favoritesCount?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  active?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    authorId?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    active?: keyof typeof SortOrder;
 }
diff --git a/@generated/article/article-nullable-relation-filter.input.ts b/@generated/article/article-nullable-relation-filter.input.ts
index de46f816..b3394f1a 100644
--- a/@generated/article/article-nullable-relation-filter.input.ts
+++ b/@generated/article/article-nullable-relation-filter.input.ts
@@ -4,9 +4,10 @@ import { ArticleWhereInput } from './article-where.input';
 
 @InputType()
 export class ArticleNullableRelationFilter {
-  @Field(() => ArticleWhereInput, { nullable: true })
-  is?: ArticleWhereInput;
 
-  @Field(() => ArticleWhereInput, { nullable: true })
-  isNot?: ArticleWhereInput;
+    @Field(() => ArticleWhereInput, {nullable:true})
+    is?: ArticleWhereInput;
+
+    @Field(() => ArticleWhereInput, {nullable:true})
+    isNot?: ArticleWhereInput;
 }
diff --git a/@generated/article/article-order-by-relation-aggregate.input.ts b/@generated/article/article-order-by-relation-aggregate.input.ts
index d1f3c8da..d37bfef8 100644
--- a/@generated/article/article-order-by-relation-aggregate.input.ts
+++ b/@generated/article/article-order-by-relation-aggregate.input.ts
@@ -4,6 +4,7 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class ArticleOrderByRelationAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  _count?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    _count?: keyof typeof SortOrder;
 }
diff --git a/@generated/article/article-order-by-relevance-field.enum.ts b/@generated/article/article-order-by-relevance-field.enum.ts
index 34e0bf28..df39c1a0 100644
--- a/@generated/article/article-order-by-relevance-field.enum.ts
+++ b/@generated/article/article-order-by-relevance-field.enum.ts
@@ -1,15 +1,13 @@
 import { registerEnumType } from '@nestjs/graphql';
 
 export enum ArticleOrderByRelevanceFieldEnum {
-  id = 'id',
-  slug = 'slug',
-  title = 'title',
-  description = 'description',
-  body = 'body',
-  authorId = 'authorId',
+    id = "id",
+    slug = "slug",
+    title = "title",
+    description = "description",
+    body = "body",
+    authorId = "authorId"
 }
 
-registerEnumType(ArticleOrderByRelevanceFieldEnum, {
-  name: 'ArticleOrderByRelevanceFieldEnum',
-  description: undefined,
-});
+
+registerEnumType(ArticleOrderByRelevanceFieldEnum, { name: 'ArticleOrderByRelevanceFieldEnum', description: undefined })
diff --git a/@generated/article/article-order-by-relevance.input.ts b/@generated/article/article-order-by-relevance.input.ts
index 87d8d5df..6df4a8fa 100644
--- a/@generated/article/article-order-by-relevance.input.ts
+++ b/@generated/article/article-order-by-relevance.input.ts
@@ -5,12 +5,13 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class ArticleOrderByRelevanceInput {
-  @Field(() => [ArticleOrderByRelevanceFieldEnum], { nullable: false })
-  fields!: Array<keyof typeof ArticleOrderByRelevanceFieldEnum>;
 
-  @Field(() => SortOrder, { nullable: false })
-  sort!: keyof typeof SortOrder;
+    @Field(() => [ArticleOrderByRelevanceFieldEnum], {nullable:false})
+    fields!: Array<keyof typeof ArticleOrderByRelevanceFieldEnum>;
 
-  @Field(() => String, { nullable: false })
-  search!: string;
+    @Field(() => SortOrder, {nullable:false})
+    sort!: keyof typeof SortOrder;
+
+    @Field(() => String, {nullable:false})
+    search!: string;
 }
diff --git a/@generated/article/article-order-by-with-aggregation.input.ts b/@generated/article/article-order-by-with-aggregation.input.ts
index b57f324c..d0fe44fb 100644
--- a/@generated/article/article-order-by-with-aggregation.input.ts
+++ b/@generated/article/article-order-by-with-aggregation.input.ts
@@ -10,48 +10,49 @@ import { ArticleSumOrderByAggregateInput } from './article-sum-order-by-aggregat
 
 @InputType()
 export class ArticleOrderByWithAggregationInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  slug?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  title?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    slug?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  description?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    title?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  body?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    description?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  createdAt?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    body?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  updatedAt?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    createdAt?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  favoritesCount?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    updatedAt?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  authorId?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    favoritesCount?: keyof typeof SortOrder;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  active?: SortOrderInput;
+    @Field(() => SortOrder, {nullable:true})
+    authorId?: keyof typeof SortOrder;
 
-  @Field(() => ArticleCountOrderByAggregateInput, { nullable: true })
-  _count?: ArticleCountOrderByAggregateInput;
+    @Field(() => SortOrderInput, {nullable:true})
+    active?: SortOrderInput;
 
-  @Field(() => ArticleAvgOrderByAggregateInput, { nullable: true })
-  _avg?: ArticleAvgOrderByAggregateInput;
+    @Field(() => ArticleCountOrderByAggregateInput, {nullable:true})
+    _count?: ArticleCountOrderByAggregateInput;
 
-  @Field(() => ArticleMaxOrderByAggregateInput, { nullable: true })
-  _max?: ArticleMaxOrderByAggregateInput;
+    @Field(() => ArticleAvgOrderByAggregateInput, {nullable:true})
+    _avg?: ArticleAvgOrderByAggregateInput;
 
-  @Field(() => ArticleMinOrderByAggregateInput, { nullable: true })
-  _min?: ArticleMinOrderByAggregateInput;
+    @Field(() => ArticleMaxOrderByAggregateInput, {nullable:true})
+    _max?: ArticleMaxOrderByAggregateInput;
 
-  @Field(() => ArticleSumOrderByAggregateInput, { nullable: true })
-  _sum?: ArticleSumOrderByAggregateInput;
+    @Field(() => ArticleMinOrderByAggregateInput, {nullable:true})
+    _min?: ArticleMinOrderByAggregateInput;
+
+    @Field(() => ArticleSumOrderByAggregateInput, {nullable:true})
+    _sum?: ArticleSumOrderByAggregateInput;
 }
diff --git a/@generated/article/article-order-by-with-relation-and-search-relevance.input.ts b/@generated/article/article-order-by-with-relation-and-search-relevance.input.ts
index 4dbea4c6..80ed924f 100644
--- a/@generated/article/article-order-by-with-relation-and-search-relevance.input.ts
+++ b/@generated/article/article-order-by-with-relation-and-search-relevance.input.ts
@@ -11,51 +11,52 @@ import { ArticleOrderByRelevanceInput } from './article-order-by-relevance.input
 
 @InputType()
 export class ArticleOrderByWithRelationAndSearchRelevanceInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  slug?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  title?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    slug?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  description?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    title?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  body?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    description?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  createdAt?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    body?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  updatedAt?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    createdAt?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  favoritesCount?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    updatedAt?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  authorId?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    favoritesCount?: keyof typeof SortOrder;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  active?: SortOrderInput;
+    @Field(() => SortOrder, {nullable:true})
+    authorId?: keyof typeof SortOrder;
 
-  @Field(() => TagOrderByRelationAggregateInput, { nullable: true })
-  tags?: TagOrderByRelationAggregateInput;
+    @Field(() => SortOrderInput, {nullable:true})
+    active?: SortOrderInput;
 
-  @Field(() => UserOrderByWithRelationAndSearchRelevanceInput, { nullable: true })
-  @Type(() => UserOrderByWithRelationAndSearchRelevanceInput)
-  author?: UserOrderByWithRelationAndSearchRelevanceInput;
+    @Field(() => TagOrderByRelationAggregateInput, {nullable:true})
+    tags?: TagOrderByRelationAggregateInput;
 
-  @Field(() => UserOrderByRelationAggregateInput, { nullable: true })
-  @Type(() => UserOrderByRelationAggregateInput)
-  favoritedBy?: UserOrderByRelationAggregateInput;
+    @Field(() => UserOrderByWithRelationAndSearchRelevanceInput, {nullable:true})
+    @Type(() => UserOrderByWithRelationAndSearchRelevanceInput)
+    author?: UserOrderByWithRelationAndSearchRelevanceInput;
 
-  @Field(() => CommentOrderByRelationAggregateInput, { nullable: true })
-  @Type(() => CommentOrderByRelationAggregateInput)
-  comments?: CommentOrderByRelationAggregateInput;
+    @Field(() => UserOrderByRelationAggregateInput, {nullable:true})
+    @Type(() => UserOrderByRelationAggregateInput)
+    favoritedBy?: UserOrderByRelationAggregateInput;
 
-  @Field(() => ArticleOrderByRelevanceInput, { nullable: true })
-  _relevance?: ArticleOrderByRelevanceInput;
+    @Field(() => CommentOrderByRelationAggregateInput, {nullable:true})
+    @Type(() => CommentOrderByRelationAggregateInput)
+    comments?: CommentOrderByRelationAggregateInput;
+
+    @Field(() => ArticleOrderByRelevanceInput, {nullable:true})
+    _relevance?: ArticleOrderByRelevanceInput;
 }
diff --git a/@generated/article/article-scalar-field.enum.ts b/@generated/article/article-scalar-field.enum.ts
index d9983842..cdc8874c 100644
--- a/@generated/article/article-scalar-field.enum.ts
+++ b/@generated/article/article-scalar-field.enum.ts
@@ -1,19 +1,17 @@
 import { registerEnumType } from '@nestjs/graphql';
 
 export enum ArticleScalarFieldEnum {
-  id = 'id',
-  slug = 'slug',
-  title = 'title',
-  description = 'description',
-  body = 'body',
-  createdAt = 'createdAt',
-  updatedAt = 'updatedAt',
-  favoritesCount = 'favoritesCount',
-  authorId = 'authorId',
-  active = 'active',
+    id = "id",
+    slug = "slug",
+    title = "title",
+    description = "description",
+    body = "body",
+    createdAt = "createdAt",
+    updatedAt = "updatedAt",
+    favoritesCount = "favoritesCount",
+    authorId = "authorId",
+    active = "active"
 }
 
-registerEnumType(ArticleScalarFieldEnum, {
-  name: 'ArticleScalarFieldEnum',
-  description: undefined,
-});
+
+registerEnumType(ArticleScalarFieldEnum, { name: 'ArticleScalarFieldEnum', description: undefined })
diff --git a/@generated/article/article-scalar-where-with-aggregates.input.ts b/@generated/article/article-scalar-where-with-aggregates.input.ts
index 3e56f506..d94909ee 100644
--- a/@generated/article/article-scalar-where-with-aggregates.input.ts
+++ b/@generated/article/article-scalar-where-with-aggregates.input.ts
@@ -7,42 +7,43 @@ import { BoolNullableWithAggregatesFilter } from '../prisma/bool-nullable-with-a
 
 @InputType()
 export class ArticleScalarWhereWithAggregatesInput {
-  @Field(() => [ArticleScalarWhereWithAggregatesInput], { nullable: true })
-  AND?: Array<ArticleScalarWhereWithAggregatesInput>;
 
-  @Field(() => [ArticleScalarWhereWithAggregatesInput], { nullable: true })
-  OR?: Array<ArticleScalarWhereWithAggregatesInput>;
+    @Field(() => [ArticleScalarWhereWithAggregatesInput], {nullable:true})
+    AND?: Array<ArticleScalarWhereWithAggregatesInput>;
 
-  @Field(() => [ArticleScalarWhereWithAggregatesInput], { nullable: true })
-  NOT?: Array<ArticleScalarWhereWithAggregatesInput>;
+    @Field(() => [ArticleScalarWhereWithAggregatesInput], {nullable:true})
+    OR?: Array<ArticleScalarWhereWithAggregatesInput>;
 
-  @Field(() => StringWithAggregatesFilter, { nullable: true })
-  id?: StringWithAggregatesFilter;
+    @Field(() => [ArticleScalarWhereWithAggregatesInput], {nullable:true})
+    NOT?: Array<ArticleScalarWhereWithAggregatesInput>;
 
-  @Field(() => StringWithAggregatesFilter, { nullable: true })
-  slug?: StringWithAggregatesFilter;
+    @Field(() => StringWithAggregatesFilter, {nullable:true})
+    id?: StringWithAggregatesFilter;
 
-  @Field(() => StringWithAggregatesFilter, { nullable: true })
-  title?: StringWithAggregatesFilter;
+    @Field(() => StringWithAggregatesFilter, {nullable:true})
+    slug?: StringWithAggregatesFilter;
 
-  @Field(() => StringWithAggregatesFilter, { nullable: true })
-  description?: StringWithAggregatesFilter;
+    @Field(() => StringWithAggregatesFilter, {nullable:true})
+    title?: StringWithAggregatesFilter;
 
-  @Field(() => StringWithAggregatesFilter, { nullable: true })
-  body?: StringWithAggregatesFilter;
+    @Field(() => StringWithAggregatesFilter, {nullable:true})
+    description?: StringWithAggregatesFilter;
 
-  @Field(() => DateTimeWithAggregatesFilter, { nullable: true })
-  createdAt?: DateTimeWithAggregatesFilter;
+    @Field(() => StringWithAggregatesFilter, {nullable:true})
+    body?: StringWithAggregatesFilter;
 
-  @Field(() => DateTimeWithAggregatesFilter, { nullable: true })
-  updatedAt?: DateTimeWithAggregatesFilter;
+    @Field(() => DateTimeWithAggregatesFilter, {nullable:true})
+    createdAt?: DateTimeWithAggregatesFilter;
 
-  @Field(() => IntWithAggregatesFilter, { nullable: true })
-  favoritesCount?: IntWithAggregatesFilter;
+    @Field(() => DateTimeWithAggregatesFilter, {nullable:true})
+    updatedAt?: DateTimeWithAggregatesFilter;
 
-  @Field(() => StringWithAggregatesFilter, { nullable: true })
-  authorId?: StringWithAggregatesFilter;
+    @Field(() => IntWithAggregatesFilter, {nullable:true})
+    favoritesCount?: IntWithAggregatesFilter;
 
-  @Field(() => BoolNullableWithAggregatesFilter, { nullable: true })
-  active?: BoolNullableWithAggregatesFilter;
+    @Field(() => StringWithAggregatesFilter, {nullable:true})
+    authorId?: StringWithAggregatesFilter;
+
+    @Field(() => BoolNullableWithAggregatesFilter, {nullable:true})
+    active?: BoolNullableWithAggregatesFilter;
 }
diff --git a/@generated/article/article-scalar-where.input.ts b/@generated/article/article-scalar-where.input.ts
index d0656ea8..4f469468 100644
--- a/@generated/article/article-scalar-where.input.ts
+++ b/@generated/article/article-scalar-where.input.ts
@@ -7,42 +7,43 @@ import { BoolNullableFilter } from '../prisma/bool-nullable-filter.input';
 
 @InputType()
 export class ArticleScalarWhereInput {
-  @Field(() => [ArticleScalarWhereInput], { nullable: true })
-  AND?: Array<ArticleScalarWhereInput>;
 
-  @Field(() => [ArticleScalarWhereInput], { nullable: true })
-  OR?: Array<ArticleScalarWhereInput>;
+    @Field(() => [ArticleScalarWhereInput], {nullable:true})
+    AND?: Array<ArticleScalarWhereInput>;
 
-  @Field(() => [ArticleScalarWhereInput], { nullable: true })
-  NOT?: Array<ArticleScalarWhereInput>;
+    @Field(() => [ArticleScalarWhereInput], {nullable:true})
+    OR?: Array<ArticleScalarWhereInput>;
 
-  @Field(() => StringFilter, { nullable: true })
-  id?: StringFilter;
+    @Field(() => [ArticleScalarWhereInput], {nullable:true})
+    NOT?: Array<ArticleScalarWhereInput>;
 
-  @Field(() => StringFilter, { nullable: true })
-  slug?: StringFilter;
+    @Field(() => StringFilter, {nullable:true})
+    id?: StringFilter;
 
-  @Field(() => StringFilter, { nullable: true })
-  title?: StringFilter;
+    @Field(() => StringFilter, {nullable:true})
+    slug?: StringFilter;
 
-  @Field(() => StringFilter, { nullable: true })
-  description?: StringFilter;
+    @Field(() => StringFilter, {nullable:true})
+    title?: StringFilter;
 
-  @Field(() => StringFilter, { nullable: true })
-  body?: StringFilter;
+    @Field(() => StringFilter, {nullable:true})
+    description?: StringFilter;
 
-  @Field(() => DateTimeFilter, { nullable: true })
-  createdAt?: DateTimeFilter;
+    @Field(() => StringFilter, {nullable:true})
+    body?: StringFilter;
 
-  @Field(() => DateTimeFilter, { nullable: true })
-  updatedAt?: DateTimeFilter;
+    @Field(() => DateTimeFilter, {nullable:true})
+    createdAt?: DateTimeFilter;
 
-  @Field(() => IntFilter, { nullable: true })
-  favoritesCount?: IntFilter;
+    @Field(() => DateTimeFilter, {nullable:true})
+    updatedAt?: DateTimeFilter;
 
-  @Field(() => StringFilter, { nullable: true })
-  authorId?: StringFilter;
+    @Field(() => IntFilter, {nullable:true})
+    favoritesCount?: IntFilter;
 
-  @Field(() => BoolNullableFilter, { nullable: true })
-  active?: BoolNullableFilter;
+    @Field(() => StringFilter, {nullable:true})
+    authorId?: StringFilter;
+
+    @Field(() => BoolNullableFilter, {nullable:true})
+    active?: BoolNullableFilter;
 }
diff --git a/@generated/article/article-sum-aggregate.input.ts b/@generated/article/article-sum-aggregate.input.ts
index 214c04d2..2d7cd758 100644
--- a/@generated/article/article-sum-aggregate.input.ts
+++ b/@generated/article/article-sum-aggregate.input.ts
@@ -3,6 +3,7 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class ArticleSumAggregateInput {
-  @Field(() => Boolean, { nullable: true })
-  favoritesCount?: true;
+
+    @Field(() => Boolean, {nullable:true})
+    favoritesCount?: true;
 }
diff --git a/@generated/article/article-sum-aggregate.output.ts b/@generated/article/article-sum-aggregate.output.ts
index 054a5312..c6c785b8 100644
--- a/@generated/article/article-sum-aggregate.output.ts
+++ b/@generated/article/article-sum-aggregate.output.ts
@@ -4,6 +4,7 @@ import { Int } from '@nestjs/graphql';
 
 @ObjectType()
 export class ArticleSumAggregate {
-  @Field(() => Int, { nullable: true })
-  favoritesCount?: number;
+
+    @Field(() => Int, {nullable:true})
+    favoritesCount?: number;
 }
diff --git a/@generated/article/article-sum-order-by-aggregate.input.ts b/@generated/article/article-sum-order-by-aggregate.input.ts
index 9b8830da..12ce0a1a 100644
--- a/@generated/article/article-sum-order-by-aggregate.input.ts
+++ b/@generated/article/article-sum-order-by-aggregate.input.ts
@@ -4,6 +4,7 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class ArticleSumOrderByAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  favoritesCount?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    favoritesCount?: keyof typeof SortOrder;
 }
diff --git a/@generated/article/article-unchecked-create-nested-many-without-author.input.ts b/@generated/article/article-unchecked-create-nested-many-without-author.input.ts
index f966d340..26799b6a 100644
--- a/@generated/article/article-unchecked-create-nested-many-without-author.input.ts
+++ b/@generated/article/article-unchecked-create-nested-many-without-author.input.ts
@@ -4,24 +4,25 @@ import { ArticleCreateWithoutAuthorInput } from './article-create-without-author
 import { Type } from 'class-transformer';
 import { ArticleCreateOrConnectWithoutAuthorInput } from './article-create-or-connect-without-author.input';
 import { ArticleCreateManyAuthorInputEnvelope } from './article-create-many-author-input-envelope.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 
 @InputType()
 export class ArticleUncheckedCreateNestedManyWithoutAuthorInput {
-  @Field(() => [ArticleCreateWithoutAuthorInput], { nullable: true })
-  @Type(() => ArticleCreateWithoutAuthorInput)
-  create?: Array<ArticleCreateWithoutAuthorInput>;
 
-  @Field(() => [ArticleCreateOrConnectWithoutAuthorInput], { nullable: true })
-  @Type(() => ArticleCreateOrConnectWithoutAuthorInput)
-  connectOrCreate?: Array<ArticleCreateOrConnectWithoutAuthorInput>;
+    @Field(() => [ArticleCreateWithoutAuthorInput], {nullable:true})
+    @Type(() => ArticleCreateWithoutAuthorInput)
+    create?: Array<ArticleCreateWithoutAuthorInput>;
 
-  @Field(() => ArticleCreateManyAuthorInputEnvelope, { nullable: true })
-  @Type(() => ArticleCreateManyAuthorInputEnvelope)
-  createMany?: ArticleCreateManyAuthorInputEnvelope;
+    @Field(() => [ArticleCreateOrConnectWithoutAuthorInput], {nullable:true})
+    @Type(() => ArticleCreateOrConnectWithoutAuthorInput)
+    connectOrCreate?: Array<ArticleCreateOrConnectWithoutAuthorInput>;
 
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  connect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+    @Field(() => ArticleCreateManyAuthorInputEnvelope, {nullable:true})
+    @Type(() => ArticleCreateManyAuthorInputEnvelope)
+    createMany?: ArticleCreateManyAuthorInputEnvelope;
+
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
 }
diff --git a/@generated/article/article-unchecked-create-nested-many-without-favorited-by.input.ts b/@generated/article/article-unchecked-create-nested-many-without-favorited-by.input.ts
index 623ffb13..d3682893 100644
--- a/@generated/article/article-unchecked-create-nested-many-without-favorited-by.input.ts
+++ b/@generated/article/article-unchecked-create-nested-many-without-favorited-by.input.ts
@@ -3,20 +3,21 @@ import { InputType } from '@nestjs/graphql';
 import { ArticleCreateWithoutFavoritedByInput } from './article-create-without-favorited-by.input';
 import { Type } from 'class-transformer';
 import { ArticleCreateOrConnectWithoutFavoritedByInput } from './article-create-or-connect-without-favorited-by.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 
 @InputType()
 export class ArticleUncheckedCreateNestedManyWithoutFavoritedByInput {
-  @Field(() => [ArticleCreateWithoutFavoritedByInput], { nullable: true })
-  @Type(() => ArticleCreateWithoutFavoritedByInput)
-  create?: Array<ArticleCreateWithoutFavoritedByInput>;
 
-  @Field(() => [ArticleCreateOrConnectWithoutFavoritedByInput], { nullable: true })
-  @Type(() => ArticleCreateOrConnectWithoutFavoritedByInput)
-  connectOrCreate?: Array<ArticleCreateOrConnectWithoutFavoritedByInput>;
+    @Field(() => [ArticleCreateWithoutFavoritedByInput], {nullable:true})
+    @Type(() => ArticleCreateWithoutFavoritedByInput)
+    create?: Array<ArticleCreateWithoutFavoritedByInput>;
 
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  connect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+    @Field(() => [ArticleCreateOrConnectWithoutFavoritedByInput], {nullable:true})
+    @Type(() => ArticleCreateOrConnectWithoutFavoritedByInput)
+    connectOrCreate?: Array<ArticleCreateOrConnectWithoutFavoritedByInput>;
+
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
 }
diff --git a/@generated/article/article-unchecked-create-nested-many-without-tags.input.ts b/@generated/article/article-unchecked-create-nested-many-without-tags.input.ts
index 7c5ea186..7d1a6d65 100644
--- a/@generated/article/article-unchecked-create-nested-many-without-tags.input.ts
+++ b/@generated/article/article-unchecked-create-nested-many-without-tags.input.ts
@@ -3,20 +3,21 @@ import { InputType } from '@nestjs/graphql';
 import { ArticleCreateWithoutTagsInput } from './article-create-without-tags.input';
 import { Type } from 'class-transformer';
 import { ArticleCreateOrConnectWithoutTagsInput } from './article-create-or-connect-without-tags.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 
 @InputType()
 export class ArticleUncheckedCreateNestedManyWithoutTagsInput {
-  @Field(() => [ArticleCreateWithoutTagsInput], { nullable: true })
-  @Type(() => ArticleCreateWithoutTagsInput)
-  create?: Array<ArticleCreateWithoutTagsInput>;
 
-  @Field(() => [ArticleCreateOrConnectWithoutTagsInput], { nullable: true })
-  @Type(() => ArticleCreateOrConnectWithoutTagsInput)
-  connectOrCreate?: Array<ArticleCreateOrConnectWithoutTagsInput>;
+    @Field(() => [ArticleCreateWithoutTagsInput], {nullable:true})
+    @Type(() => ArticleCreateWithoutTagsInput)
+    create?: Array<ArticleCreateWithoutTagsInput>;
 
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  connect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+    @Field(() => [ArticleCreateOrConnectWithoutTagsInput], {nullable:true})
+    @Type(() => ArticleCreateOrConnectWithoutTagsInput)
+    connectOrCreate?: Array<ArticleCreateOrConnectWithoutTagsInput>;
+
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
 }
diff --git a/@generated/article/article-unchecked-create-without-author.input.ts b/@generated/article/article-unchecked-create-without-author.input.ts
index 6e55c706..9d738cf2 100644
--- a/@generated/article/article-unchecked-create-without-author.input.ts
+++ b/@generated/article/article-unchecked-create-without-author.input.ts
@@ -9,43 +9,42 @@ import { CommentUncheckedCreateNestedManyWithoutArticleInput } from '../comment/
 
 @InputType()
 export class ArticleUncheckedCreateWithoutAuthorInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => String, { nullable: false })
-  slug!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: false })
-  title!: string;
+    @Field(() => String, {nullable:false})
+    slug!: string;
 
-  @Field(() => String, { nullable: false })
-  description!: string;
+    @Field(() => String, {nullable:false})
+    title!: string;
 
-  @Field(() => String, { nullable: false })
-  body!: string;
+    @Field(() => String, {nullable:false})
+    description!: string;
 
-  @HideField()
-  createdAt?: Date | string;
+    @Field(() => String, {nullable:false})
+    body!: string;
 
-  @Field(() => Date, { nullable: true })
-  updatedAt?: Date | string;
+    @HideField()
+    createdAt?: Date | string;
 
-  @Field(() => Int, { nullable: true })
-  favoritesCount?: number;
+    @Field(() => Date, {nullable:true})
+    updatedAt?: Date | string;
 
-  @Field(() => Boolean, { nullable: true })
-  active?: boolean;
+    @Field(() => Int, {nullable:true})
+    favoritesCount?: number;
 
-  @Field(() => TagUncheckedCreateNestedManyWithoutArticlesInput, { nullable: true })
-  tags?: TagUncheckedCreateNestedManyWithoutArticlesInput;
+    @Field(() => Boolean, {nullable:true})
+    active?: boolean;
 
-  @Field(() => UserUncheckedCreateNestedManyWithoutFavoriteArticlesInput, {
-    nullable: true,
-  })
-  @Type(() => UserUncheckedCreateNestedManyWithoutFavoriteArticlesInput)
-  favoritedBy?: UserUncheckedCreateNestedManyWithoutFavoriteArticlesInput;
+    @Field(() => TagUncheckedCreateNestedManyWithoutArticlesInput, {nullable:true})
+    tags?: TagUncheckedCreateNestedManyWithoutArticlesInput;
 
-  @Field(() => CommentUncheckedCreateNestedManyWithoutArticleInput, { nullable: true })
-  @Type(() => CommentUncheckedCreateNestedManyWithoutArticleInput)
-  comments?: CommentUncheckedCreateNestedManyWithoutArticleInput;
+    @Field(() => UserUncheckedCreateNestedManyWithoutFavoriteArticlesInput, {nullable:true})
+    @Type(() => UserUncheckedCreateNestedManyWithoutFavoriteArticlesInput)
+    favoritedBy?: UserUncheckedCreateNestedManyWithoutFavoriteArticlesInput;
+
+    @Field(() => CommentUncheckedCreateNestedManyWithoutArticleInput, {nullable:true})
+    @Type(() => CommentUncheckedCreateNestedManyWithoutArticleInput)
+    comments?: CommentUncheckedCreateNestedManyWithoutArticleInput;
 }
diff --git a/@generated/article/article-unchecked-create-without-comments.input.ts b/@generated/article/article-unchecked-create-without-comments.input.ts
index cb18b556..77734c86 100644
--- a/@generated/article/article-unchecked-create-without-comments.input.ts
+++ b/@generated/article/article-unchecked-create-without-comments.input.ts
@@ -8,42 +8,41 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class ArticleUncheckedCreateWithoutCommentsInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => String, { nullable: false })
-  slug!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: false })
-  title!: string;
+    @Field(() => String, {nullable:false})
+    slug!: string;
 
-  @Field(() => String, { nullable: false })
-  description!: string;
+    @Field(() => String, {nullable:false})
+    title!: string;
 
-  @Field(() => String, { nullable: false })
-  body!: string;
+    @Field(() => String, {nullable:false})
+    description!: string;
 
-  @HideField()
-  createdAt?: Date | string;
+    @Field(() => String, {nullable:false})
+    body!: string;
 
-  @Field(() => Date, { nullable: true })
-  updatedAt?: Date | string;
+    @HideField()
+    createdAt?: Date | string;
 
-  @Field(() => Int, { nullable: true })
-  favoritesCount?: number;
+    @Field(() => Date, {nullable:true})
+    updatedAt?: Date | string;
 
-  @Field(() => String, { nullable: false })
-  authorId!: string;
+    @Field(() => Int, {nullable:true})
+    favoritesCount?: number;
 
-  @Field(() => Boolean, { nullable: true })
-  active?: boolean;
+    @Field(() => String, {nullable:false})
+    authorId!: string;
 
-  @Field(() => TagUncheckedCreateNestedManyWithoutArticlesInput, { nullable: true })
-  tags?: TagUncheckedCreateNestedManyWithoutArticlesInput;
+    @Field(() => Boolean, {nullable:true})
+    active?: boolean;
 
-  @Field(() => UserUncheckedCreateNestedManyWithoutFavoriteArticlesInput, {
-    nullable: true,
-  })
-  @Type(() => UserUncheckedCreateNestedManyWithoutFavoriteArticlesInput)
-  favoritedBy?: UserUncheckedCreateNestedManyWithoutFavoriteArticlesInput;
+    @Field(() => TagUncheckedCreateNestedManyWithoutArticlesInput, {nullable:true})
+    tags?: TagUncheckedCreateNestedManyWithoutArticlesInput;
+
+    @Field(() => UserUncheckedCreateNestedManyWithoutFavoriteArticlesInput, {nullable:true})
+    @Type(() => UserUncheckedCreateNestedManyWithoutFavoriteArticlesInput)
+    favoritedBy?: UserUncheckedCreateNestedManyWithoutFavoriteArticlesInput;
 }
diff --git a/@generated/article/article-unchecked-create-without-favorited-by.input.ts b/@generated/article/article-unchecked-create-without-favorited-by.input.ts
index 4b7f35e6..116bb0f0 100644
--- a/@generated/article/article-unchecked-create-without-favorited-by.input.ts
+++ b/@generated/article/article-unchecked-create-without-favorited-by.input.ts
@@ -8,40 +8,41 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class ArticleUncheckedCreateWithoutFavoritedByInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => String, { nullable: false })
-  slug!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: false })
-  title!: string;
+    @Field(() => String, {nullable:false})
+    slug!: string;
 
-  @Field(() => String, { nullable: false })
-  description!: string;
+    @Field(() => String, {nullable:false})
+    title!: string;
 
-  @Field(() => String, { nullable: false })
-  body!: string;
+    @Field(() => String, {nullable:false})
+    description!: string;
 
-  @HideField()
-  createdAt?: Date | string;
+    @Field(() => String, {nullable:false})
+    body!: string;
 
-  @Field(() => Date, { nullable: true })
-  updatedAt?: Date | string;
+    @HideField()
+    createdAt?: Date | string;
 
-  @Field(() => Int, { nullable: true })
-  favoritesCount?: number;
+    @Field(() => Date, {nullable:true})
+    updatedAt?: Date | string;
 
-  @Field(() => String, { nullable: false })
-  authorId!: string;
+    @Field(() => Int, {nullable:true})
+    favoritesCount?: number;
 
-  @Field(() => Boolean, { nullable: true })
-  active?: boolean;
+    @Field(() => String, {nullable:false})
+    authorId!: string;
 
-  @Field(() => TagUncheckedCreateNestedManyWithoutArticlesInput, { nullable: true })
-  tags?: TagUncheckedCreateNestedManyWithoutArticlesInput;
+    @Field(() => Boolean, {nullable:true})
+    active?: boolean;
 
-  @Field(() => CommentUncheckedCreateNestedManyWithoutArticleInput, { nullable: true })
-  @Type(() => CommentUncheckedCreateNestedManyWithoutArticleInput)
-  comments?: CommentUncheckedCreateNestedManyWithoutArticleInput;
+    @Field(() => TagUncheckedCreateNestedManyWithoutArticlesInput, {nullable:true})
+    tags?: TagUncheckedCreateNestedManyWithoutArticlesInput;
+
+    @Field(() => CommentUncheckedCreateNestedManyWithoutArticleInput, {nullable:true})
+    @Type(() => CommentUncheckedCreateNestedManyWithoutArticleInput)
+    comments?: CommentUncheckedCreateNestedManyWithoutArticleInput;
 }
diff --git a/@generated/article/article-unchecked-create-without-tags.input.ts b/@generated/article/article-unchecked-create-without-tags.input.ts
index 25a095d0..9398aa0d 100644
--- a/@generated/article/article-unchecked-create-without-tags.input.ts
+++ b/@generated/article/article-unchecked-create-without-tags.input.ts
@@ -8,43 +8,42 @@ import { CommentUncheckedCreateNestedManyWithoutArticleInput } from '../comment/
 
 @InputType()
 export class ArticleUncheckedCreateWithoutTagsInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => String, { nullable: false })
-  slug!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: false })
-  title!: string;
+    @Field(() => String, {nullable:false})
+    slug!: string;
 
-  @Field(() => String, { nullable: false })
-  description!: string;
+    @Field(() => String, {nullable:false})
+    title!: string;
 
-  @Field(() => String, { nullable: false })
-  body!: string;
+    @Field(() => String, {nullable:false})
+    description!: string;
 
-  @HideField()
-  createdAt?: Date | string;
+    @Field(() => String, {nullable:false})
+    body!: string;
 
-  @Field(() => Date, { nullable: true })
-  updatedAt?: Date | string;
+    @HideField()
+    createdAt?: Date | string;
 
-  @Field(() => Int, { nullable: true })
-  favoritesCount?: number;
+    @Field(() => Date, {nullable:true})
+    updatedAt?: Date | string;
 
-  @Field(() => String, { nullable: false })
-  authorId!: string;
+    @Field(() => Int, {nullable:true})
+    favoritesCount?: number;
 
-  @Field(() => Boolean, { nullable: true })
-  active?: boolean;
+    @Field(() => String, {nullable:false})
+    authorId!: string;
 
-  @Field(() => UserUncheckedCreateNestedManyWithoutFavoriteArticlesInput, {
-    nullable: true,
-  })
-  @Type(() => UserUncheckedCreateNestedManyWithoutFavoriteArticlesInput)
-  favoritedBy?: UserUncheckedCreateNestedManyWithoutFavoriteArticlesInput;
+    @Field(() => Boolean, {nullable:true})
+    active?: boolean;
 
-  @Field(() => CommentUncheckedCreateNestedManyWithoutArticleInput, { nullable: true })
-  @Type(() => CommentUncheckedCreateNestedManyWithoutArticleInput)
-  comments?: CommentUncheckedCreateNestedManyWithoutArticleInput;
+    @Field(() => UserUncheckedCreateNestedManyWithoutFavoriteArticlesInput, {nullable:true})
+    @Type(() => UserUncheckedCreateNestedManyWithoutFavoriteArticlesInput)
+    favoritedBy?: UserUncheckedCreateNestedManyWithoutFavoriteArticlesInput;
+
+    @Field(() => CommentUncheckedCreateNestedManyWithoutArticleInput, {nullable:true})
+    @Type(() => CommentUncheckedCreateNestedManyWithoutArticleInput)
+    comments?: CommentUncheckedCreateNestedManyWithoutArticleInput;
 }
diff --git a/@generated/article/article-unchecked-create.input.ts b/@generated/article/article-unchecked-create.input.ts
index 4a875acc..a74d3e65 100644
--- a/@generated/article/article-unchecked-create.input.ts
+++ b/@generated/article/article-unchecked-create.input.ts
@@ -9,46 +9,45 @@ import { CommentUncheckedCreateNestedManyWithoutArticleInput } from '../comment/
 
 @InputType()
 export class ArticleUncheckedCreateInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => String, { nullable: false })
-  slug!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: false })
-  title!: string;
+    @Field(() => String, {nullable:false})
+    slug!: string;
 
-  @Field(() => String, { nullable: false })
-  description!: string;
+    @Field(() => String, {nullable:false})
+    title!: string;
 
-  @Field(() => String, { nullable: false })
-  body!: string;
+    @Field(() => String, {nullable:false})
+    description!: string;
 
-  @HideField()
-  createdAt?: Date | string;
+    @Field(() => String, {nullable:false})
+    body!: string;
 
-  @Field(() => Date, { nullable: true })
-  updatedAt?: Date | string;
+    @HideField()
+    createdAt?: Date | string;
 
-  @Field(() => Int, { nullable: true })
-  favoritesCount?: number;
+    @Field(() => Date, {nullable:true})
+    updatedAt?: Date | string;
 
-  @Field(() => String, { nullable: false })
-  authorId!: string;
+    @Field(() => Int, {nullable:true})
+    favoritesCount?: number;
 
-  @Field(() => Boolean, { nullable: true })
-  active?: boolean;
+    @Field(() => String, {nullable:false})
+    authorId!: string;
 
-  @Field(() => TagUncheckedCreateNestedManyWithoutArticlesInput, { nullable: true })
-  tags?: TagUncheckedCreateNestedManyWithoutArticlesInput;
+    @Field(() => Boolean, {nullable:true})
+    active?: boolean;
 
-  @Field(() => UserUncheckedCreateNestedManyWithoutFavoriteArticlesInput, {
-    nullable: true,
-  })
-  @Type(() => UserUncheckedCreateNestedManyWithoutFavoriteArticlesInput)
-  favoritedBy?: UserUncheckedCreateNestedManyWithoutFavoriteArticlesInput;
+    @Field(() => TagUncheckedCreateNestedManyWithoutArticlesInput, {nullable:true})
+    tags?: TagUncheckedCreateNestedManyWithoutArticlesInput;
 
-  @Field(() => CommentUncheckedCreateNestedManyWithoutArticleInput, { nullable: true })
-  @Type(() => CommentUncheckedCreateNestedManyWithoutArticleInput)
-  comments?: CommentUncheckedCreateNestedManyWithoutArticleInput;
+    @Field(() => UserUncheckedCreateNestedManyWithoutFavoriteArticlesInput, {nullable:true})
+    @Type(() => UserUncheckedCreateNestedManyWithoutFavoriteArticlesInput)
+    favoritedBy?: UserUncheckedCreateNestedManyWithoutFavoriteArticlesInput;
+
+    @Field(() => CommentUncheckedCreateNestedManyWithoutArticleInput, {nullable:true})
+    @Type(() => CommentUncheckedCreateNestedManyWithoutArticleInput)
+    comments?: CommentUncheckedCreateNestedManyWithoutArticleInput;
 }
diff --git a/@generated/article/article-unchecked-update-many-without-author-nested.input.ts b/@generated/article/article-unchecked-update-many-without-author-nested.input.ts
index 616cb227..0569bb4f 100644
--- a/@generated/article/article-unchecked-update-many-without-author-nested.input.ts
+++ b/@generated/article/article-unchecked-update-many-without-author-nested.input.ts
@@ -5,7 +5,7 @@ import { Type } from 'class-transformer';
 import { ArticleCreateOrConnectWithoutAuthorInput } from './article-create-or-connect-without-author.input';
 import { ArticleUpsertWithWhereUniqueWithoutAuthorInput } from './article-upsert-with-where-unique-without-author.input';
 import { ArticleCreateManyAuthorInputEnvelope } from './article-create-many-author-input-envelope.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 import { ArticleUpdateWithWhereUniqueWithoutAuthorInput } from './article-update-with-where-unique-without-author.input';
 import { ArticleUpdateManyWithWhereWithoutAuthorInput } from './article-update-many-with-where-without-author.input';
@@ -13,47 +13,48 @@ import { ArticleScalarWhereInput } from './article-scalar-where.input';
 
 @InputType()
 export class ArticleUncheckedUpdateManyWithoutAuthorNestedInput {
-  @Field(() => [ArticleCreateWithoutAuthorInput], { nullable: true })
-  @Type(() => ArticleCreateWithoutAuthorInput)
-  create?: Array<ArticleCreateWithoutAuthorInput>;
 
-  @Field(() => [ArticleCreateOrConnectWithoutAuthorInput], { nullable: true })
-  @Type(() => ArticleCreateOrConnectWithoutAuthorInput)
-  connectOrCreate?: Array<ArticleCreateOrConnectWithoutAuthorInput>;
+    @Field(() => [ArticleCreateWithoutAuthorInput], {nullable:true})
+    @Type(() => ArticleCreateWithoutAuthorInput)
+    create?: Array<ArticleCreateWithoutAuthorInput>;
 
-  @Field(() => [ArticleUpsertWithWhereUniqueWithoutAuthorInput], { nullable: true })
-  @Type(() => ArticleUpsertWithWhereUniqueWithoutAuthorInput)
-  upsert?: Array<ArticleUpsertWithWhereUniqueWithoutAuthorInput>;
+    @Field(() => [ArticleCreateOrConnectWithoutAuthorInput], {nullable:true})
+    @Type(() => ArticleCreateOrConnectWithoutAuthorInput)
+    connectOrCreate?: Array<ArticleCreateOrConnectWithoutAuthorInput>;
 
-  @Field(() => ArticleCreateManyAuthorInputEnvelope, { nullable: true })
-  @Type(() => ArticleCreateManyAuthorInputEnvelope)
-  createMany?: ArticleCreateManyAuthorInputEnvelope;
+    @Field(() => [ArticleUpsertWithWhereUniqueWithoutAuthorInput], {nullable:true})
+    @Type(() => ArticleUpsertWithWhereUniqueWithoutAuthorInput)
+    upsert?: Array<ArticleUpsertWithWhereUniqueWithoutAuthorInput>;
 
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  set?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+    @Field(() => ArticleCreateManyAuthorInputEnvelope, {nullable:true})
+    @Type(() => ArticleCreateManyAuthorInputEnvelope)
+    createMany?: ArticleCreateManyAuthorInputEnvelope;
 
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  disconnect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    set?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
 
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  delete?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    disconnect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
 
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  connect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    delete?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
 
-  @Field(() => [ArticleUpdateWithWhereUniqueWithoutAuthorInput], { nullable: true })
-  @Type(() => ArticleUpdateWithWhereUniqueWithoutAuthorInput)
-  update?: Array<ArticleUpdateWithWhereUniqueWithoutAuthorInput>;
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
 
-  @Field(() => [ArticleUpdateManyWithWhereWithoutAuthorInput], { nullable: true })
-  @Type(() => ArticleUpdateManyWithWhereWithoutAuthorInput)
-  updateMany?: Array<ArticleUpdateManyWithWhereWithoutAuthorInput>;
+    @Field(() => [ArticleUpdateWithWhereUniqueWithoutAuthorInput], {nullable:true})
+    @Type(() => ArticleUpdateWithWhereUniqueWithoutAuthorInput)
+    update?: Array<ArticleUpdateWithWhereUniqueWithoutAuthorInput>;
 
-  @Field(() => [ArticleScalarWhereInput], { nullable: true })
-  @Type(() => ArticleScalarWhereInput)
-  deleteMany?: Array<ArticleScalarWhereInput>;
+    @Field(() => [ArticleUpdateManyWithWhereWithoutAuthorInput], {nullable:true})
+    @Type(() => ArticleUpdateManyWithWhereWithoutAuthorInput)
+    updateMany?: Array<ArticleUpdateManyWithWhereWithoutAuthorInput>;
+
+    @Field(() => [ArticleScalarWhereInput], {nullable:true})
+    @Type(() => ArticleScalarWhereInput)
+    deleteMany?: Array<ArticleScalarWhereInput>;
 }
diff --git a/@generated/article/article-unchecked-update-many-without-author.input.ts b/@generated/article/article-unchecked-update-many-without-author.input.ts
index 15e8e036..a5a8c7d8 100644
--- a/@generated/article/article-unchecked-update-many-without-author.input.ts
+++ b/@generated/article/article-unchecked-update-many-without-author.input.ts
@@ -7,30 +7,31 @@ import { NullableBoolFieldUpdateOperationsInput } from '../prisma/nullable-bool-
 
 @InputType()
 export class ArticleUncheckedUpdateManyWithoutAuthorInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  slug?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  title?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    slug?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  description?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    title?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  body?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    description?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  createdAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    body?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  updatedAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    createdAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => IntFieldUpdateOperationsInput, { nullable: true })
-  favoritesCount?: IntFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    updatedAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => NullableBoolFieldUpdateOperationsInput, { nullable: true })
-  active?: NullableBoolFieldUpdateOperationsInput;
+    @Field(() => IntFieldUpdateOperationsInput, {nullable:true})
+    favoritesCount?: IntFieldUpdateOperationsInput;
+
+    @Field(() => NullableBoolFieldUpdateOperationsInput, {nullable:true})
+    active?: NullableBoolFieldUpdateOperationsInput;
 }
diff --git a/@generated/article/article-unchecked-update-many-without-favorited-by-nested.input.ts b/@generated/article/article-unchecked-update-many-without-favorited-by-nested.input.ts
index 1efab459..89e9f812 100644
--- a/@generated/article/article-unchecked-update-many-without-favorited-by-nested.input.ts
+++ b/@generated/article/article-unchecked-update-many-without-favorited-by-nested.input.ts
@@ -4,7 +4,7 @@ import { ArticleCreateWithoutFavoritedByInput } from './article-create-without-f
 import { Type } from 'class-transformer';
 import { ArticleCreateOrConnectWithoutFavoritedByInput } from './article-create-or-connect-without-favorited-by.input';
 import { ArticleUpsertWithWhereUniqueWithoutFavoritedByInput } from './article-upsert-with-where-unique-without-favorited-by.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 import { ArticleUpdateWithWhereUniqueWithoutFavoritedByInput } from './article-update-with-where-unique-without-favorited-by.input';
 import { ArticleUpdateManyWithWhereWithoutFavoritedByInput } from './article-update-many-with-where-without-favorited-by.input';
@@ -12,47 +12,44 @@ import { ArticleScalarWhereInput } from './article-scalar-where.input';
 
 @InputType()
 export class ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput {
-  @Field(() => [ArticleCreateWithoutFavoritedByInput], { nullable: true })
-  @Type(() => ArticleCreateWithoutFavoritedByInput)
-  create?: Array<ArticleCreateWithoutFavoritedByInput>;
-
-  @Field(() => [ArticleCreateOrConnectWithoutFavoritedByInput], { nullable: true })
-  @Type(() => ArticleCreateOrConnectWithoutFavoritedByInput)
-  connectOrCreate?: Array<ArticleCreateOrConnectWithoutFavoritedByInput>;
-
-  @Field(() => [ArticleUpsertWithWhereUniqueWithoutFavoritedByInput], {
-    nullable: true,
-  })
-  @Type(() => ArticleUpsertWithWhereUniqueWithoutFavoritedByInput)
-  upsert?: Array<ArticleUpsertWithWhereUniqueWithoutFavoritedByInput>;
-
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  set?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
-
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  disconnect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
-
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  delete?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
-
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  connect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
-
-  @Field(() => [ArticleUpdateWithWhereUniqueWithoutFavoritedByInput], {
-    nullable: true,
-  })
-  @Type(() => ArticleUpdateWithWhereUniqueWithoutFavoritedByInput)
-  update?: Array<ArticleUpdateWithWhereUniqueWithoutFavoritedByInput>;
-
-  @Field(() => [ArticleUpdateManyWithWhereWithoutFavoritedByInput], { nullable: true })
-  @Type(() => ArticleUpdateManyWithWhereWithoutFavoritedByInput)
-  updateMany?: Array<ArticleUpdateManyWithWhereWithoutFavoritedByInput>;
-
-  @Field(() => [ArticleScalarWhereInput], { nullable: true })
-  @Type(() => ArticleScalarWhereInput)
-  deleteMany?: Array<ArticleScalarWhereInput>;
+
+    @Field(() => [ArticleCreateWithoutFavoritedByInput], {nullable:true})
+    @Type(() => ArticleCreateWithoutFavoritedByInput)
+    create?: Array<ArticleCreateWithoutFavoritedByInput>;
+
+    @Field(() => [ArticleCreateOrConnectWithoutFavoritedByInput], {nullable:true})
+    @Type(() => ArticleCreateOrConnectWithoutFavoritedByInput)
+    connectOrCreate?: Array<ArticleCreateOrConnectWithoutFavoritedByInput>;
+
+    @Field(() => [ArticleUpsertWithWhereUniqueWithoutFavoritedByInput], {nullable:true})
+    @Type(() => ArticleUpsertWithWhereUniqueWithoutFavoritedByInput)
+    upsert?: Array<ArticleUpsertWithWhereUniqueWithoutFavoritedByInput>;
+
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    set?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    disconnect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    delete?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+
+    @Field(() => [ArticleUpdateWithWhereUniqueWithoutFavoritedByInput], {nullable:true})
+    @Type(() => ArticleUpdateWithWhereUniqueWithoutFavoritedByInput)
+    update?: Array<ArticleUpdateWithWhereUniqueWithoutFavoritedByInput>;
+
+    @Field(() => [ArticleUpdateManyWithWhereWithoutFavoritedByInput], {nullable:true})
+    @Type(() => ArticleUpdateManyWithWhereWithoutFavoritedByInput)
+    updateMany?: Array<ArticleUpdateManyWithWhereWithoutFavoritedByInput>;
+
+    @Field(() => [ArticleScalarWhereInput], {nullable:true})
+    @Type(() => ArticleScalarWhereInput)
+    deleteMany?: Array<ArticleScalarWhereInput>;
 }
diff --git a/@generated/article/article-unchecked-update-many-without-favorited-by.input.ts b/@generated/article/article-unchecked-update-many-without-favorited-by.input.ts
index 62cbc923..9568c278 100644
--- a/@generated/article/article-unchecked-update-many-without-favorited-by.input.ts
+++ b/@generated/article/article-unchecked-update-many-without-favorited-by.input.ts
@@ -7,33 +7,34 @@ import { NullableBoolFieldUpdateOperationsInput } from '../prisma/nullable-bool-
 
 @InputType()
 export class ArticleUncheckedUpdateManyWithoutFavoritedByInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  slug?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  title?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    slug?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  description?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    title?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  body?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    description?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  createdAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    body?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  updatedAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    createdAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => IntFieldUpdateOperationsInput, { nullable: true })
-  favoritesCount?: IntFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    updatedAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  authorId?: StringFieldUpdateOperationsInput;
+    @Field(() => IntFieldUpdateOperationsInput, {nullable:true})
+    favoritesCount?: IntFieldUpdateOperationsInput;
 
-  @Field(() => NullableBoolFieldUpdateOperationsInput, { nullable: true })
-  active?: NullableBoolFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    authorId?: StringFieldUpdateOperationsInput;
+
+    @Field(() => NullableBoolFieldUpdateOperationsInput, {nullable:true})
+    active?: NullableBoolFieldUpdateOperationsInput;
 }
diff --git a/@generated/article/article-unchecked-update-many-without-tags-nested.input.ts b/@generated/article/article-unchecked-update-many-without-tags-nested.input.ts
index fd056891..5b899725 100644
--- a/@generated/article/article-unchecked-update-many-without-tags-nested.input.ts
+++ b/@generated/article/article-unchecked-update-many-without-tags-nested.input.ts
@@ -4,7 +4,7 @@ import { ArticleCreateWithoutTagsInput } from './article-create-without-tags.inp
 import { Type } from 'class-transformer';
 import { ArticleCreateOrConnectWithoutTagsInput } from './article-create-or-connect-without-tags.input';
 import { ArticleUpsertWithWhereUniqueWithoutTagsInput } from './article-upsert-with-where-unique-without-tags.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 import { ArticleUpdateWithWhereUniqueWithoutTagsInput } from './article-update-with-where-unique-without-tags.input';
 import { ArticleUpdateManyWithWhereWithoutTagsInput } from './article-update-many-with-where-without-tags.input';
@@ -12,43 +12,44 @@ import { ArticleScalarWhereInput } from './article-scalar-where.input';
 
 @InputType()
 export class ArticleUncheckedUpdateManyWithoutTagsNestedInput {
-  @Field(() => [ArticleCreateWithoutTagsInput], { nullable: true })
-  @Type(() => ArticleCreateWithoutTagsInput)
-  create?: Array<ArticleCreateWithoutTagsInput>;
 
-  @Field(() => [ArticleCreateOrConnectWithoutTagsInput], { nullable: true })
-  @Type(() => ArticleCreateOrConnectWithoutTagsInput)
-  connectOrCreate?: Array<ArticleCreateOrConnectWithoutTagsInput>;
+    @Field(() => [ArticleCreateWithoutTagsInput], {nullable:true})
+    @Type(() => ArticleCreateWithoutTagsInput)
+    create?: Array<ArticleCreateWithoutTagsInput>;
 
-  @Field(() => [ArticleUpsertWithWhereUniqueWithoutTagsInput], { nullable: true })
-  @Type(() => ArticleUpsertWithWhereUniqueWithoutTagsInput)
-  upsert?: Array<ArticleUpsertWithWhereUniqueWithoutTagsInput>;
+    @Field(() => [ArticleCreateOrConnectWithoutTagsInput], {nullable:true})
+    @Type(() => ArticleCreateOrConnectWithoutTagsInput)
+    connectOrCreate?: Array<ArticleCreateOrConnectWithoutTagsInput>;
 
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  set?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+    @Field(() => [ArticleUpsertWithWhereUniqueWithoutTagsInput], {nullable:true})
+    @Type(() => ArticleUpsertWithWhereUniqueWithoutTagsInput)
+    upsert?: Array<ArticleUpsertWithWhereUniqueWithoutTagsInput>;
 
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  disconnect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    set?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
 
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  delete?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    disconnect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
 
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  connect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    delete?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
 
-  @Field(() => [ArticleUpdateWithWhereUniqueWithoutTagsInput], { nullable: true })
-  @Type(() => ArticleUpdateWithWhereUniqueWithoutTagsInput)
-  update?: Array<ArticleUpdateWithWhereUniqueWithoutTagsInput>;
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
 
-  @Field(() => [ArticleUpdateManyWithWhereWithoutTagsInput], { nullable: true })
-  @Type(() => ArticleUpdateManyWithWhereWithoutTagsInput)
-  updateMany?: Array<ArticleUpdateManyWithWhereWithoutTagsInput>;
+    @Field(() => [ArticleUpdateWithWhereUniqueWithoutTagsInput], {nullable:true})
+    @Type(() => ArticleUpdateWithWhereUniqueWithoutTagsInput)
+    update?: Array<ArticleUpdateWithWhereUniqueWithoutTagsInput>;
 
-  @Field(() => [ArticleScalarWhereInput], { nullable: true })
-  @Type(() => ArticleScalarWhereInput)
-  deleteMany?: Array<ArticleScalarWhereInput>;
+    @Field(() => [ArticleUpdateManyWithWhereWithoutTagsInput], {nullable:true})
+    @Type(() => ArticleUpdateManyWithWhereWithoutTagsInput)
+    updateMany?: Array<ArticleUpdateManyWithWhereWithoutTagsInput>;
+
+    @Field(() => [ArticleScalarWhereInput], {nullable:true})
+    @Type(() => ArticleScalarWhereInput)
+    deleteMany?: Array<ArticleScalarWhereInput>;
 }
diff --git a/@generated/article/article-unchecked-update-many-without-tags.input.ts b/@generated/article/article-unchecked-update-many-without-tags.input.ts
index e04be714..2ea6019e 100644
--- a/@generated/article/article-unchecked-update-many-without-tags.input.ts
+++ b/@generated/article/article-unchecked-update-many-without-tags.input.ts
@@ -7,33 +7,34 @@ import { NullableBoolFieldUpdateOperationsInput } from '../prisma/nullable-bool-
 
 @InputType()
 export class ArticleUncheckedUpdateManyWithoutTagsInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  slug?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  title?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    slug?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  description?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    title?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  body?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    description?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  createdAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    body?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  updatedAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    createdAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => IntFieldUpdateOperationsInput, { nullable: true })
-  favoritesCount?: IntFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    updatedAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  authorId?: StringFieldUpdateOperationsInput;
+    @Field(() => IntFieldUpdateOperationsInput, {nullable:true})
+    favoritesCount?: IntFieldUpdateOperationsInput;
 
-  @Field(() => NullableBoolFieldUpdateOperationsInput, { nullable: true })
-  active?: NullableBoolFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    authorId?: StringFieldUpdateOperationsInput;
+
+    @Field(() => NullableBoolFieldUpdateOperationsInput, {nullable:true})
+    active?: NullableBoolFieldUpdateOperationsInput;
 }
diff --git a/@generated/article/article-unchecked-update-many.input.ts b/@generated/article/article-unchecked-update-many.input.ts
index 3ee82daa..ebb20e31 100644
--- a/@generated/article/article-unchecked-update-many.input.ts
+++ b/@generated/article/article-unchecked-update-many.input.ts
@@ -7,33 +7,34 @@ import { NullableBoolFieldUpdateOperationsInput } from '../prisma/nullable-bool-
 
 @InputType()
 export class ArticleUncheckedUpdateManyInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  slug?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  title?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    slug?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  description?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    title?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  body?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    description?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  createdAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    body?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  updatedAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    createdAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => IntFieldUpdateOperationsInput, { nullable: true })
-  favoritesCount?: IntFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    updatedAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  authorId?: StringFieldUpdateOperationsInput;
+    @Field(() => IntFieldUpdateOperationsInput, {nullable:true})
+    favoritesCount?: IntFieldUpdateOperationsInput;
 
-  @Field(() => NullableBoolFieldUpdateOperationsInput, { nullable: true })
-  active?: NullableBoolFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    authorId?: StringFieldUpdateOperationsInput;
+
+    @Field(() => NullableBoolFieldUpdateOperationsInput, {nullable:true})
+    active?: NullableBoolFieldUpdateOperationsInput;
 }
diff --git a/@generated/article/article-unchecked-update-without-author.input.ts b/@generated/article/article-unchecked-update-without-author.input.ts
index ac2c7025..1bd78905 100644
--- a/@generated/article/article-unchecked-update-without-author.input.ts
+++ b/@generated/article/article-unchecked-update-without-author.input.ts
@@ -11,43 +11,42 @@ import { CommentUncheckedUpdateManyWithoutArticleNestedInput } from '../comment/
 
 @InputType()
 export class ArticleUncheckedUpdateWithoutAuthorInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  slug?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  title?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    slug?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  description?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    title?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  body?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    description?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  createdAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    body?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  updatedAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    createdAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => IntFieldUpdateOperationsInput, { nullable: true })
-  favoritesCount?: IntFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    updatedAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => NullableBoolFieldUpdateOperationsInput, { nullable: true })
-  active?: NullableBoolFieldUpdateOperationsInput;
+    @Field(() => IntFieldUpdateOperationsInput, {nullable:true})
+    favoritesCount?: IntFieldUpdateOperationsInput;
 
-  @Field(() => TagUncheckedUpdateManyWithoutArticlesNestedInput, { nullable: true })
-  tags?: TagUncheckedUpdateManyWithoutArticlesNestedInput;
+    @Field(() => NullableBoolFieldUpdateOperationsInput, {nullable:true})
+    active?: NullableBoolFieldUpdateOperationsInput;
 
-  @Field(() => UserUncheckedUpdateManyWithoutFavoriteArticlesNestedInput, {
-    nullable: true,
-  })
-  @Type(() => UserUncheckedUpdateManyWithoutFavoriteArticlesNestedInput)
-  favoritedBy?: UserUncheckedUpdateManyWithoutFavoriteArticlesNestedInput;
+    @Field(() => TagUncheckedUpdateManyWithoutArticlesNestedInput, {nullable:true})
+    tags?: TagUncheckedUpdateManyWithoutArticlesNestedInput;
 
-  @Field(() => CommentUncheckedUpdateManyWithoutArticleNestedInput, { nullable: true })
-  @Type(() => CommentUncheckedUpdateManyWithoutArticleNestedInput)
-  comments?: CommentUncheckedUpdateManyWithoutArticleNestedInput;
+    @Field(() => UserUncheckedUpdateManyWithoutFavoriteArticlesNestedInput, {nullable:true})
+    @Type(() => UserUncheckedUpdateManyWithoutFavoriteArticlesNestedInput)
+    favoritedBy?: UserUncheckedUpdateManyWithoutFavoriteArticlesNestedInput;
+
+    @Field(() => CommentUncheckedUpdateManyWithoutArticleNestedInput, {nullable:true})
+    @Type(() => CommentUncheckedUpdateManyWithoutArticleNestedInput)
+    comments?: CommentUncheckedUpdateManyWithoutArticleNestedInput;
 }
diff --git a/@generated/article/article-unchecked-update-without-comments.input.ts b/@generated/article/article-unchecked-update-without-comments.input.ts
index 4d66b550..27cf6458 100644
--- a/@generated/article/article-unchecked-update-without-comments.input.ts
+++ b/@generated/article/article-unchecked-update-without-comments.input.ts
@@ -10,42 +10,41 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class ArticleUncheckedUpdateWithoutCommentsInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  slug?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  title?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    slug?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  description?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    title?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  body?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    description?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  createdAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    body?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  updatedAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    createdAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => IntFieldUpdateOperationsInput, { nullable: true })
-  favoritesCount?: IntFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    updatedAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  authorId?: StringFieldUpdateOperationsInput;
+    @Field(() => IntFieldUpdateOperationsInput, {nullable:true})
+    favoritesCount?: IntFieldUpdateOperationsInput;
 
-  @Field(() => NullableBoolFieldUpdateOperationsInput, { nullable: true })
-  active?: NullableBoolFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    authorId?: StringFieldUpdateOperationsInput;
 
-  @Field(() => TagUncheckedUpdateManyWithoutArticlesNestedInput, { nullable: true })
-  tags?: TagUncheckedUpdateManyWithoutArticlesNestedInput;
+    @Field(() => NullableBoolFieldUpdateOperationsInput, {nullable:true})
+    active?: NullableBoolFieldUpdateOperationsInput;
 
-  @Field(() => UserUncheckedUpdateManyWithoutFavoriteArticlesNestedInput, {
-    nullable: true,
-  })
-  @Type(() => UserUncheckedUpdateManyWithoutFavoriteArticlesNestedInput)
-  favoritedBy?: UserUncheckedUpdateManyWithoutFavoriteArticlesNestedInput;
+    @Field(() => TagUncheckedUpdateManyWithoutArticlesNestedInput, {nullable:true})
+    tags?: TagUncheckedUpdateManyWithoutArticlesNestedInput;
+
+    @Field(() => UserUncheckedUpdateManyWithoutFavoriteArticlesNestedInput, {nullable:true})
+    @Type(() => UserUncheckedUpdateManyWithoutFavoriteArticlesNestedInput)
+    favoritedBy?: UserUncheckedUpdateManyWithoutFavoriteArticlesNestedInput;
 }
diff --git a/@generated/article/article-unchecked-update-without-favorited-by.input.ts b/@generated/article/article-unchecked-update-without-favorited-by.input.ts
index 0b9e5606..ddf9d208 100644
--- a/@generated/article/article-unchecked-update-without-favorited-by.input.ts
+++ b/@generated/article/article-unchecked-update-without-favorited-by.input.ts
@@ -10,40 +10,41 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class ArticleUncheckedUpdateWithoutFavoritedByInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  slug?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  title?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    slug?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  description?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    title?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  body?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    description?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  createdAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    body?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  updatedAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    createdAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => IntFieldUpdateOperationsInput, { nullable: true })
-  favoritesCount?: IntFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    updatedAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  authorId?: StringFieldUpdateOperationsInput;
+    @Field(() => IntFieldUpdateOperationsInput, {nullable:true})
+    favoritesCount?: IntFieldUpdateOperationsInput;
 
-  @Field(() => NullableBoolFieldUpdateOperationsInput, { nullable: true })
-  active?: NullableBoolFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    authorId?: StringFieldUpdateOperationsInput;
 
-  @Field(() => TagUncheckedUpdateManyWithoutArticlesNestedInput, { nullable: true })
-  tags?: TagUncheckedUpdateManyWithoutArticlesNestedInput;
+    @Field(() => NullableBoolFieldUpdateOperationsInput, {nullable:true})
+    active?: NullableBoolFieldUpdateOperationsInput;
 
-  @Field(() => CommentUncheckedUpdateManyWithoutArticleNestedInput, { nullable: true })
-  @Type(() => CommentUncheckedUpdateManyWithoutArticleNestedInput)
-  comments?: CommentUncheckedUpdateManyWithoutArticleNestedInput;
+    @Field(() => TagUncheckedUpdateManyWithoutArticlesNestedInput, {nullable:true})
+    tags?: TagUncheckedUpdateManyWithoutArticlesNestedInput;
+
+    @Field(() => CommentUncheckedUpdateManyWithoutArticleNestedInput, {nullable:true})
+    @Type(() => CommentUncheckedUpdateManyWithoutArticleNestedInput)
+    comments?: CommentUncheckedUpdateManyWithoutArticleNestedInput;
 }
diff --git a/@generated/article/article-unchecked-update-without-tags.input.ts b/@generated/article/article-unchecked-update-without-tags.input.ts
index 209e7dca..3e13298e 100644
--- a/@generated/article/article-unchecked-update-without-tags.input.ts
+++ b/@generated/article/article-unchecked-update-without-tags.input.ts
@@ -10,43 +10,42 @@ import { CommentUncheckedUpdateManyWithoutArticleNestedInput } from '../comment/
 
 @InputType()
 export class ArticleUncheckedUpdateWithoutTagsInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  slug?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  title?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    slug?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  description?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    title?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  body?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    description?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  createdAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    body?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  updatedAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    createdAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => IntFieldUpdateOperationsInput, { nullable: true })
-  favoritesCount?: IntFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    updatedAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  authorId?: StringFieldUpdateOperationsInput;
+    @Field(() => IntFieldUpdateOperationsInput, {nullable:true})
+    favoritesCount?: IntFieldUpdateOperationsInput;
 
-  @Field(() => NullableBoolFieldUpdateOperationsInput, { nullable: true })
-  active?: NullableBoolFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    authorId?: StringFieldUpdateOperationsInput;
 
-  @Field(() => UserUncheckedUpdateManyWithoutFavoriteArticlesNestedInput, {
-    nullable: true,
-  })
-  @Type(() => UserUncheckedUpdateManyWithoutFavoriteArticlesNestedInput)
-  favoritedBy?: UserUncheckedUpdateManyWithoutFavoriteArticlesNestedInput;
+    @Field(() => NullableBoolFieldUpdateOperationsInput, {nullable:true})
+    active?: NullableBoolFieldUpdateOperationsInput;
 
-  @Field(() => CommentUncheckedUpdateManyWithoutArticleNestedInput, { nullable: true })
-  @Type(() => CommentUncheckedUpdateManyWithoutArticleNestedInput)
-  comments?: CommentUncheckedUpdateManyWithoutArticleNestedInput;
+    @Field(() => UserUncheckedUpdateManyWithoutFavoriteArticlesNestedInput, {nullable:true})
+    @Type(() => UserUncheckedUpdateManyWithoutFavoriteArticlesNestedInput)
+    favoritedBy?: UserUncheckedUpdateManyWithoutFavoriteArticlesNestedInput;
+
+    @Field(() => CommentUncheckedUpdateManyWithoutArticleNestedInput, {nullable:true})
+    @Type(() => CommentUncheckedUpdateManyWithoutArticleNestedInput)
+    comments?: CommentUncheckedUpdateManyWithoutArticleNestedInput;
 }
diff --git a/@generated/article/article-unchecked-update.input.ts b/@generated/article/article-unchecked-update.input.ts
index 8cf9af61..fe2eeacb 100644
--- a/@generated/article/article-unchecked-update.input.ts
+++ b/@generated/article/article-unchecked-update.input.ts
@@ -11,46 +11,45 @@ import { CommentUncheckedUpdateManyWithoutArticleNestedInput } from '../comment/
 
 @InputType()
 export class ArticleUncheckedUpdateInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  slug?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  title?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    slug?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  description?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    title?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  body?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    description?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  createdAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    body?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  updatedAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    createdAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => IntFieldUpdateOperationsInput, { nullable: true })
-  favoritesCount?: IntFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    updatedAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  authorId?: StringFieldUpdateOperationsInput;
+    @Field(() => IntFieldUpdateOperationsInput, {nullable:true})
+    favoritesCount?: IntFieldUpdateOperationsInput;
 
-  @Field(() => NullableBoolFieldUpdateOperationsInput, { nullable: true })
-  active?: NullableBoolFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    authorId?: StringFieldUpdateOperationsInput;
 
-  @Field(() => TagUncheckedUpdateManyWithoutArticlesNestedInput, { nullable: true })
-  tags?: TagUncheckedUpdateManyWithoutArticlesNestedInput;
+    @Field(() => NullableBoolFieldUpdateOperationsInput, {nullable:true})
+    active?: NullableBoolFieldUpdateOperationsInput;
 
-  @Field(() => UserUncheckedUpdateManyWithoutFavoriteArticlesNestedInput, {
-    nullable: true,
-  })
-  @Type(() => UserUncheckedUpdateManyWithoutFavoriteArticlesNestedInput)
-  favoritedBy?: UserUncheckedUpdateManyWithoutFavoriteArticlesNestedInput;
+    @Field(() => TagUncheckedUpdateManyWithoutArticlesNestedInput, {nullable:true})
+    tags?: TagUncheckedUpdateManyWithoutArticlesNestedInput;
 
-  @Field(() => CommentUncheckedUpdateManyWithoutArticleNestedInput, { nullable: true })
-  @Type(() => CommentUncheckedUpdateManyWithoutArticleNestedInput)
-  comments?: CommentUncheckedUpdateManyWithoutArticleNestedInput;
+    @Field(() => UserUncheckedUpdateManyWithoutFavoriteArticlesNestedInput, {nullable:true})
+    @Type(() => UserUncheckedUpdateManyWithoutFavoriteArticlesNestedInput)
+    favoritedBy?: UserUncheckedUpdateManyWithoutFavoriteArticlesNestedInput;
+
+    @Field(() => CommentUncheckedUpdateManyWithoutArticleNestedInput, {nullable:true})
+    @Type(() => CommentUncheckedUpdateManyWithoutArticleNestedInput)
+    comments?: CommentUncheckedUpdateManyWithoutArticleNestedInput;
 }
diff --git a/@generated/article/article-update-many-mutation.input.ts b/@generated/article/article-update-many-mutation.input.ts
index e45daa8f..ea27d041 100644
--- a/@generated/article/article-update-many-mutation.input.ts
+++ b/@generated/article/article-update-many-mutation.input.ts
@@ -7,30 +7,31 @@ import { NullableBoolFieldUpdateOperationsInput } from '../prisma/nullable-bool-
 
 @InputType()
 export class ArticleUpdateManyMutationInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  slug?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  title?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    slug?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  description?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    title?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  body?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    description?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  createdAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    body?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  updatedAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    createdAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => IntFieldUpdateOperationsInput, { nullable: true })
-  favoritesCount?: IntFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    updatedAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => NullableBoolFieldUpdateOperationsInput, { nullable: true })
-  active?: NullableBoolFieldUpdateOperationsInput;
+    @Field(() => IntFieldUpdateOperationsInput, {nullable:true})
+    favoritesCount?: IntFieldUpdateOperationsInput;
+
+    @Field(() => NullableBoolFieldUpdateOperationsInput, {nullable:true})
+    active?: NullableBoolFieldUpdateOperationsInput;
 }
diff --git a/@generated/article/article-update-many-with-where-without-author.input.ts b/@generated/article/article-update-many-with-where-without-author.input.ts
index 436cbc80..f1a17f7d 100644
--- a/@generated/article/article-update-many-with-where-without-author.input.ts
+++ b/@generated/article/article-update-many-with-where-without-author.input.ts
@@ -6,11 +6,12 @@ import { ArticleUpdateManyMutationInput } from './article-update-many-mutation.i
 
 @InputType()
 export class ArticleUpdateManyWithWhereWithoutAuthorInput {
-  @Field(() => ArticleScalarWhereInput, { nullable: false })
-  @Type(() => ArticleScalarWhereInput)
-  where!: ArticleScalarWhereInput;
 
-  @Field(() => ArticleUpdateManyMutationInput, { nullable: false })
-  @Type(() => ArticleUpdateManyMutationInput)
-  data!: ArticleUpdateManyMutationInput;
+    @Field(() => ArticleScalarWhereInput, {nullable:false})
+    @Type(() => ArticleScalarWhereInput)
+    where!: ArticleScalarWhereInput;
+
+    @Field(() => ArticleUpdateManyMutationInput, {nullable:false})
+    @Type(() => ArticleUpdateManyMutationInput)
+    data!: ArticleUpdateManyMutationInput;
 }
diff --git a/@generated/article/article-update-many-with-where-without-favorited-by.input.ts b/@generated/article/article-update-many-with-where-without-favorited-by.input.ts
index 826049bb..2329ca33 100644
--- a/@generated/article/article-update-many-with-where-without-favorited-by.input.ts
+++ b/@generated/article/article-update-many-with-where-without-favorited-by.input.ts
@@ -6,11 +6,12 @@ import { ArticleUpdateManyMutationInput } from './article-update-many-mutation.i
 
 @InputType()
 export class ArticleUpdateManyWithWhereWithoutFavoritedByInput {
-  @Field(() => ArticleScalarWhereInput, { nullable: false })
-  @Type(() => ArticleScalarWhereInput)
-  where!: ArticleScalarWhereInput;
 
-  @Field(() => ArticleUpdateManyMutationInput, { nullable: false })
-  @Type(() => ArticleUpdateManyMutationInput)
-  data!: ArticleUpdateManyMutationInput;
+    @Field(() => ArticleScalarWhereInput, {nullable:false})
+    @Type(() => ArticleScalarWhereInput)
+    where!: ArticleScalarWhereInput;
+
+    @Field(() => ArticleUpdateManyMutationInput, {nullable:false})
+    @Type(() => ArticleUpdateManyMutationInput)
+    data!: ArticleUpdateManyMutationInput;
 }
diff --git a/@generated/article/article-update-many-with-where-without-tags.input.ts b/@generated/article/article-update-many-with-where-without-tags.input.ts
index 3b7c221c..1fe467ff 100644
--- a/@generated/article/article-update-many-with-where-without-tags.input.ts
+++ b/@generated/article/article-update-many-with-where-without-tags.input.ts
@@ -6,11 +6,12 @@ import { ArticleUpdateManyMutationInput } from './article-update-many-mutation.i
 
 @InputType()
 export class ArticleUpdateManyWithWhereWithoutTagsInput {
-  @Field(() => ArticleScalarWhereInput, { nullable: false })
-  @Type(() => ArticleScalarWhereInput)
-  where!: ArticleScalarWhereInput;
 
-  @Field(() => ArticleUpdateManyMutationInput, { nullable: false })
-  @Type(() => ArticleUpdateManyMutationInput)
-  data!: ArticleUpdateManyMutationInput;
+    @Field(() => ArticleScalarWhereInput, {nullable:false})
+    @Type(() => ArticleScalarWhereInput)
+    where!: ArticleScalarWhereInput;
+
+    @Field(() => ArticleUpdateManyMutationInput, {nullable:false})
+    @Type(() => ArticleUpdateManyMutationInput)
+    data!: ArticleUpdateManyMutationInput;
 }
diff --git a/@generated/article/article-update-many-without-author-nested.input.ts b/@generated/article/article-update-many-without-author-nested.input.ts
index f364dbc3..b9105622 100644
--- a/@generated/article/article-update-many-without-author-nested.input.ts
+++ b/@generated/article/article-update-many-without-author-nested.input.ts
@@ -5,7 +5,7 @@ import { Type } from 'class-transformer';
 import { ArticleCreateOrConnectWithoutAuthorInput } from './article-create-or-connect-without-author.input';
 import { ArticleUpsertWithWhereUniqueWithoutAuthorInput } from './article-upsert-with-where-unique-without-author.input';
 import { ArticleCreateManyAuthorInputEnvelope } from './article-create-many-author-input-envelope.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 import { ArticleUpdateWithWhereUniqueWithoutAuthorInput } from './article-update-with-where-unique-without-author.input';
 import { ArticleUpdateManyWithWhereWithoutAuthorInput } from './article-update-many-with-where-without-author.input';
@@ -13,47 +13,48 @@ import { ArticleScalarWhereInput } from './article-scalar-where.input';
 
 @InputType()
 export class ArticleUpdateManyWithoutAuthorNestedInput {
-  @Field(() => [ArticleCreateWithoutAuthorInput], { nullable: true })
-  @Type(() => ArticleCreateWithoutAuthorInput)
-  create?: Array<ArticleCreateWithoutAuthorInput>;
 
-  @Field(() => [ArticleCreateOrConnectWithoutAuthorInput], { nullable: true })
-  @Type(() => ArticleCreateOrConnectWithoutAuthorInput)
-  connectOrCreate?: Array<ArticleCreateOrConnectWithoutAuthorInput>;
+    @Field(() => [ArticleCreateWithoutAuthorInput], {nullable:true})
+    @Type(() => ArticleCreateWithoutAuthorInput)
+    create?: Array<ArticleCreateWithoutAuthorInput>;
 
-  @Field(() => [ArticleUpsertWithWhereUniqueWithoutAuthorInput], { nullable: true })
-  @Type(() => ArticleUpsertWithWhereUniqueWithoutAuthorInput)
-  upsert?: Array<ArticleUpsertWithWhereUniqueWithoutAuthorInput>;
+    @Field(() => [ArticleCreateOrConnectWithoutAuthorInput], {nullable:true})
+    @Type(() => ArticleCreateOrConnectWithoutAuthorInput)
+    connectOrCreate?: Array<ArticleCreateOrConnectWithoutAuthorInput>;
 
-  @Field(() => ArticleCreateManyAuthorInputEnvelope, { nullable: true })
-  @Type(() => ArticleCreateManyAuthorInputEnvelope)
-  createMany?: ArticleCreateManyAuthorInputEnvelope;
+    @Field(() => [ArticleUpsertWithWhereUniqueWithoutAuthorInput], {nullable:true})
+    @Type(() => ArticleUpsertWithWhereUniqueWithoutAuthorInput)
+    upsert?: Array<ArticleUpsertWithWhereUniqueWithoutAuthorInput>;
 
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  set?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+    @Field(() => ArticleCreateManyAuthorInputEnvelope, {nullable:true})
+    @Type(() => ArticleCreateManyAuthorInputEnvelope)
+    createMany?: ArticleCreateManyAuthorInputEnvelope;
 
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  disconnect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    set?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
 
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  delete?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    disconnect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
 
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  connect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    delete?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
 
-  @Field(() => [ArticleUpdateWithWhereUniqueWithoutAuthorInput], { nullable: true })
-  @Type(() => ArticleUpdateWithWhereUniqueWithoutAuthorInput)
-  update?: Array<ArticleUpdateWithWhereUniqueWithoutAuthorInput>;
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
 
-  @Field(() => [ArticleUpdateManyWithWhereWithoutAuthorInput], { nullable: true })
-  @Type(() => ArticleUpdateManyWithWhereWithoutAuthorInput)
-  updateMany?: Array<ArticleUpdateManyWithWhereWithoutAuthorInput>;
+    @Field(() => [ArticleUpdateWithWhereUniqueWithoutAuthorInput], {nullable:true})
+    @Type(() => ArticleUpdateWithWhereUniqueWithoutAuthorInput)
+    update?: Array<ArticleUpdateWithWhereUniqueWithoutAuthorInput>;
 
-  @Field(() => [ArticleScalarWhereInput], { nullable: true })
-  @Type(() => ArticleScalarWhereInput)
-  deleteMany?: Array<ArticleScalarWhereInput>;
+    @Field(() => [ArticleUpdateManyWithWhereWithoutAuthorInput], {nullable:true})
+    @Type(() => ArticleUpdateManyWithWhereWithoutAuthorInput)
+    updateMany?: Array<ArticleUpdateManyWithWhereWithoutAuthorInput>;
+
+    @Field(() => [ArticleScalarWhereInput], {nullable:true})
+    @Type(() => ArticleScalarWhereInput)
+    deleteMany?: Array<ArticleScalarWhereInput>;
 }
diff --git a/@generated/article/article-update-many-without-favorited-by-nested.input.ts b/@generated/article/article-update-many-without-favorited-by-nested.input.ts
index 8ff9c61c..da3b2955 100644
--- a/@generated/article/article-update-many-without-favorited-by-nested.input.ts
+++ b/@generated/article/article-update-many-without-favorited-by-nested.input.ts
@@ -4,7 +4,7 @@ import { ArticleCreateWithoutFavoritedByInput } from './article-create-without-f
 import { Type } from 'class-transformer';
 import { ArticleCreateOrConnectWithoutFavoritedByInput } from './article-create-or-connect-without-favorited-by.input';
 import { ArticleUpsertWithWhereUniqueWithoutFavoritedByInput } from './article-upsert-with-where-unique-without-favorited-by.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 import { ArticleUpdateWithWhereUniqueWithoutFavoritedByInput } from './article-update-with-where-unique-without-favorited-by.input';
 import { ArticleUpdateManyWithWhereWithoutFavoritedByInput } from './article-update-many-with-where-without-favorited-by.input';
@@ -12,47 +12,44 @@ import { ArticleScalarWhereInput } from './article-scalar-where.input';
 
 @InputType()
 export class ArticleUpdateManyWithoutFavoritedByNestedInput {
-  @Field(() => [ArticleCreateWithoutFavoritedByInput], { nullable: true })
-  @Type(() => ArticleCreateWithoutFavoritedByInput)
-  create?: Array<ArticleCreateWithoutFavoritedByInput>;
-
-  @Field(() => [ArticleCreateOrConnectWithoutFavoritedByInput], { nullable: true })
-  @Type(() => ArticleCreateOrConnectWithoutFavoritedByInput)
-  connectOrCreate?: Array<ArticleCreateOrConnectWithoutFavoritedByInput>;
-
-  @Field(() => [ArticleUpsertWithWhereUniqueWithoutFavoritedByInput], {
-    nullable: true,
-  })
-  @Type(() => ArticleUpsertWithWhereUniqueWithoutFavoritedByInput)
-  upsert?: Array<ArticleUpsertWithWhereUniqueWithoutFavoritedByInput>;
-
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  set?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
-
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  disconnect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
-
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  delete?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
-
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  connect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
-
-  @Field(() => [ArticleUpdateWithWhereUniqueWithoutFavoritedByInput], {
-    nullable: true,
-  })
-  @Type(() => ArticleUpdateWithWhereUniqueWithoutFavoritedByInput)
-  update?: Array<ArticleUpdateWithWhereUniqueWithoutFavoritedByInput>;
-
-  @Field(() => [ArticleUpdateManyWithWhereWithoutFavoritedByInput], { nullable: true })
-  @Type(() => ArticleUpdateManyWithWhereWithoutFavoritedByInput)
-  updateMany?: Array<ArticleUpdateManyWithWhereWithoutFavoritedByInput>;
-
-  @Field(() => [ArticleScalarWhereInput], { nullable: true })
-  @Type(() => ArticleScalarWhereInput)
-  deleteMany?: Array<ArticleScalarWhereInput>;
+
+    @Field(() => [ArticleCreateWithoutFavoritedByInput], {nullable:true})
+    @Type(() => ArticleCreateWithoutFavoritedByInput)
+    create?: Array<ArticleCreateWithoutFavoritedByInput>;
+
+    @Field(() => [ArticleCreateOrConnectWithoutFavoritedByInput], {nullable:true})
+    @Type(() => ArticleCreateOrConnectWithoutFavoritedByInput)
+    connectOrCreate?: Array<ArticleCreateOrConnectWithoutFavoritedByInput>;
+
+    @Field(() => [ArticleUpsertWithWhereUniqueWithoutFavoritedByInput], {nullable:true})
+    @Type(() => ArticleUpsertWithWhereUniqueWithoutFavoritedByInput)
+    upsert?: Array<ArticleUpsertWithWhereUniqueWithoutFavoritedByInput>;
+
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    set?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    disconnect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    delete?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+
+    @Field(() => [ArticleUpdateWithWhereUniqueWithoutFavoritedByInput], {nullable:true})
+    @Type(() => ArticleUpdateWithWhereUniqueWithoutFavoritedByInput)
+    update?: Array<ArticleUpdateWithWhereUniqueWithoutFavoritedByInput>;
+
+    @Field(() => [ArticleUpdateManyWithWhereWithoutFavoritedByInput], {nullable:true})
+    @Type(() => ArticleUpdateManyWithWhereWithoutFavoritedByInput)
+    updateMany?: Array<ArticleUpdateManyWithWhereWithoutFavoritedByInput>;
+
+    @Field(() => [ArticleScalarWhereInput], {nullable:true})
+    @Type(() => ArticleScalarWhereInput)
+    deleteMany?: Array<ArticleScalarWhereInput>;
 }
diff --git a/@generated/article/article-update-many-without-tags-nested.input.ts b/@generated/article/article-update-many-without-tags-nested.input.ts
index be7557fd..1a29dbe5 100644
--- a/@generated/article/article-update-many-without-tags-nested.input.ts
+++ b/@generated/article/article-update-many-without-tags-nested.input.ts
@@ -4,7 +4,7 @@ import { ArticleCreateWithoutTagsInput } from './article-create-without-tags.inp
 import { Type } from 'class-transformer';
 import { ArticleCreateOrConnectWithoutTagsInput } from './article-create-or-connect-without-tags.input';
 import { ArticleUpsertWithWhereUniqueWithoutTagsInput } from './article-upsert-with-where-unique-without-tags.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 import { ArticleUpdateWithWhereUniqueWithoutTagsInput } from './article-update-with-where-unique-without-tags.input';
 import { ArticleUpdateManyWithWhereWithoutTagsInput } from './article-update-many-with-where-without-tags.input';
@@ -12,43 +12,44 @@ import { ArticleScalarWhereInput } from './article-scalar-where.input';
 
 @InputType()
 export class ArticleUpdateManyWithoutTagsNestedInput {
-  @Field(() => [ArticleCreateWithoutTagsInput], { nullable: true })
-  @Type(() => ArticleCreateWithoutTagsInput)
-  create?: Array<ArticleCreateWithoutTagsInput>;
 
-  @Field(() => [ArticleCreateOrConnectWithoutTagsInput], { nullable: true })
-  @Type(() => ArticleCreateOrConnectWithoutTagsInput)
-  connectOrCreate?: Array<ArticleCreateOrConnectWithoutTagsInput>;
+    @Field(() => [ArticleCreateWithoutTagsInput], {nullable:true})
+    @Type(() => ArticleCreateWithoutTagsInput)
+    create?: Array<ArticleCreateWithoutTagsInput>;
 
-  @Field(() => [ArticleUpsertWithWhereUniqueWithoutTagsInput], { nullable: true })
-  @Type(() => ArticleUpsertWithWhereUniqueWithoutTagsInput)
-  upsert?: Array<ArticleUpsertWithWhereUniqueWithoutTagsInput>;
+    @Field(() => [ArticleCreateOrConnectWithoutTagsInput], {nullable:true})
+    @Type(() => ArticleCreateOrConnectWithoutTagsInput)
+    connectOrCreate?: Array<ArticleCreateOrConnectWithoutTagsInput>;
 
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  set?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+    @Field(() => [ArticleUpsertWithWhereUniqueWithoutTagsInput], {nullable:true})
+    @Type(() => ArticleUpsertWithWhereUniqueWithoutTagsInput)
+    upsert?: Array<ArticleUpsertWithWhereUniqueWithoutTagsInput>;
 
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  disconnect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    set?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
 
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  delete?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    disconnect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
 
-  @Field(() => [ArticleWhereUniqueInput], { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  connect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    delete?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
 
-  @Field(() => [ArticleUpdateWithWhereUniqueWithoutTagsInput], { nullable: true })
-  @Type(() => ArticleUpdateWithWhereUniqueWithoutTagsInput)
-  update?: Array<ArticleUpdateWithWhereUniqueWithoutTagsInput>;
+    @Field(() => [ArticleWhereUniqueInput], {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>>;
 
-  @Field(() => [ArticleUpdateManyWithWhereWithoutTagsInput], { nullable: true })
-  @Type(() => ArticleUpdateManyWithWhereWithoutTagsInput)
-  updateMany?: Array<ArticleUpdateManyWithWhereWithoutTagsInput>;
+    @Field(() => [ArticleUpdateWithWhereUniqueWithoutTagsInput], {nullable:true})
+    @Type(() => ArticleUpdateWithWhereUniqueWithoutTagsInput)
+    update?: Array<ArticleUpdateWithWhereUniqueWithoutTagsInput>;
 
-  @Field(() => [ArticleScalarWhereInput], { nullable: true })
-  @Type(() => ArticleScalarWhereInput)
-  deleteMany?: Array<ArticleScalarWhereInput>;
+    @Field(() => [ArticleUpdateManyWithWhereWithoutTagsInput], {nullable:true})
+    @Type(() => ArticleUpdateManyWithWhereWithoutTagsInput)
+    updateMany?: Array<ArticleUpdateManyWithWhereWithoutTagsInput>;
+
+    @Field(() => [ArticleScalarWhereInput], {nullable:true})
+    @Type(() => ArticleScalarWhereInput)
+    deleteMany?: Array<ArticleScalarWhereInput>;
 }
diff --git a/@generated/article/article-update-one-without-comments-nested.input.ts b/@generated/article/article-update-one-without-comments-nested.input.ts
index 21d1b328..46939b5e 100644
--- a/@generated/article/article-update-one-without-comments-nested.input.ts
+++ b/@generated/article/article-update-one-without-comments-nested.input.ts
@@ -5,37 +5,38 @@ import { Type } from 'class-transformer';
 import { ArticleCreateOrConnectWithoutCommentsInput } from './article-create-or-connect-without-comments.input';
 import { ArticleUpsertWithoutCommentsInput } from './article-upsert-without-comments.input';
 import { ArticleWhereInput } from './article-where.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 import { ArticleUpdateToOneWithWhereWithoutCommentsInput } from './article-update-to-one-with-where-without-comments.input';
 
 @InputType()
 export class ArticleUpdateOneWithoutCommentsNestedInput {
-  @Field(() => ArticleCreateWithoutCommentsInput, { nullable: true })
-  @Type(() => ArticleCreateWithoutCommentsInput)
-  create?: ArticleCreateWithoutCommentsInput;
 
-  @Field(() => ArticleCreateOrConnectWithoutCommentsInput, { nullable: true })
-  @Type(() => ArticleCreateOrConnectWithoutCommentsInput)
-  connectOrCreate?: ArticleCreateOrConnectWithoutCommentsInput;
+    @Field(() => ArticleCreateWithoutCommentsInput, {nullable:true})
+    @Type(() => ArticleCreateWithoutCommentsInput)
+    create?: ArticleCreateWithoutCommentsInput;
 
-  @Field(() => ArticleUpsertWithoutCommentsInput, { nullable: true })
-  @Type(() => ArticleUpsertWithoutCommentsInput)
-  upsert?: ArticleUpsertWithoutCommentsInput;
+    @Field(() => ArticleCreateOrConnectWithoutCommentsInput, {nullable:true})
+    @Type(() => ArticleCreateOrConnectWithoutCommentsInput)
+    connectOrCreate?: ArticleCreateOrConnectWithoutCommentsInput;
 
-  @Field(() => ArticleWhereInput, { nullable: true })
-  @Type(() => ArticleWhereInput)
-  disconnect?: ArticleWhereInput;
+    @Field(() => ArticleUpsertWithoutCommentsInput, {nullable:true})
+    @Type(() => ArticleUpsertWithoutCommentsInput)
+    upsert?: ArticleUpsertWithoutCommentsInput;
 
-  @Field(() => ArticleWhereInput, { nullable: true })
-  @Type(() => ArticleWhereInput)
-  delete?: ArticleWhereInput;
+    @Field(() => ArticleWhereInput, {nullable:true})
+    @Type(() => ArticleWhereInput)
+    disconnect?: ArticleWhereInput;
 
-  @Field(() => ArticleWhereUniqueInput, { nullable: true })
-  @Type(() => ArticleWhereUniqueInput)
-  connect?: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
+    @Field(() => ArticleWhereInput, {nullable:true})
+    @Type(() => ArticleWhereInput)
+    delete?: ArticleWhereInput;
 
-  @Field(() => ArticleUpdateToOneWithWhereWithoutCommentsInput, { nullable: true })
-  @Type(() => ArticleUpdateToOneWithWhereWithoutCommentsInput)
-  update?: ArticleUpdateToOneWithWhereWithoutCommentsInput;
+    @Field(() => ArticleWhereUniqueInput, {nullable:true})
+    @Type(() => ArticleWhereUniqueInput)
+    connect?: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
+
+    @Field(() => ArticleUpdateToOneWithWhereWithoutCommentsInput, {nullable:true})
+    @Type(() => ArticleUpdateToOneWithWhereWithoutCommentsInput)
+    update?: ArticleUpdateToOneWithWhereWithoutCommentsInput;
 }
diff --git a/@generated/article/article-update-to-one-with-where-without-comments.input.ts b/@generated/article/article-update-to-one-with-where-without-comments.input.ts
index 6991406d..4f9e46b1 100644
--- a/@generated/article/article-update-to-one-with-where-without-comments.input.ts
+++ b/@generated/article/article-update-to-one-with-where-without-comments.input.ts
@@ -6,11 +6,12 @@ import { ArticleUpdateWithoutCommentsInput } from './article-update-without-comm
 
 @InputType()
 export class ArticleUpdateToOneWithWhereWithoutCommentsInput {
-  @Field(() => ArticleWhereInput, { nullable: true })
-  @Type(() => ArticleWhereInput)
-  where?: ArticleWhereInput;
 
-  @Field(() => ArticleUpdateWithoutCommentsInput, { nullable: false })
-  @Type(() => ArticleUpdateWithoutCommentsInput)
-  data!: ArticleUpdateWithoutCommentsInput;
+    @Field(() => ArticleWhereInput, {nullable:true})
+    @Type(() => ArticleWhereInput)
+    where?: ArticleWhereInput;
+
+    @Field(() => ArticleUpdateWithoutCommentsInput, {nullable:false})
+    @Type(() => ArticleUpdateWithoutCommentsInput)
+    data!: ArticleUpdateWithoutCommentsInput;
 }
diff --git a/@generated/article/article-update-with-where-unique-without-author.input.ts b/@generated/article/article-update-with-where-unique-without-author.input.ts
index a4a7f599..c4798f14 100644
--- a/@generated/article/article-update-with-where-unique-without-author.input.ts
+++ b/@generated/article/article-update-with-where-unique-without-author.input.ts
@@ -1,17 +1,18 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 import { Type } from 'class-transformer';
 import { ArticleUpdateWithoutAuthorInput } from './article-update-without-author.input';
 
 @InputType()
 export class ArticleUpdateWithWhereUniqueWithoutAuthorInput {
-  @Field(() => ArticleWhereUniqueInput, { nullable: false })
-  @Type(() => ArticleWhereUniqueInput)
-  where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
 
-  @Field(() => ArticleUpdateWithoutAuthorInput, { nullable: false })
-  @Type(() => ArticleUpdateWithoutAuthorInput)
-  data!: ArticleUpdateWithoutAuthorInput;
+    @Field(() => ArticleWhereUniqueInput, {nullable:false})
+    @Type(() => ArticleWhereUniqueInput)
+    where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
+
+    @Field(() => ArticleUpdateWithoutAuthorInput, {nullable:false})
+    @Type(() => ArticleUpdateWithoutAuthorInput)
+    data!: ArticleUpdateWithoutAuthorInput;
 }
diff --git a/@generated/article/article-update-with-where-unique-without-favorited-by.input.ts b/@generated/article/article-update-with-where-unique-without-favorited-by.input.ts
index 2ae620c9..d3961e95 100644
--- a/@generated/article/article-update-with-where-unique-without-favorited-by.input.ts
+++ b/@generated/article/article-update-with-where-unique-without-favorited-by.input.ts
@@ -1,17 +1,18 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 import { Type } from 'class-transformer';
 import { ArticleUpdateWithoutFavoritedByInput } from './article-update-without-favorited-by.input';
 
 @InputType()
 export class ArticleUpdateWithWhereUniqueWithoutFavoritedByInput {
-  @Field(() => ArticleWhereUniqueInput, { nullable: false })
-  @Type(() => ArticleWhereUniqueInput)
-  where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
 
-  @Field(() => ArticleUpdateWithoutFavoritedByInput, { nullable: false })
-  @Type(() => ArticleUpdateWithoutFavoritedByInput)
-  data!: ArticleUpdateWithoutFavoritedByInput;
+    @Field(() => ArticleWhereUniqueInput, {nullable:false})
+    @Type(() => ArticleWhereUniqueInput)
+    where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
+
+    @Field(() => ArticleUpdateWithoutFavoritedByInput, {nullable:false})
+    @Type(() => ArticleUpdateWithoutFavoritedByInput)
+    data!: ArticleUpdateWithoutFavoritedByInput;
 }
diff --git a/@generated/article/article-update-with-where-unique-without-tags.input.ts b/@generated/article/article-update-with-where-unique-without-tags.input.ts
index ee0aff1b..c22b86f8 100644
--- a/@generated/article/article-update-with-where-unique-without-tags.input.ts
+++ b/@generated/article/article-update-with-where-unique-without-tags.input.ts
@@ -1,17 +1,18 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 import { Type } from 'class-transformer';
 import { ArticleUpdateWithoutTagsInput } from './article-update-without-tags.input';
 
 @InputType()
 export class ArticleUpdateWithWhereUniqueWithoutTagsInput {
-  @Field(() => ArticleWhereUniqueInput, { nullable: false })
-  @Type(() => ArticleWhereUniqueInput)
-  where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
 
-  @Field(() => ArticleUpdateWithoutTagsInput, { nullable: false })
-  @Type(() => ArticleUpdateWithoutTagsInput)
-  data!: ArticleUpdateWithoutTagsInput;
+    @Field(() => ArticleWhereUniqueInput, {nullable:false})
+    @Type(() => ArticleWhereUniqueInput)
+    where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
+
+    @Field(() => ArticleUpdateWithoutTagsInput, {nullable:false})
+    @Type(() => ArticleUpdateWithoutTagsInput)
+    data!: ArticleUpdateWithoutTagsInput;
 }
diff --git a/@generated/article/article-update-without-author.input.ts b/@generated/article/article-update-without-author.input.ts
index 6303e6c7..df03e9a4 100644
--- a/@generated/article/article-update-without-author.input.ts
+++ b/@generated/article/article-update-without-author.input.ts
@@ -11,41 +11,42 @@ import { CommentUpdateManyWithoutArticleNestedInput } from '../comment/comment-u
 
 @InputType()
 export class ArticleUpdateWithoutAuthorInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  slug?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  title?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    slug?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  description?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    title?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  body?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    description?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  createdAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    body?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  updatedAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    createdAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => IntFieldUpdateOperationsInput, { nullable: true })
-  favoritesCount?: IntFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    updatedAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => NullableBoolFieldUpdateOperationsInput, { nullable: true })
-  active?: NullableBoolFieldUpdateOperationsInput;
+    @Field(() => IntFieldUpdateOperationsInput, {nullable:true})
+    favoritesCount?: IntFieldUpdateOperationsInput;
 
-  @Field(() => TagUpdateManyWithoutArticlesNestedInput, { nullable: true })
-  tags?: TagUpdateManyWithoutArticlesNestedInput;
+    @Field(() => NullableBoolFieldUpdateOperationsInput, {nullable:true})
+    active?: NullableBoolFieldUpdateOperationsInput;
 
-  @Field(() => UserUpdateManyWithoutFavoriteArticlesNestedInput, { nullable: true })
-  @Type(() => UserUpdateManyWithoutFavoriteArticlesNestedInput)
-  favoritedBy?: UserUpdateManyWithoutFavoriteArticlesNestedInput;
+    @Field(() => TagUpdateManyWithoutArticlesNestedInput, {nullable:true})
+    tags?: TagUpdateManyWithoutArticlesNestedInput;
 
-  @Field(() => CommentUpdateManyWithoutArticleNestedInput, { nullable: true })
-  @Type(() => CommentUpdateManyWithoutArticleNestedInput)
-  comments?: CommentUpdateManyWithoutArticleNestedInput;
+    @Field(() => UserUpdateManyWithoutFavoriteArticlesNestedInput, {nullable:true})
+    @Type(() => UserUpdateManyWithoutFavoriteArticlesNestedInput)
+    favoritedBy?: UserUpdateManyWithoutFavoriteArticlesNestedInput;
+
+    @Field(() => CommentUpdateManyWithoutArticleNestedInput, {nullable:true})
+    @Type(() => CommentUpdateManyWithoutArticleNestedInput)
+    comments?: CommentUpdateManyWithoutArticleNestedInput;
 }
diff --git a/@generated/article/article-update-without-comments.input.ts b/@generated/article/article-update-without-comments.input.ts
index a9d84f3d..1ea10fb1 100644
--- a/@generated/article/article-update-without-comments.input.ts
+++ b/@generated/article/article-update-without-comments.input.ts
@@ -11,41 +11,42 @@ import { UserUpdateManyWithoutFavoriteArticlesNestedInput } from '../user/user-u
 
 @InputType()
 export class ArticleUpdateWithoutCommentsInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  slug?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  title?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    slug?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  description?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    title?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  body?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    description?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  createdAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    body?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  updatedAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    createdAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => IntFieldUpdateOperationsInput, { nullable: true })
-  favoritesCount?: IntFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    updatedAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => NullableBoolFieldUpdateOperationsInput, { nullable: true })
-  active?: NullableBoolFieldUpdateOperationsInput;
+    @Field(() => IntFieldUpdateOperationsInput, {nullable:true})
+    favoritesCount?: IntFieldUpdateOperationsInput;
 
-  @Field(() => TagUpdateManyWithoutArticlesNestedInput, { nullable: true })
-  tags?: TagUpdateManyWithoutArticlesNestedInput;
+    @Field(() => NullableBoolFieldUpdateOperationsInput, {nullable:true})
+    active?: NullableBoolFieldUpdateOperationsInput;
 
-  @Field(() => UserUpdateOneRequiredWithoutArticlesNestedInput, { nullable: true })
-  @Type(() => UserUpdateOneRequiredWithoutArticlesNestedInput)
-  author?: UserUpdateOneRequiredWithoutArticlesNestedInput;
+    @Field(() => TagUpdateManyWithoutArticlesNestedInput, {nullable:true})
+    tags?: TagUpdateManyWithoutArticlesNestedInput;
 
-  @Field(() => UserUpdateManyWithoutFavoriteArticlesNestedInput, { nullable: true })
-  @Type(() => UserUpdateManyWithoutFavoriteArticlesNestedInput)
-  favoritedBy?: UserUpdateManyWithoutFavoriteArticlesNestedInput;
+    @Field(() => UserUpdateOneRequiredWithoutArticlesNestedInput, {nullable:true})
+    @Type(() => UserUpdateOneRequiredWithoutArticlesNestedInput)
+    author?: UserUpdateOneRequiredWithoutArticlesNestedInput;
+
+    @Field(() => UserUpdateManyWithoutFavoriteArticlesNestedInput, {nullable:true})
+    @Type(() => UserUpdateManyWithoutFavoriteArticlesNestedInput)
+    favoritedBy?: UserUpdateManyWithoutFavoriteArticlesNestedInput;
 }
diff --git a/@generated/article/article-update-without-favorited-by.input.ts b/@generated/article/article-update-without-favorited-by.input.ts
index df09dbcf..25a0a273 100644
--- a/@generated/article/article-update-without-favorited-by.input.ts
+++ b/@generated/article/article-update-without-favorited-by.input.ts
@@ -11,41 +11,42 @@ import { CommentUpdateManyWithoutArticleNestedInput } from '../comment/comment-u
 
 @InputType()
 export class ArticleUpdateWithoutFavoritedByInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  slug?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  title?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    slug?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  description?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    title?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  body?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    description?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  createdAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    body?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  updatedAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    createdAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => IntFieldUpdateOperationsInput, { nullable: true })
-  favoritesCount?: IntFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    updatedAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => NullableBoolFieldUpdateOperationsInput, { nullable: true })
-  active?: NullableBoolFieldUpdateOperationsInput;
+    @Field(() => IntFieldUpdateOperationsInput, {nullable:true})
+    favoritesCount?: IntFieldUpdateOperationsInput;
 
-  @Field(() => TagUpdateManyWithoutArticlesNestedInput, { nullable: true })
-  tags?: TagUpdateManyWithoutArticlesNestedInput;
+    @Field(() => NullableBoolFieldUpdateOperationsInput, {nullable:true})
+    active?: NullableBoolFieldUpdateOperationsInput;
 
-  @Field(() => UserUpdateOneRequiredWithoutArticlesNestedInput, { nullable: true })
-  @Type(() => UserUpdateOneRequiredWithoutArticlesNestedInput)
-  author?: UserUpdateOneRequiredWithoutArticlesNestedInput;
+    @Field(() => TagUpdateManyWithoutArticlesNestedInput, {nullable:true})
+    tags?: TagUpdateManyWithoutArticlesNestedInput;
 
-  @Field(() => CommentUpdateManyWithoutArticleNestedInput, { nullable: true })
-  @Type(() => CommentUpdateManyWithoutArticleNestedInput)
-  comments?: CommentUpdateManyWithoutArticleNestedInput;
+    @Field(() => UserUpdateOneRequiredWithoutArticlesNestedInput, {nullable:true})
+    @Type(() => UserUpdateOneRequiredWithoutArticlesNestedInput)
+    author?: UserUpdateOneRequiredWithoutArticlesNestedInput;
+
+    @Field(() => CommentUpdateManyWithoutArticleNestedInput, {nullable:true})
+    @Type(() => CommentUpdateManyWithoutArticleNestedInput)
+    comments?: CommentUpdateManyWithoutArticleNestedInput;
 }
diff --git a/@generated/article/article-update-without-tags.input.ts b/@generated/article/article-update-without-tags.input.ts
index 58c961fb..3bc5bf46 100644
--- a/@generated/article/article-update-without-tags.input.ts
+++ b/@generated/article/article-update-without-tags.input.ts
@@ -11,42 +11,43 @@ import { CommentUpdateManyWithoutArticleNestedInput } from '../comment/comment-u
 
 @InputType()
 export class ArticleUpdateWithoutTagsInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  slug?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  title?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    slug?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  description?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    title?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  body?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    description?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  createdAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    body?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  updatedAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    createdAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => IntFieldUpdateOperationsInput, { nullable: true })
-  favoritesCount?: IntFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    updatedAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => NullableBoolFieldUpdateOperationsInput, { nullable: true })
-  active?: NullableBoolFieldUpdateOperationsInput;
+    @Field(() => IntFieldUpdateOperationsInput, {nullable:true})
+    favoritesCount?: IntFieldUpdateOperationsInput;
 
-  @Field(() => UserUpdateOneRequiredWithoutArticlesNestedInput, { nullable: true })
-  @Type(() => UserUpdateOneRequiredWithoutArticlesNestedInput)
-  author?: UserUpdateOneRequiredWithoutArticlesNestedInput;
+    @Field(() => NullableBoolFieldUpdateOperationsInput, {nullable:true})
+    active?: NullableBoolFieldUpdateOperationsInput;
 
-  @Field(() => UserUpdateManyWithoutFavoriteArticlesNestedInput, { nullable: true })
-  @Type(() => UserUpdateManyWithoutFavoriteArticlesNestedInput)
-  favoritedBy?: UserUpdateManyWithoutFavoriteArticlesNestedInput;
+    @Field(() => UserUpdateOneRequiredWithoutArticlesNestedInput, {nullable:true})
+    @Type(() => UserUpdateOneRequiredWithoutArticlesNestedInput)
+    author?: UserUpdateOneRequiredWithoutArticlesNestedInput;
 
-  @Field(() => CommentUpdateManyWithoutArticleNestedInput, { nullable: true })
-  @Type(() => CommentUpdateManyWithoutArticleNestedInput)
-  comments?: CommentUpdateManyWithoutArticleNestedInput;
+    @Field(() => UserUpdateManyWithoutFavoriteArticlesNestedInput, {nullable:true})
+    @Type(() => UserUpdateManyWithoutFavoriteArticlesNestedInput)
+    favoritedBy?: UserUpdateManyWithoutFavoriteArticlesNestedInput;
+
+    @Field(() => CommentUpdateManyWithoutArticleNestedInput, {nullable:true})
+    @Type(() => CommentUpdateManyWithoutArticleNestedInput)
+    comments?: CommentUpdateManyWithoutArticleNestedInput;
 }
diff --git a/@generated/article/article-update.input.ts b/@generated/article/article-update.input.ts
index c38e4d55..a8134ad5 100644
--- a/@generated/article/article-update.input.ts
+++ b/@generated/article/article-update.input.ts
@@ -12,45 +12,46 @@ import { CommentUpdateManyWithoutArticleNestedInput } from '../comment/comment-u
 
 @InputType()
 export class ArticleUpdateInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  slug?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  title?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    slug?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  description?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    title?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  body?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    description?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  createdAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    body?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  updatedAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    createdAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => IntFieldUpdateOperationsInput, { nullable: true })
-  favoritesCount?: IntFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    updatedAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => NullableBoolFieldUpdateOperationsInput, { nullable: true })
-  active?: NullableBoolFieldUpdateOperationsInput;
+    @Field(() => IntFieldUpdateOperationsInput, {nullable:true})
+    favoritesCount?: IntFieldUpdateOperationsInput;
 
-  @Field(() => TagUpdateManyWithoutArticlesNestedInput, { nullable: true })
-  tags?: TagUpdateManyWithoutArticlesNestedInput;
+    @Field(() => NullableBoolFieldUpdateOperationsInput, {nullable:true})
+    active?: NullableBoolFieldUpdateOperationsInput;
 
-  @Field(() => UserUpdateOneRequiredWithoutArticlesNestedInput, { nullable: true })
-  @Type(() => UserUpdateOneRequiredWithoutArticlesNestedInput)
-  author?: UserUpdateOneRequiredWithoutArticlesNestedInput;
+    @Field(() => TagUpdateManyWithoutArticlesNestedInput, {nullable:true})
+    tags?: TagUpdateManyWithoutArticlesNestedInput;
 
-  @Field(() => UserUpdateManyWithoutFavoriteArticlesNestedInput, { nullable: true })
-  @Type(() => UserUpdateManyWithoutFavoriteArticlesNestedInput)
-  favoritedBy?: UserUpdateManyWithoutFavoriteArticlesNestedInput;
+    @Field(() => UserUpdateOneRequiredWithoutArticlesNestedInput, {nullable:true})
+    @Type(() => UserUpdateOneRequiredWithoutArticlesNestedInput)
+    author?: UserUpdateOneRequiredWithoutArticlesNestedInput;
 
-  @Field(() => CommentUpdateManyWithoutArticleNestedInput, { nullable: true })
-  @Type(() => CommentUpdateManyWithoutArticleNestedInput)
-  comments?: CommentUpdateManyWithoutArticleNestedInput;
+    @Field(() => UserUpdateManyWithoutFavoriteArticlesNestedInput, {nullable:true})
+    @Type(() => UserUpdateManyWithoutFavoriteArticlesNestedInput)
+    favoritedBy?: UserUpdateManyWithoutFavoriteArticlesNestedInput;
+
+    @Field(() => CommentUpdateManyWithoutArticleNestedInput, {nullable:true})
+    @Type(() => CommentUpdateManyWithoutArticleNestedInput)
+    comments?: CommentUpdateManyWithoutArticleNestedInput;
 }
diff --git a/@generated/article/article-upsert-with-where-unique-without-author.input.ts b/@generated/article/article-upsert-with-where-unique-without-author.input.ts
index 6709543d..699dd0d1 100644
--- a/@generated/article/article-upsert-with-where-unique-without-author.input.ts
+++ b/@generated/article/article-upsert-with-where-unique-without-author.input.ts
@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 import { Type } from 'class-transformer';
 import { ArticleUpdateWithoutAuthorInput } from './article-update-without-author.input';
@@ -8,15 +8,16 @@ import { ArticleCreateWithoutAuthorInput } from './article-create-without-author
 
 @InputType()
 export class ArticleUpsertWithWhereUniqueWithoutAuthorInput {
-  @Field(() => ArticleWhereUniqueInput, { nullable: false })
-  @Type(() => ArticleWhereUniqueInput)
-  where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
 
-  @Field(() => ArticleUpdateWithoutAuthorInput, { nullable: false })
-  @Type(() => ArticleUpdateWithoutAuthorInput)
-  update!: ArticleUpdateWithoutAuthorInput;
+    @Field(() => ArticleWhereUniqueInput, {nullable:false})
+    @Type(() => ArticleWhereUniqueInput)
+    where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
 
-  @Field(() => ArticleCreateWithoutAuthorInput, { nullable: false })
-  @Type(() => ArticleCreateWithoutAuthorInput)
-  create!: ArticleCreateWithoutAuthorInput;
+    @Field(() => ArticleUpdateWithoutAuthorInput, {nullable:false})
+    @Type(() => ArticleUpdateWithoutAuthorInput)
+    update!: ArticleUpdateWithoutAuthorInput;
+
+    @Field(() => ArticleCreateWithoutAuthorInput, {nullable:false})
+    @Type(() => ArticleCreateWithoutAuthorInput)
+    create!: ArticleCreateWithoutAuthorInput;
 }
diff --git a/@generated/article/article-upsert-with-where-unique-without-favorited-by.input.ts b/@generated/article/article-upsert-with-where-unique-without-favorited-by.input.ts
index 007a2a00..9ea1b53e 100644
--- a/@generated/article/article-upsert-with-where-unique-without-favorited-by.input.ts
+++ b/@generated/article/article-upsert-with-where-unique-without-favorited-by.input.ts
@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 import { Type } from 'class-transformer';
 import { ArticleUpdateWithoutFavoritedByInput } from './article-update-without-favorited-by.input';
@@ -8,15 +8,16 @@ import { ArticleCreateWithoutFavoritedByInput } from './article-create-without-f
 
 @InputType()
 export class ArticleUpsertWithWhereUniqueWithoutFavoritedByInput {
-  @Field(() => ArticleWhereUniqueInput, { nullable: false })
-  @Type(() => ArticleWhereUniqueInput)
-  where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
 
-  @Field(() => ArticleUpdateWithoutFavoritedByInput, { nullable: false })
-  @Type(() => ArticleUpdateWithoutFavoritedByInput)
-  update!: ArticleUpdateWithoutFavoritedByInput;
+    @Field(() => ArticleWhereUniqueInput, {nullable:false})
+    @Type(() => ArticleWhereUniqueInput)
+    where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
 
-  @Field(() => ArticleCreateWithoutFavoritedByInput, { nullable: false })
-  @Type(() => ArticleCreateWithoutFavoritedByInput)
-  create!: ArticleCreateWithoutFavoritedByInput;
+    @Field(() => ArticleUpdateWithoutFavoritedByInput, {nullable:false})
+    @Type(() => ArticleUpdateWithoutFavoritedByInput)
+    update!: ArticleUpdateWithoutFavoritedByInput;
+
+    @Field(() => ArticleCreateWithoutFavoritedByInput, {nullable:false})
+    @Type(() => ArticleCreateWithoutFavoritedByInput)
+    create!: ArticleCreateWithoutFavoritedByInput;
 }
diff --git a/@generated/article/article-upsert-with-where-unique-without-tags.input.ts b/@generated/article/article-upsert-with-where-unique-without-tags.input.ts
index cd4a0d85..ca79f13f 100644
--- a/@generated/article/article-upsert-with-where-unique-without-tags.input.ts
+++ b/@generated/article/article-upsert-with-where-unique-without-tags.input.ts
@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 import { Type } from 'class-transformer';
 import { ArticleUpdateWithoutTagsInput } from './article-update-without-tags.input';
@@ -8,15 +8,16 @@ import { ArticleCreateWithoutTagsInput } from './article-create-without-tags.inp
 
 @InputType()
 export class ArticleUpsertWithWhereUniqueWithoutTagsInput {
-  @Field(() => ArticleWhereUniqueInput, { nullable: false })
-  @Type(() => ArticleWhereUniqueInput)
-  where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
 
-  @Field(() => ArticleUpdateWithoutTagsInput, { nullable: false })
-  @Type(() => ArticleUpdateWithoutTagsInput)
-  update!: ArticleUpdateWithoutTagsInput;
+    @Field(() => ArticleWhereUniqueInput, {nullable:false})
+    @Type(() => ArticleWhereUniqueInput)
+    where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
 
-  @Field(() => ArticleCreateWithoutTagsInput, { nullable: false })
-  @Type(() => ArticleCreateWithoutTagsInput)
-  create!: ArticleCreateWithoutTagsInput;
+    @Field(() => ArticleUpdateWithoutTagsInput, {nullable:false})
+    @Type(() => ArticleUpdateWithoutTagsInput)
+    update!: ArticleUpdateWithoutTagsInput;
+
+    @Field(() => ArticleCreateWithoutTagsInput, {nullable:false})
+    @Type(() => ArticleCreateWithoutTagsInput)
+    create!: ArticleCreateWithoutTagsInput;
 }
diff --git a/@generated/article/article-upsert-without-comments.input.ts b/@generated/article/article-upsert-without-comments.input.ts
index 7e722c9c..26e65aef 100644
--- a/@generated/article/article-upsert-without-comments.input.ts
+++ b/@generated/article/article-upsert-without-comments.input.ts
@@ -7,15 +7,16 @@ import { ArticleWhereInput } from './article-where.input';
 
 @InputType()
 export class ArticleUpsertWithoutCommentsInput {
-  @Field(() => ArticleUpdateWithoutCommentsInput, { nullable: false })
-  @Type(() => ArticleUpdateWithoutCommentsInput)
-  update!: ArticleUpdateWithoutCommentsInput;
 
-  @Field(() => ArticleCreateWithoutCommentsInput, { nullable: false })
-  @Type(() => ArticleCreateWithoutCommentsInput)
-  create!: ArticleCreateWithoutCommentsInput;
+    @Field(() => ArticleUpdateWithoutCommentsInput, {nullable:false})
+    @Type(() => ArticleUpdateWithoutCommentsInput)
+    update!: ArticleUpdateWithoutCommentsInput;
 
-  @Field(() => ArticleWhereInput, { nullable: true })
-  @Type(() => ArticleWhereInput)
-  where?: ArticleWhereInput;
+    @Field(() => ArticleCreateWithoutCommentsInput, {nullable:false})
+    @Type(() => ArticleCreateWithoutCommentsInput)
+    create!: ArticleCreateWithoutCommentsInput;
+
+    @Field(() => ArticleWhereInput, {nullable:true})
+    @Type(() => ArticleWhereInput)
+    where?: ArticleWhereInput;
 }
diff --git a/@generated/article/article-where-unique.input.ts b/@generated/article/article-where-unique.input.ts
index b2c1a227..33112495 100644
--- a/@generated/article/article-where-unique.input.ts
+++ b/@generated/article/article-where-unique.input.ts
@@ -13,57 +13,58 @@ import { CommentListRelationFilter } from '../comment/comment-list-relation-filt
 
 @InputType()
 export class ArticleWhereUniqueInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => String, { nullable: true })
-  slug?: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => [ArticleWhereInput], { nullable: true })
-  AND?: Array<ArticleWhereInput>;
+    @Field(() => String, {nullable:true})
+    slug?: string;
 
-  @Field(() => [ArticleWhereInput], { nullable: true })
-  OR?: Array<ArticleWhereInput>;
+    @Field(() => [ArticleWhereInput], {nullable:true})
+    AND?: Array<ArticleWhereInput>;
 
-  @Field(() => [ArticleWhereInput], { nullable: true })
-  NOT?: Array<ArticleWhereInput>;
+    @Field(() => [ArticleWhereInput], {nullable:true})
+    OR?: Array<ArticleWhereInput>;
 
-  @Field(() => StringFilter, { nullable: true })
-  title?: StringFilter;
+    @Field(() => [ArticleWhereInput], {nullable:true})
+    NOT?: Array<ArticleWhereInput>;
 
-  @Field(() => StringFilter, { nullable: true })
-  description?: StringFilter;
+    @Field(() => StringFilter, {nullable:true})
+    title?: StringFilter;
 
-  @Field(() => StringFilter, { nullable: true })
-  body?: StringFilter;
+    @Field(() => StringFilter, {nullable:true})
+    description?: StringFilter;
 
-  @Field(() => DateTimeFilter, { nullable: true })
-  createdAt?: DateTimeFilter;
+    @Field(() => StringFilter, {nullable:true})
+    body?: StringFilter;
 
-  @Field(() => DateTimeFilter, { nullable: true })
-  updatedAt?: DateTimeFilter;
+    @Field(() => DateTimeFilter, {nullable:true})
+    createdAt?: DateTimeFilter;
 
-  @Field(() => IntFilter, { nullable: true })
-  favoritesCount?: IntFilter;
+    @Field(() => DateTimeFilter, {nullable:true})
+    updatedAt?: DateTimeFilter;
 
-  @Field(() => StringFilter, { nullable: true })
-  authorId?: StringFilter;
+    @Field(() => IntFilter, {nullable:true})
+    favoritesCount?: IntFilter;
 
-  @Field(() => BoolNullableFilter, { nullable: true })
-  active?: BoolNullableFilter;
+    @Field(() => StringFilter, {nullable:true})
+    authorId?: StringFilter;
 
-  @Field(() => TagListRelationFilter, { nullable: true })
-  tags?: TagListRelationFilter;
+    @Field(() => BoolNullableFilter, {nullable:true})
+    active?: BoolNullableFilter;
 
-  @Field(() => UserRelationFilter, { nullable: true })
-  @Type(() => UserRelationFilter)
-  author?: UserRelationFilter;
+    @Field(() => TagListRelationFilter, {nullable:true})
+    tags?: TagListRelationFilter;
 
-  @Field(() => UserListRelationFilter, { nullable: true })
-  @Type(() => UserListRelationFilter)
-  favoritedBy?: UserListRelationFilter;
+    @Field(() => UserRelationFilter, {nullable:true})
+    @Type(() => UserRelationFilter)
+    author?: UserRelationFilter;
 
-  @Field(() => CommentListRelationFilter, { nullable: true })
-  @Type(() => CommentListRelationFilter)
-  comments?: CommentListRelationFilter;
+    @Field(() => UserListRelationFilter, {nullable:true})
+    @Type(() => UserListRelationFilter)
+    favoritedBy?: UserListRelationFilter;
+
+    @Field(() => CommentListRelationFilter, {nullable:true})
+    @Type(() => CommentListRelationFilter)
+    comments?: CommentListRelationFilter;
 }
diff --git a/@generated/article/article-where.input.ts b/@generated/article/article-where.input.ts
index 0ec5249a..352c9b64 100644
--- a/@generated/article/article-where.input.ts
+++ b/@generated/article/article-where.input.ts
@@ -12,57 +12,58 @@ import { CommentListRelationFilter } from '../comment/comment-list-relation-filt
 
 @InputType()
 export class ArticleWhereInput {
-  @Field(() => [ArticleWhereInput], { nullable: true })
-  AND?: Array<ArticleWhereInput>;
 
-  @Field(() => [ArticleWhereInput], { nullable: true })
-  OR?: Array<ArticleWhereInput>;
+    @Field(() => [ArticleWhereInput], {nullable:true})
+    AND?: Array<ArticleWhereInput>;
 
-  @Field(() => [ArticleWhereInput], { nullable: true })
-  NOT?: Array<ArticleWhereInput>;
+    @Field(() => [ArticleWhereInput], {nullable:true})
+    OR?: Array<ArticleWhereInput>;
 
-  @Field(() => StringFilter, { nullable: true })
-  id?: StringFilter;
+    @Field(() => [ArticleWhereInput], {nullable:true})
+    NOT?: Array<ArticleWhereInput>;
 
-  @Field(() => StringFilter, { nullable: true })
-  slug?: StringFilter;
+    @Field(() => StringFilter, {nullable:true})
+    id?: StringFilter;
 
-  @Field(() => StringFilter, { nullable: true })
-  title?: StringFilter;
+    @Field(() => StringFilter, {nullable:true})
+    slug?: StringFilter;
 
-  @Field(() => StringFilter, { nullable: true })
-  description?: StringFilter;
+    @Field(() => StringFilter, {nullable:true})
+    title?: StringFilter;
 
-  @Field(() => StringFilter, { nullable: true })
-  body?: StringFilter;
+    @Field(() => StringFilter, {nullable:true})
+    description?: StringFilter;
 
-  @Field(() => DateTimeFilter, { nullable: true })
-  createdAt?: DateTimeFilter;
+    @Field(() => StringFilter, {nullable:true})
+    body?: StringFilter;
 
-  @Field(() => DateTimeFilter, { nullable: true })
-  updatedAt?: DateTimeFilter;
+    @Field(() => DateTimeFilter, {nullable:true})
+    createdAt?: DateTimeFilter;
 
-  @Field(() => IntFilter, { nullable: true })
-  favoritesCount?: IntFilter;
+    @Field(() => DateTimeFilter, {nullable:true})
+    updatedAt?: DateTimeFilter;
 
-  @Field(() => StringFilter, { nullable: true })
-  authorId?: StringFilter;
+    @Field(() => IntFilter, {nullable:true})
+    favoritesCount?: IntFilter;
 
-  @Field(() => BoolNullableFilter, { nullable: true })
-  active?: BoolNullableFilter;
+    @Field(() => StringFilter, {nullable:true})
+    authorId?: StringFilter;
 
-  @Field(() => TagListRelationFilter, { nullable: true })
-  tags?: TagListRelationFilter;
+    @Field(() => BoolNullableFilter, {nullable:true})
+    active?: BoolNullableFilter;
 
-  @Field(() => UserWhereInput, { nullable: true })
-  @Type(() => UserWhereInput)
-  author?: UserWhereInput;
+    @Field(() => TagListRelationFilter, {nullable:true})
+    tags?: TagListRelationFilter;
 
-  @Field(() => UserListRelationFilter, { nullable: true })
-  @Type(() => UserListRelationFilter)
-  favoritedBy?: UserListRelationFilter;
+    @Field(() => UserWhereInput, {nullable:true})
+    @Type(() => UserWhereInput)
+    author?: UserWhereInput;
 
-  @Field(() => CommentListRelationFilter, { nullable: true })
-  @Type(() => CommentListRelationFilter)
-  comments?: CommentListRelationFilter;
+    @Field(() => UserListRelationFilter, {nullable:true})
+    @Type(() => UserListRelationFilter)
+    favoritedBy?: UserListRelationFilter;
+
+    @Field(() => CommentListRelationFilter, {nullable:true})
+    @Type(() => CommentListRelationFilter)
+    comments?: CommentListRelationFilter;
 }
diff --git a/@generated/article/article.model.ts b/@generated/article/article.model.ts
index fd922398..7ec172e2 100644
--- a/@generated/article/article.model.ts
+++ b/@generated/article/article.model.ts
@@ -9,48 +9,49 @@ import { ArticleCount } from './article-count.output';
 
 @ObjectType()
 export class Article {
-  @Field(() => ID, { nullable: false })
-  id!: string;
 
-  @Field(() => String, { nullable: false })
-  slug!: string;
+    @Field(() => ID, {nullable:false})
+    id!: string;
 
-  @Field(() => String, { nullable: false })
-  title!: string;
+    @Field(() => String, {nullable:false})
+    slug!: string;
 
-  @Field(() => String, { nullable: false })
-  description!: string;
+    @Field(() => String, {nullable:false})
+    title!: string;
 
-  @Field(() => String, { nullable: false })
-  body!: string;
+    @Field(() => String, {nullable:false})
+    description!: string;
 
-  @Field(() => Date, { nullable: false })
-  createdAt!: Date;
+    @Field(() => String, {nullable:false})
+    body!: string;
 
-  @Field(() => Date, { nullable: false })
-  updatedAt!: Date;
+    @Field(() => Date, {nullable:false})
+    createdAt!: Date;
 
-  @Field(() => Int, { nullable: false, defaultValue: 0 })
-  favoritesCount!: number;
+    @Field(() => Date, {nullable:false})
+    updatedAt!: Date;
 
-  @Field(() => String, { nullable: false })
-  authorId!: string;
+    @Field(() => Int, {nullable:false,defaultValue:0})
+    favoritesCount!: number;
 
-  @Field(() => Boolean, { nullable: true, defaultValue: true })
-  active!: boolean | null;
+    @Field(() => String, {nullable:false})
+    authorId!: string;
 
-  @Field(() => [Tag], { nullable: true })
-  tags?: Array<Tag>;
+    @Field(() => Boolean, {nullable:true,defaultValue:true})
+    active!: boolean | null;
 
-  @Field(() => User, { nullable: false })
-  author?: User;
+    @Field(() => [Tag], {nullable:true})
+    tags?: Array<Tag>;
 
-  @Field(() => [User], { nullable: true })
-  favoritedBy?: Array<User>;
+    @Field(() => User, {nullable:false})
+    author?: User;
 
-  @Field(() => [Comment], { nullable: true })
-  comments?: Array<Comment>;
+    @Field(() => [User], {nullable:true})
+    favoritedBy?: Array<User>;
 
-  @Field(() => ArticleCount, { nullable: false })
-  _count?: ArticleCount;
+    @Field(() => [Comment], {nullable:true})
+    comments?: Array<Comment>;
+
+    @Field(() => ArticleCount, {nullable:false})
+    _count?: ArticleCount;
 }
diff --git a/@generated/article/create-many-article.args.ts b/@generated/article/create-many-article.args.ts
index fc03b238..0485fa69 100644
--- a/@generated/article/create-many-article.args.ts
+++ b/@generated/article/create-many-article.args.ts
@@ -5,10 +5,11 @@ import { Type } from 'class-transformer';
 
 @ArgsType()
 export class CreateManyArticleArgs {
-  @Field(() => [ArticleCreateManyInput], { nullable: false })
-  @Type(() => ArticleCreateManyInput)
-  data!: Array<ArticleCreateManyInput>;
 
-  @Field(() => Boolean, { nullable: true })
-  skipDuplicates?: boolean;
+    @Field(() => [ArticleCreateManyInput], {nullable:false})
+    @Type(() => ArticleCreateManyInput)
+    data!: Array<ArticleCreateManyInput>;
+
+    @Field(() => Boolean, {nullable:true})
+    skipDuplicates?: boolean;
 }
diff --git a/@generated/article/create-one-article.args.ts b/@generated/article/create-one-article.args.ts
index 7dcf3217..a5dc7fa8 100644
--- a/@generated/article/create-one-article.args.ts
+++ b/@generated/article/create-one-article.args.ts
@@ -5,7 +5,8 @@ import { Type } from 'class-transformer';
 
 @ArgsType()
 export class CreateOneArticleArgs {
-  @Field(() => ArticleCreateInput, { nullable: false })
-  @Type(() => ArticleCreateInput)
-  data!: ArticleCreateInput;
+
+    @Field(() => ArticleCreateInput, {nullable:false})
+    @Type(() => ArticleCreateInput)
+    data!: ArticleCreateInput;
 }
diff --git a/@generated/article/delete-many-article.args.ts b/@generated/article/delete-many-article.args.ts
index 3707e12b..bb343849 100644
--- a/@generated/article/delete-many-article.args.ts
+++ b/@generated/article/delete-many-article.args.ts
@@ -5,7 +5,8 @@ import { Type } from 'class-transformer';
 
 @ArgsType()
 export class DeleteManyArticleArgs {
-  @Field(() => ArticleWhereInput, { nullable: true })
-  @Type(() => ArticleWhereInput)
-  where?: ArticleWhereInput;
+
+    @Field(() => ArticleWhereInput, {nullable:true})
+    @Type(() => ArticleWhereInput)
+    where?: ArticleWhereInput;
 }
diff --git a/@generated/article/delete-one-article.args.ts b/@generated/article/delete-one-article.args.ts
index 335689bd..9b878e6f 100644
--- a/@generated/article/delete-one-article.args.ts
+++ b/@generated/article/delete-one-article.args.ts
@@ -1,12 +1,13 @@
 import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 import { Type } from 'class-transformer';
 
 @ArgsType()
 export class DeleteOneArticleArgs {
-  @Field(() => ArticleWhereUniqueInput, { nullable: false })
-  @Type(() => ArticleWhereUniqueInput)
-  where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
+
+    @Field(() => ArticleWhereUniqueInput, {nullable:false})
+    @Type(() => ArticleWhereUniqueInput)
+    where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
 }
diff --git a/@generated/article/find-first-article-or-throw.args.ts b/@generated/article/find-first-article-or-throw.args.ts
index c7d5623d..a1cfce1a 100644
--- a/@generated/article/find-first-article-or-throw.args.ts
+++ b/@generated/article/find-first-article-or-throw.args.ts
@@ -3,29 +3,30 @@ import { ArgsType } from '@nestjs/graphql';
 import { ArticleWhereInput } from './article-where.input';
 import { Type } from 'class-transformer';
 import { ArticleOrderByWithRelationAndSearchRelevanceInput } from './article-order-by-with-relation-and-search-relevance.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 import { Int } from '@nestjs/graphql';
 import { ArticleScalarFieldEnum } from './article-scalar-field.enum';
 
 @ArgsType()
 export class FindFirstArticleOrThrowArgs {
-  @Field(() => ArticleWhereInput, { nullable: true })
-  @Type(() => ArticleWhereInput)
-  where?: ArticleWhereInput;
 
-  @Field(() => [ArticleOrderByWithRelationAndSearchRelevanceInput], { nullable: true })
-  orderBy?: Array<ArticleOrderByWithRelationAndSearchRelevanceInput>;
+    @Field(() => ArticleWhereInput, {nullable:true})
+    @Type(() => ArticleWhereInput)
+    where?: ArticleWhereInput;
 
-  @Field(() => ArticleWhereUniqueInput, { nullable: true })
-  cursor?: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
+    @Field(() => [ArticleOrderByWithRelationAndSearchRelevanceInput], {nullable:true})
+    orderBy?: Array<ArticleOrderByWithRelationAndSearchRelevanceInput>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => ArticleWhereUniqueInput, {nullable:true})
+    cursor?: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => [ArticleScalarFieldEnum], { nullable: true })
-  distinct?: Array<keyof typeof ArticleScalarFieldEnum>;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
+
+    @Field(() => [ArticleScalarFieldEnum], {nullable:true})
+    distinct?: Array<keyof typeof ArticleScalarFieldEnum>;
 }
diff --git a/@generated/article/find-first-article.args.ts b/@generated/article/find-first-article.args.ts
index 69b9373e..d89010b2 100644
--- a/@generated/article/find-first-article.args.ts
+++ b/@generated/article/find-first-article.args.ts
@@ -3,29 +3,30 @@ import { ArgsType } from '@nestjs/graphql';
 import { ArticleWhereInput } from './article-where.input';
 import { Type } from 'class-transformer';
 import { ArticleOrderByWithRelationAndSearchRelevanceInput } from './article-order-by-with-relation-and-search-relevance.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 import { Int } from '@nestjs/graphql';
 import { ArticleScalarFieldEnum } from './article-scalar-field.enum';
 
 @ArgsType()
 export class FindFirstArticleArgs {
-  @Field(() => ArticleWhereInput, { nullable: true })
-  @Type(() => ArticleWhereInput)
-  where?: ArticleWhereInput;
 
-  @Field(() => [ArticleOrderByWithRelationAndSearchRelevanceInput], { nullable: true })
-  orderBy?: Array<ArticleOrderByWithRelationAndSearchRelevanceInput>;
+    @Field(() => ArticleWhereInput, {nullable:true})
+    @Type(() => ArticleWhereInput)
+    where?: ArticleWhereInput;
 
-  @Field(() => ArticleWhereUniqueInput, { nullable: true })
-  cursor?: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
+    @Field(() => [ArticleOrderByWithRelationAndSearchRelevanceInput], {nullable:true})
+    orderBy?: Array<ArticleOrderByWithRelationAndSearchRelevanceInput>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => ArticleWhereUniqueInput, {nullable:true})
+    cursor?: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => [ArticleScalarFieldEnum], { nullable: true })
-  distinct?: Array<keyof typeof ArticleScalarFieldEnum>;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
+
+    @Field(() => [ArticleScalarFieldEnum], {nullable:true})
+    distinct?: Array<keyof typeof ArticleScalarFieldEnum>;
 }
diff --git a/@generated/article/find-many-article.args.ts b/@generated/article/find-many-article.args.ts
index 24edf7bb..aff6a2f7 100644
--- a/@generated/article/find-many-article.args.ts
+++ b/@generated/article/find-many-article.args.ts
@@ -3,29 +3,30 @@ import { ArgsType } from '@nestjs/graphql';
 import { ArticleWhereInput } from './article-where.input';
 import { Type } from 'class-transformer';
 import { ArticleOrderByWithRelationAndSearchRelevanceInput } from './article-order-by-with-relation-and-search-relevance.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 import { Int } from '@nestjs/graphql';
 import { ArticleScalarFieldEnum } from './article-scalar-field.enum';
 
 @ArgsType()
 export class FindManyArticleArgs {
-  @Field(() => ArticleWhereInput, { nullable: true })
-  @Type(() => ArticleWhereInput)
-  where?: ArticleWhereInput;
 
-  @Field(() => [ArticleOrderByWithRelationAndSearchRelevanceInput], { nullable: true })
-  orderBy?: Array<ArticleOrderByWithRelationAndSearchRelevanceInput>;
+    @Field(() => ArticleWhereInput, {nullable:true})
+    @Type(() => ArticleWhereInput)
+    where?: ArticleWhereInput;
 
-  @Field(() => ArticleWhereUniqueInput, { nullable: true })
-  cursor?: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
+    @Field(() => [ArticleOrderByWithRelationAndSearchRelevanceInput], {nullable:true})
+    orderBy?: Array<ArticleOrderByWithRelationAndSearchRelevanceInput>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => ArticleWhereUniqueInput, {nullable:true})
+    cursor?: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => [ArticleScalarFieldEnum], { nullable: true })
-  distinct?: Array<keyof typeof ArticleScalarFieldEnum>;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
+
+    @Field(() => [ArticleScalarFieldEnum], {nullable:true})
+    distinct?: Array<keyof typeof ArticleScalarFieldEnum>;
 }
diff --git a/@generated/article/find-unique-article-or-throw.args.ts b/@generated/article/find-unique-article-or-throw.args.ts
index d7742512..94e64e81 100644
--- a/@generated/article/find-unique-article-or-throw.args.ts
+++ b/@generated/article/find-unique-article-or-throw.args.ts
@@ -1,12 +1,13 @@
 import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 import { Type } from 'class-transformer';
 
 @ArgsType()
 export class FindUniqueArticleOrThrowArgs {
-  @Field(() => ArticleWhereUniqueInput, { nullable: false })
-  @Type(() => ArticleWhereUniqueInput)
-  where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
+
+    @Field(() => ArticleWhereUniqueInput, {nullable:false})
+    @Type(() => ArticleWhereUniqueInput)
+    where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
 }
diff --git a/@generated/article/find-unique-article.args.ts b/@generated/article/find-unique-article.args.ts
index 606b2ff4..31a050df 100644
--- a/@generated/article/find-unique-article.args.ts
+++ b/@generated/article/find-unique-article.args.ts
@@ -1,12 +1,13 @@
 import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 import { Type } from 'class-transformer';
 
 @ArgsType()
 export class FindUniqueArticleArgs {
-  @Field(() => ArticleWhereUniqueInput, { nullable: false })
-  @Type(() => ArticleWhereUniqueInput)
-  where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
+
+    @Field(() => ArticleWhereUniqueInput, {nullable:false})
+    @Type(() => ArticleWhereUniqueInput)
+    where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
 }
diff --git a/@generated/article/update-many-article.args.ts b/@generated/article/update-many-article.args.ts
index b020d5de..288ed3be 100644
--- a/@generated/article/update-many-article.args.ts
+++ b/@generated/article/update-many-article.args.ts
@@ -6,11 +6,12 @@ import { ArticleWhereInput } from './article-where.input';
 
 @ArgsType()
 export class UpdateManyArticleArgs {
-  @Field(() => ArticleUpdateManyMutationInput, { nullable: false })
-  @Type(() => ArticleUpdateManyMutationInput)
-  data!: ArticleUpdateManyMutationInput;
 
-  @Field(() => ArticleWhereInput, { nullable: true })
-  @Type(() => ArticleWhereInput)
-  where?: ArticleWhereInput;
+    @Field(() => ArticleUpdateManyMutationInput, {nullable:false})
+    @Type(() => ArticleUpdateManyMutationInput)
+    data!: ArticleUpdateManyMutationInput;
+
+    @Field(() => ArticleWhereInput, {nullable:true})
+    @Type(() => ArticleWhereInput)
+    where?: ArticleWhereInput;
 }
diff --git a/@generated/article/update-one-article.args.ts b/@generated/article/update-one-article.args.ts
index 67139a92..24c6aa58 100644
--- a/@generated/article/update-one-article.args.ts
+++ b/@generated/article/update-one-article.args.ts
@@ -2,16 +2,17 @@ import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
 import { ArticleUpdateInput } from './article-update.input';
 import { Type } from 'class-transformer';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 
 @ArgsType()
 export class UpdateOneArticleArgs {
-  @Field(() => ArticleUpdateInput, { nullable: false })
-  @Type(() => ArticleUpdateInput)
-  data!: ArticleUpdateInput;
 
-  @Field(() => ArticleWhereUniqueInput, { nullable: false })
-  @Type(() => ArticleWhereUniqueInput)
-  where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
+    @Field(() => ArticleUpdateInput, {nullable:false})
+    @Type(() => ArticleUpdateInput)
+    data!: ArticleUpdateInput;
+
+    @Field(() => ArticleWhereUniqueInput, {nullable:false})
+    @Type(() => ArticleWhereUniqueInput)
+    where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
 }
diff --git a/@generated/article/upsert-one-article.args.ts b/@generated/article/upsert-one-article.args.ts
index d3ba8f23..e038cafb 100644
--- a/@generated/article/upsert-one-article.args.ts
+++ b/@generated/article/upsert-one-article.args.ts
@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ArticleWhereUniqueInput } from './article-where-unique.input';
 import { Type } from 'class-transformer';
 import { ArticleCreateInput } from './article-create.input';
@@ -8,15 +8,16 @@ import { ArticleUpdateInput } from './article-update.input';
 
 @ArgsType()
 export class UpsertOneArticleArgs {
-  @Field(() => ArticleWhereUniqueInput, { nullable: false })
-  @Type(() => ArticleWhereUniqueInput)
-  where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
 
-  @Field(() => ArticleCreateInput, { nullable: false })
-  @Type(() => ArticleCreateInput)
-  create!: ArticleCreateInput;
+    @Field(() => ArticleWhereUniqueInput, {nullable:false})
+    @Type(() => ArticleWhereUniqueInput)
+    where!: Prisma.AtLeast<ArticleWhereUniqueInput, 'id' | 'slug'>;
 
-  @Field(() => ArticleUpdateInput, { nullable: false })
-  @Type(() => ArticleUpdateInput)
-  update!: ArticleUpdateInput;
+    @Field(() => ArticleCreateInput, {nullable:false})
+    @Type(() => ArticleCreateInput)
+    create!: ArticleCreateInput;
+
+    @Field(() => ArticleUpdateInput, {nullable:false})
+    @Type(() => ArticleUpdateInput)
+    update!: ArticleUpdateInput;
 }
diff --git a/@generated/comment/aggregate-comment.output.ts b/@generated/comment/aggregate-comment.output.ts
index 59c747eb..3090623a 100644
--- a/@generated/comment/aggregate-comment.output.ts
+++ b/@generated/comment/aggregate-comment.output.ts
@@ -6,12 +6,13 @@ import { CommentMaxAggregate } from './comment-max-aggregate.output';
 
 @ObjectType()
 export class AggregateComment {
-  @Field(() => CommentCountAggregate, { nullable: true })
-  _count?: CommentCountAggregate;
 
-  @Field(() => CommentMinAggregate, { nullable: true })
-  _min?: CommentMinAggregate;
+    @Field(() => CommentCountAggregate, {nullable:true})
+    _count?: CommentCountAggregate;
 
-  @Field(() => CommentMaxAggregate, { nullable: true })
-  _max?: CommentMaxAggregate;
+    @Field(() => CommentMinAggregate, {nullable:true})
+    _min?: CommentMinAggregate;
+
+    @Field(() => CommentMaxAggregate, {nullable:true})
+    _max?: CommentMaxAggregate;
 }
diff --git a/@generated/comment/comment-aggregate.args.ts b/@generated/comment/comment-aggregate.args.ts
index 9a2115aa..65077d0c 100644
--- a/@generated/comment/comment-aggregate.args.ts
+++ b/@generated/comment/comment-aggregate.args.ts
@@ -3,7 +3,7 @@ import { ArgsType } from '@nestjs/graphql';
 import { CommentWhereInput } from './comment-where.input';
 import { Type } from 'class-transformer';
 import { CommentOrderByWithRelationAndSearchRelevanceInput } from './comment-order-by-with-relation-and-search-relevance.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { CommentWhereUniqueInput } from './comment-where-unique.input';
 import { Int } from '@nestjs/graphql';
 import { CommentCountAggregateInput } from './comment-count-aggregate.input';
@@ -12,28 +12,29 @@ import { CommentMaxAggregateInput } from './comment-max-aggregate.input';
 
 @ArgsType()
 export class CommentAggregateArgs {
-  @Field(() => CommentWhereInput, { nullable: true })
-  @Type(() => CommentWhereInput)
-  where?: CommentWhereInput;
 
-  @Field(() => [CommentOrderByWithRelationAndSearchRelevanceInput], { nullable: true })
-  orderBy?: Array<CommentOrderByWithRelationAndSearchRelevanceInput>;
+    @Field(() => CommentWhereInput, {nullable:true})
+    @Type(() => CommentWhereInput)
+    where?: CommentWhereInput;
 
-  @Field(() => CommentWhereUniqueInput, { nullable: true })
-  cursor?: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
+    @Field(() => [CommentOrderByWithRelationAndSearchRelevanceInput], {nullable:true})
+    orderBy?: Array<CommentOrderByWithRelationAndSearchRelevanceInput>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => CommentWhereUniqueInput, {nullable:true})
+    cursor?: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => CommentCountAggregateInput, { nullable: true })
-  _count?: CommentCountAggregateInput;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
 
-  @Field(() => CommentMinAggregateInput, { nullable: true })
-  _min?: CommentMinAggregateInput;
+    @Field(() => CommentCountAggregateInput, {nullable:true})
+    _count?: CommentCountAggregateInput;
 
-  @Field(() => CommentMaxAggregateInput, { nullable: true })
-  _max?: CommentMaxAggregateInput;
+    @Field(() => CommentMinAggregateInput, {nullable:true})
+    _min?: CommentMinAggregateInput;
+
+    @Field(() => CommentMaxAggregateInput, {nullable:true})
+    _max?: CommentMaxAggregateInput;
 }
diff --git a/@generated/comment/comment-count-aggregate.input.ts b/@generated/comment/comment-count-aggregate.input.ts
index 75d67faf..e50a941c 100644
--- a/@generated/comment/comment-count-aggregate.input.ts
+++ b/@generated/comment/comment-count-aggregate.input.ts
@@ -3,24 +3,25 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class CommentCountAggregateInput {
-  @Field(() => Boolean, { nullable: true })
-  id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  createdAt?: true;
+    @Field(() => Boolean, {nullable:true})
+    id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  updatedAt?: true;
+    @Field(() => Boolean, {nullable:true})
+    createdAt?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  body?: true;
+    @Field(() => Boolean, {nullable:true})
+    updatedAt?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  authorId?: true;
+    @Field(() => Boolean, {nullable:true})
+    body?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  articleId?: true;
+    @Field(() => Boolean, {nullable:true})
+    authorId?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  _all?: true;
+    @Field(() => Boolean, {nullable:true})
+    articleId?: true;
+
+    @Field(() => Boolean, {nullable:true})
+    _all?: true;
 }
diff --git a/@generated/comment/comment-count-aggregate.output.ts b/@generated/comment/comment-count-aggregate.output.ts
index fd7bfc02..d9d20242 100644
--- a/@generated/comment/comment-count-aggregate.output.ts
+++ b/@generated/comment/comment-count-aggregate.output.ts
@@ -4,24 +4,25 @@ import { Int } from '@nestjs/graphql';
 
 @ObjectType()
 export class CommentCountAggregate {
-  @Field(() => Int, { nullable: false })
-  id!: number;
 
-  @Field(() => Int, { nullable: false })
-  createdAt!: number;
+    @Field(() => Int, {nullable:false})
+    id!: number;
 
-  @Field(() => Int, { nullable: false })
-  updatedAt!: number;
+    @Field(() => Int, {nullable:false})
+    createdAt!: number;
 
-  @Field(() => Int, { nullable: false })
-  body!: number;
+    @Field(() => Int, {nullable:false})
+    updatedAt!: number;
 
-  @Field(() => Int, { nullable: false })
-  authorId!: number;
+    @Field(() => Int, {nullable:false})
+    body!: number;
 
-  @Field(() => Int, { nullable: false })
-  articleId!: number;
+    @Field(() => Int, {nullable:false})
+    authorId!: number;
 
-  @Field(() => Int, { nullable: false })
-  _all!: number;
+    @Field(() => Int, {nullable:false})
+    articleId!: number;
+
+    @Field(() => Int, {nullable:false})
+    _all!: number;
 }
diff --git a/@generated/comment/comment-count-order-by-aggregate.input.ts b/@generated/comment/comment-count-order-by-aggregate.input.ts
index fdb69b3a..e65b523b 100644
--- a/@generated/comment/comment-count-order-by-aggregate.input.ts
+++ b/@generated/comment/comment-count-order-by-aggregate.input.ts
@@ -4,21 +4,22 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class CommentCountOrderByAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  createdAt?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  updatedAt?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    createdAt?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  body?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    updatedAt?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  authorId?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    body?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  articleId?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    authorId?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    articleId?: keyof typeof SortOrder;
 }
diff --git a/@generated/comment/comment-create-many-article-input-envelope.input.ts b/@generated/comment/comment-create-many-article-input-envelope.input.ts
index 40ea2d07..c008db09 100644
--- a/@generated/comment/comment-create-many-article-input-envelope.input.ts
+++ b/@generated/comment/comment-create-many-article-input-envelope.input.ts
@@ -5,10 +5,11 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class CommentCreateManyArticleInputEnvelope {
-  @Field(() => [CommentCreateManyArticleInput], { nullable: false })
-  @Type(() => CommentCreateManyArticleInput)
-  data!: Array<CommentCreateManyArticleInput>;
 
-  @Field(() => Boolean, { nullable: true })
-  skipDuplicates?: boolean;
+    @Field(() => [CommentCreateManyArticleInput], {nullable:false})
+    @Type(() => CommentCreateManyArticleInput)
+    data!: Array<CommentCreateManyArticleInput>;
+
+    @Field(() => Boolean, {nullable:true})
+    skipDuplicates?: boolean;
 }
diff --git a/@generated/comment/comment-create-many-article.input.ts b/@generated/comment/comment-create-many-article.input.ts
index 85509527..3788547d 100644
--- a/@generated/comment/comment-create-many-article.input.ts
+++ b/@generated/comment/comment-create-many-article.input.ts
@@ -3,18 +3,19 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class CommentCreateManyArticleInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => Date, { nullable: true })
-  createdAt?: Date | string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => Date, { nullable: true })
-  updatedAt?: Date | string;
+    @Field(() => Date, {nullable:true})
+    createdAt?: Date | string;
 
-  @Field(() => String, { nullable: false })
-  body!: string;
+    @Field(() => Date, {nullable:true})
+    updatedAt?: Date | string;
 
-  @Field(() => String, { nullable: false })
-  authorId!: string;
+    @Field(() => String, {nullable:false})
+    body!: string;
+
+    @Field(() => String, {nullable:false})
+    authorId!: string;
 }
diff --git a/@generated/comment/comment-create-many-author-input-envelope.input.ts b/@generated/comment/comment-create-many-author-input-envelope.input.ts
index 61137975..2dd543bd 100644
--- a/@generated/comment/comment-create-many-author-input-envelope.input.ts
+++ b/@generated/comment/comment-create-many-author-input-envelope.input.ts
@@ -5,10 +5,11 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class CommentCreateManyAuthorInputEnvelope {
-  @Field(() => [CommentCreateManyAuthorInput], { nullable: false })
-  @Type(() => CommentCreateManyAuthorInput)
-  data!: Array<CommentCreateManyAuthorInput>;
 
-  @Field(() => Boolean, { nullable: true })
-  skipDuplicates?: boolean;
+    @Field(() => [CommentCreateManyAuthorInput], {nullable:false})
+    @Type(() => CommentCreateManyAuthorInput)
+    data!: Array<CommentCreateManyAuthorInput>;
+
+    @Field(() => Boolean, {nullable:true})
+    skipDuplicates?: boolean;
 }
diff --git a/@generated/comment/comment-create-many-author.input.ts b/@generated/comment/comment-create-many-author.input.ts
index 7d5866c1..de176c48 100644
--- a/@generated/comment/comment-create-many-author.input.ts
+++ b/@generated/comment/comment-create-many-author.input.ts
@@ -3,18 +3,19 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class CommentCreateManyAuthorInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => Date, { nullable: true })
-  createdAt?: Date | string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => Date, { nullable: true })
-  updatedAt?: Date | string;
+    @Field(() => Date, {nullable:true})
+    createdAt?: Date | string;
 
-  @Field(() => String, { nullable: false })
-  body!: string;
+    @Field(() => Date, {nullable:true})
+    updatedAt?: Date | string;
 
-  @Field(() => String, { nullable: true })
-  articleId?: string;
+    @Field(() => String, {nullable:false})
+    body!: string;
+
+    @Field(() => String, {nullable:true})
+    articleId?: string;
 }
diff --git a/@generated/comment/comment-create-many.input.ts b/@generated/comment/comment-create-many.input.ts
index b636adba..14919a8d 100644
--- a/@generated/comment/comment-create-many.input.ts
+++ b/@generated/comment/comment-create-many.input.ts
@@ -3,21 +3,22 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class CommentCreateManyInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => Date, { nullable: true })
-  createdAt?: Date | string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => Date, { nullable: true })
-  updatedAt?: Date | string;
+    @Field(() => Date, {nullable:true})
+    createdAt?: Date | string;
 
-  @Field(() => String, { nullable: false })
-  body!: string;
+    @Field(() => Date, {nullable:true})
+    updatedAt?: Date | string;
 
-  @Field(() => String, { nullable: false })
-  authorId!: string;
+    @Field(() => String, {nullable:false})
+    body!: string;
 
-  @Field(() => String, { nullable: true })
-  articleId?: string;
+    @Field(() => String, {nullable:false})
+    authorId!: string;
+
+    @Field(() => String, {nullable:true})
+    articleId?: string;
 }
diff --git a/@generated/comment/comment-create-nested-many-without-article.input.ts b/@generated/comment/comment-create-nested-many-without-article.input.ts
index 8f967a15..d8bff1ce 100644
--- a/@generated/comment/comment-create-nested-many-without-article.input.ts
+++ b/@generated/comment/comment-create-nested-many-without-article.input.ts
@@ -4,24 +4,25 @@ import { CommentCreateWithoutArticleInput } from './comment-create-without-artic
 import { Type } from 'class-transformer';
 import { CommentCreateOrConnectWithoutArticleInput } from './comment-create-or-connect-without-article.input';
 import { CommentCreateManyArticleInputEnvelope } from './comment-create-many-article-input-envelope.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { CommentWhereUniqueInput } from './comment-where-unique.input';
 
 @InputType()
 export class CommentCreateNestedManyWithoutArticleInput {
-  @Field(() => [CommentCreateWithoutArticleInput], { nullable: true })
-  @Type(() => CommentCreateWithoutArticleInput)
-  create?: Array<CommentCreateWithoutArticleInput>;
 
-  @Field(() => [CommentCreateOrConnectWithoutArticleInput], { nullable: true })
-  @Type(() => CommentCreateOrConnectWithoutArticleInput)
-  connectOrCreate?: Array<CommentCreateOrConnectWithoutArticleInput>;
+    @Field(() => [CommentCreateWithoutArticleInput], {nullable:true})
+    @Type(() => CommentCreateWithoutArticleInput)
+    create?: Array<CommentCreateWithoutArticleInput>;
 
-  @Field(() => CommentCreateManyArticleInputEnvelope, { nullable: true })
-  @Type(() => CommentCreateManyArticleInputEnvelope)
-  createMany?: CommentCreateManyArticleInputEnvelope;
+    @Field(() => [CommentCreateOrConnectWithoutArticleInput], {nullable:true})
+    @Type(() => CommentCreateOrConnectWithoutArticleInput)
+    connectOrCreate?: Array<CommentCreateOrConnectWithoutArticleInput>;
 
-  @Field(() => [CommentWhereUniqueInput], { nullable: true })
-  @Type(() => CommentWhereUniqueInput)
-  connect?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
+    @Field(() => CommentCreateManyArticleInputEnvelope, {nullable:true})
+    @Type(() => CommentCreateManyArticleInputEnvelope)
+    createMany?: CommentCreateManyArticleInputEnvelope;
+
+    @Field(() => [CommentWhereUniqueInput], {nullable:true})
+    @Type(() => CommentWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
 }
diff --git a/@generated/comment/comment-create-nested-many-without-author.input.ts b/@generated/comment/comment-create-nested-many-without-author.input.ts
index 673c0970..e0ee281b 100644
--- a/@generated/comment/comment-create-nested-many-without-author.input.ts
+++ b/@generated/comment/comment-create-nested-many-without-author.input.ts
@@ -4,24 +4,25 @@ import { CommentCreateWithoutAuthorInput } from './comment-create-without-author
 import { Type } from 'class-transformer';
 import { CommentCreateOrConnectWithoutAuthorInput } from './comment-create-or-connect-without-author.input';
 import { CommentCreateManyAuthorInputEnvelope } from './comment-create-many-author-input-envelope.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { CommentWhereUniqueInput } from './comment-where-unique.input';
 
 @InputType()
 export class CommentCreateNestedManyWithoutAuthorInput {
-  @Field(() => [CommentCreateWithoutAuthorInput], { nullable: true })
-  @Type(() => CommentCreateWithoutAuthorInput)
-  create?: Array<CommentCreateWithoutAuthorInput>;
 
-  @Field(() => [CommentCreateOrConnectWithoutAuthorInput], { nullable: true })
-  @Type(() => CommentCreateOrConnectWithoutAuthorInput)
-  connectOrCreate?: Array<CommentCreateOrConnectWithoutAuthorInput>;
+    @Field(() => [CommentCreateWithoutAuthorInput], {nullable:true})
+    @Type(() => CommentCreateWithoutAuthorInput)
+    create?: Array<CommentCreateWithoutAuthorInput>;
 
-  @Field(() => CommentCreateManyAuthorInputEnvelope, { nullable: true })
-  @Type(() => CommentCreateManyAuthorInputEnvelope)
-  createMany?: CommentCreateManyAuthorInputEnvelope;
+    @Field(() => [CommentCreateOrConnectWithoutAuthorInput], {nullable:true})
+    @Type(() => CommentCreateOrConnectWithoutAuthorInput)
+    connectOrCreate?: Array<CommentCreateOrConnectWithoutAuthorInput>;
 
-  @Field(() => [CommentWhereUniqueInput], { nullable: true })
-  @Type(() => CommentWhereUniqueInput)
-  connect?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
+    @Field(() => CommentCreateManyAuthorInputEnvelope, {nullable:true})
+    @Type(() => CommentCreateManyAuthorInputEnvelope)
+    createMany?: CommentCreateManyAuthorInputEnvelope;
+
+    @Field(() => [CommentWhereUniqueInput], {nullable:true})
+    @Type(() => CommentWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
 }
diff --git a/@generated/comment/comment-create-or-connect-without-article.input.ts b/@generated/comment/comment-create-or-connect-without-article.input.ts
index 8ab1608d..a79fe646 100644
--- a/@generated/comment/comment-create-or-connect-without-article.input.ts
+++ b/@generated/comment/comment-create-or-connect-without-article.input.ts
@@ -1,17 +1,18 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { CommentWhereUniqueInput } from './comment-where-unique.input';
 import { Type } from 'class-transformer';
 import { CommentCreateWithoutArticleInput } from './comment-create-without-article.input';
 
 @InputType()
 export class CommentCreateOrConnectWithoutArticleInput {
-  @Field(() => CommentWhereUniqueInput, { nullable: false })
-  @Type(() => CommentWhereUniqueInput)
-  where!: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
 
-  @Field(() => CommentCreateWithoutArticleInput, { nullable: false })
-  @Type(() => CommentCreateWithoutArticleInput)
-  create!: CommentCreateWithoutArticleInput;
+    @Field(() => CommentWhereUniqueInput, {nullable:false})
+    @Type(() => CommentWhereUniqueInput)
+    where!: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
+
+    @Field(() => CommentCreateWithoutArticleInput, {nullable:false})
+    @Type(() => CommentCreateWithoutArticleInput)
+    create!: CommentCreateWithoutArticleInput;
 }
diff --git a/@generated/comment/comment-create-or-connect-without-author.input.ts b/@generated/comment/comment-create-or-connect-without-author.input.ts
index 5e2cd441..5b9b82f8 100644
--- a/@generated/comment/comment-create-or-connect-without-author.input.ts
+++ b/@generated/comment/comment-create-or-connect-without-author.input.ts
@@ -1,17 +1,18 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { CommentWhereUniqueInput } from './comment-where-unique.input';
 import { Type } from 'class-transformer';
 import { CommentCreateWithoutAuthorInput } from './comment-create-without-author.input';
 
 @InputType()
 export class CommentCreateOrConnectWithoutAuthorInput {
-  @Field(() => CommentWhereUniqueInput, { nullable: false })
-  @Type(() => CommentWhereUniqueInput)
-  where!: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
 
-  @Field(() => CommentCreateWithoutAuthorInput, { nullable: false })
-  @Type(() => CommentCreateWithoutAuthorInput)
-  create!: CommentCreateWithoutAuthorInput;
+    @Field(() => CommentWhereUniqueInput, {nullable:false})
+    @Type(() => CommentWhereUniqueInput)
+    where!: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
+
+    @Field(() => CommentCreateWithoutAuthorInput, {nullable:false})
+    @Type(() => CommentCreateWithoutAuthorInput)
+    create!: CommentCreateWithoutAuthorInput;
 }
diff --git a/@generated/comment/comment-create-without-article.input.ts b/@generated/comment/comment-create-without-article.input.ts
index ab79a09a..b9c8937c 100644
--- a/@generated/comment/comment-create-without-article.input.ts
+++ b/@generated/comment/comment-create-without-article.input.ts
@@ -5,19 +5,20 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class CommentCreateWithoutArticleInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => Date, { nullable: true })
-  createdAt?: Date | string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => Date, { nullable: true })
-  updatedAt?: Date | string;
+    @Field(() => Date, {nullable:true})
+    createdAt?: Date | string;
 
-  @Field(() => String, { nullable: false })
-  body!: string;
+    @Field(() => Date, {nullable:true})
+    updatedAt?: Date | string;
 
-  @Field(() => UserCreateNestedOneWithoutCommentsInput, { nullable: false })
-  @Type(() => UserCreateNestedOneWithoutCommentsInput)
-  author!: UserCreateNestedOneWithoutCommentsInput;
+    @Field(() => String, {nullable:false})
+    body!: string;
+
+    @Field(() => UserCreateNestedOneWithoutCommentsInput, {nullable:false})
+    @Type(() => UserCreateNestedOneWithoutCommentsInput)
+    author!: UserCreateNestedOneWithoutCommentsInput;
 }
diff --git a/@generated/comment/comment-create-without-author.input.ts b/@generated/comment/comment-create-without-author.input.ts
index 86d9aaba..55c39af5 100644
--- a/@generated/comment/comment-create-without-author.input.ts
+++ b/@generated/comment/comment-create-without-author.input.ts
@@ -5,19 +5,20 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class CommentCreateWithoutAuthorInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => Date, { nullable: true })
-  createdAt?: Date | string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => Date, { nullable: true })
-  updatedAt?: Date | string;
+    @Field(() => Date, {nullable:true})
+    createdAt?: Date | string;
 
-  @Field(() => String, { nullable: false })
-  body!: string;
+    @Field(() => Date, {nullable:true})
+    updatedAt?: Date | string;
 
-  @Field(() => ArticleCreateNestedOneWithoutCommentsInput, { nullable: true })
-  @Type(() => ArticleCreateNestedOneWithoutCommentsInput)
-  article?: ArticleCreateNestedOneWithoutCommentsInput;
+    @Field(() => String, {nullable:false})
+    body!: string;
+
+    @Field(() => ArticleCreateNestedOneWithoutCommentsInput, {nullable:true})
+    @Type(() => ArticleCreateNestedOneWithoutCommentsInput)
+    article?: ArticleCreateNestedOneWithoutCommentsInput;
 }
diff --git a/@generated/comment/comment-create.input.ts b/@generated/comment/comment-create.input.ts
index 82fa85e1..fb9dc042 100644
--- a/@generated/comment/comment-create.input.ts
+++ b/@generated/comment/comment-create.input.ts
@@ -6,23 +6,24 @@ import { ArticleCreateNestedOneWithoutCommentsInput } from '../article/article-c
 
 @InputType()
 export class CommentCreateInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => Date, { nullable: true })
-  createdAt?: Date | string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => Date, { nullable: true })
-  updatedAt?: Date | string;
+    @Field(() => Date, {nullable:true})
+    createdAt?: Date | string;
 
-  @Field(() => String, { nullable: false })
-  body!: string;
+    @Field(() => Date, {nullable:true})
+    updatedAt?: Date | string;
 
-  @Field(() => UserCreateNestedOneWithoutCommentsInput, { nullable: false })
-  @Type(() => UserCreateNestedOneWithoutCommentsInput)
-  author!: UserCreateNestedOneWithoutCommentsInput;
+    @Field(() => String, {nullable:false})
+    body!: string;
 
-  @Field(() => ArticleCreateNestedOneWithoutCommentsInput, { nullable: true })
-  @Type(() => ArticleCreateNestedOneWithoutCommentsInput)
-  article?: ArticleCreateNestedOneWithoutCommentsInput;
+    @Field(() => UserCreateNestedOneWithoutCommentsInput, {nullable:false})
+    @Type(() => UserCreateNestedOneWithoutCommentsInput)
+    author!: UserCreateNestedOneWithoutCommentsInput;
+
+    @Field(() => ArticleCreateNestedOneWithoutCommentsInput, {nullable:true})
+    @Type(() => ArticleCreateNestedOneWithoutCommentsInput)
+    article?: ArticleCreateNestedOneWithoutCommentsInput;
 }
diff --git a/@generated/comment/comment-group-by.args.ts b/@generated/comment/comment-group-by.args.ts
index 436a0eb4..a3521aba 100644
--- a/@generated/comment/comment-group-by.args.ts
+++ b/@generated/comment/comment-group-by.args.ts
@@ -12,31 +12,32 @@ import { CommentMaxAggregateInput } from './comment-max-aggregate.input';
 
 @ArgsType()
 export class CommentGroupByArgs {
-  @Field(() => CommentWhereInput, { nullable: true })
-  @Type(() => CommentWhereInput)
-  where?: CommentWhereInput;
 
-  @Field(() => [CommentOrderByWithAggregationInput], { nullable: true })
-  orderBy?: Array<CommentOrderByWithAggregationInput>;
+    @Field(() => CommentWhereInput, {nullable:true})
+    @Type(() => CommentWhereInput)
+    where?: CommentWhereInput;
 
-  @Field(() => [CommentScalarFieldEnum], { nullable: false })
-  by!: Array<keyof typeof CommentScalarFieldEnum>;
+    @Field(() => [CommentOrderByWithAggregationInput], {nullable:true})
+    orderBy?: Array<CommentOrderByWithAggregationInput>;
 
-  @Field(() => CommentScalarWhereWithAggregatesInput, { nullable: true })
-  having?: CommentScalarWhereWithAggregatesInput;
+    @Field(() => [CommentScalarFieldEnum], {nullable:false})
+    by!: Array<keyof typeof CommentScalarFieldEnum>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => CommentScalarWhereWithAggregatesInput, {nullable:true})
+    having?: CommentScalarWhereWithAggregatesInput;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => CommentCountAggregateInput, { nullable: true })
-  _count?: CommentCountAggregateInput;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
 
-  @Field(() => CommentMinAggregateInput, { nullable: true })
-  _min?: CommentMinAggregateInput;
+    @Field(() => CommentCountAggregateInput, {nullable:true})
+    _count?: CommentCountAggregateInput;
 
-  @Field(() => CommentMaxAggregateInput, { nullable: true })
-  _max?: CommentMaxAggregateInput;
+    @Field(() => CommentMinAggregateInput, {nullable:true})
+    _min?: CommentMinAggregateInput;
+
+    @Field(() => CommentMaxAggregateInput, {nullable:true})
+    _max?: CommentMaxAggregateInput;
 }
diff --git a/@generated/comment/comment-group-by.output.ts b/@generated/comment/comment-group-by.output.ts
index 0969c04e..956d0f2c 100644
--- a/@generated/comment/comment-group-by.output.ts
+++ b/@generated/comment/comment-group-by.output.ts
@@ -6,30 +6,31 @@ import { CommentMaxAggregate } from './comment-max-aggregate.output';
 
 @ObjectType()
 export class CommentGroupBy {
-  @Field(() => String, { nullable: false })
-  id!: string;
 
-  @Field(() => Date, { nullable: false })
-  createdAt!: Date | string;
+    @Field(() => String, {nullable:false})
+    id!: string;
 
-  @Field(() => Date, { nullable: false })
-  updatedAt!: Date | string;
+    @Field(() => Date, {nullable:false})
+    createdAt!: Date | string;
 
-  @Field(() => String, { nullable: false })
-  body!: string;
+    @Field(() => Date, {nullable:false})
+    updatedAt!: Date | string;
 
-  @Field(() => String, { nullable: false })
-  authorId!: string;
+    @Field(() => String, {nullable:false})
+    body!: string;
 
-  @Field(() => String, { nullable: true })
-  articleId?: string;
+    @Field(() => String, {nullable:false})
+    authorId!: string;
 
-  @Field(() => CommentCountAggregate, { nullable: true })
-  _count?: CommentCountAggregate;
+    @Field(() => String, {nullable:true})
+    articleId?: string;
 
-  @Field(() => CommentMinAggregate, { nullable: true })
-  _min?: CommentMinAggregate;
+    @Field(() => CommentCountAggregate, {nullable:true})
+    _count?: CommentCountAggregate;
 
-  @Field(() => CommentMaxAggregate, { nullable: true })
-  _max?: CommentMaxAggregate;
+    @Field(() => CommentMinAggregate, {nullable:true})
+    _min?: CommentMinAggregate;
+
+    @Field(() => CommentMaxAggregate, {nullable:true})
+    _max?: CommentMaxAggregate;
 }
diff --git a/@generated/comment/comment-list-relation-filter.input.ts b/@generated/comment/comment-list-relation-filter.input.ts
index 7e058603..5f2ca5b2 100644
--- a/@generated/comment/comment-list-relation-filter.input.ts
+++ b/@generated/comment/comment-list-relation-filter.input.ts
@@ -4,12 +4,13 @@ import { CommentWhereInput } from './comment-where.input';
 
 @InputType()
 export class CommentListRelationFilter {
-  @Field(() => CommentWhereInput, { nullable: true })
-  every?: CommentWhereInput;
 
-  @Field(() => CommentWhereInput, { nullable: true })
-  some?: CommentWhereInput;
+    @Field(() => CommentWhereInput, {nullable:true})
+    every?: CommentWhereInput;
 
-  @Field(() => CommentWhereInput, { nullable: true })
-  none?: CommentWhereInput;
+    @Field(() => CommentWhereInput, {nullable:true})
+    some?: CommentWhereInput;
+
+    @Field(() => CommentWhereInput, {nullable:true})
+    none?: CommentWhereInput;
 }
diff --git a/@generated/comment/comment-max-aggregate.input.ts b/@generated/comment/comment-max-aggregate.input.ts
index fdeb0b9d..251fedcc 100644
--- a/@generated/comment/comment-max-aggregate.input.ts
+++ b/@generated/comment/comment-max-aggregate.input.ts
@@ -3,21 +3,22 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class CommentMaxAggregateInput {
-  @Field(() => Boolean, { nullable: true })
-  id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  createdAt?: true;
+    @Field(() => Boolean, {nullable:true})
+    id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  updatedAt?: true;
+    @Field(() => Boolean, {nullable:true})
+    createdAt?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  body?: true;
+    @Field(() => Boolean, {nullable:true})
+    updatedAt?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  authorId?: true;
+    @Field(() => Boolean, {nullable:true})
+    body?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  articleId?: true;
+    @Field(() => Boolean, {nullable:true})
+    authorId?: true;
+
+    @Field(() => Boolean, {nullable:true})
+    articleId?: true;
 }
diff --git a/@generated/comment/comment-max-aggregate.output.ts b/@generated/comment/comment-max-aggregate.output.ts
index ab979fb7..6f437680 100644
--- a/@generated/comment/comment-max-aggregate.output.ts
+++ b/@generated/comment/comment-max-aggregate.output.ts
@@ -3,21 +3,22 @@ import { ObjectType } from '@nestjs/graphql';
 
 @ObjectType()
 export class CommentMaxAggregate {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => Date, { nullable: true })
-  createdAt?: Date | string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => Date, { nullable: true })
-  updatedAt?: Date | string;
+    @Field(() => Date, {nullable:true})
+    createdAt?: Date | string;
 
-  @Field(() => String, { nullable: true })
-  body?: string;
+    @Field(() => Date, {nullable:true})
+    updatedAt?: Date | string;
 
-  @Field(() => String, { nullable: true })
-  authorId?: string;
+    @Field(() => String, {nullable:true})
+    body?: string;
 
-  @Field(() => String, { nullable: true })
-  articleId?: string;
+    @Field(() => String, {nullable:true})
+    authorId?: string;
+
+    @Field(() => String, {nullable:true})
+    articleId?: string;
 }
diff --git a/@generated/comment/comment-max-order-by-aggregate.input.ts b/@generated/comment/comment-max-order-by-aggregate.input.ts
index faf5254f..f66b9fff 100644
--- a/@generated/comment/comment-max-order-by-aggregate.input.ts
+++ b/@generated/comment/comment-max-order-by-aggregate.input.ts
@@ -4,21 +4,22 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class CommentMaxOrderByAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  createdAt?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  updatedAt?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    createdAt?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  body?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    updatedAt?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  authorId?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    body?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  articleId?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    authorId?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    articleId?: keyof typeof SortOrder;
 }
diff --git a/@generated/comment/comment-min-aggregate.input.ts b/@generated/comment/comment-min-aggregate.input.ts
index 44330cad..dc195f09 100644
--- a/@generated/comment/comment-min-aggregate.input.ts
+++ b/@generated/comment/comment-min-aggregate.input.ts
@@ -3,21 +3,22 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class CommentMinAggregateInput {
-  @Field(() => Boolean, { nullable: true })
-  id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  createdAt?: true;
+    @Field(() => Boolean, {nullable:true})
+    id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  updatedAt?: true;
+    @Field(() => Boolean, {nullable:true})
+    createdAt?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  body?: true;
+    @Field(() => Boolean, {nullable:true})
+    updatedAt?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  authorId?: true;
+    @Field(() => Boolean, {nullable:true})
+    body?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  articleId?: true;
+    @Field(() => Boolean, {nullable:true})
+    authorId?: true;
+
+    @Field(() => Boolean, {nullable:true})
+    articleId?: true;
 }
diff --git a/@generated/comment/comment-min-aggregate.output.ts b/@generated/comment/comment-min-aggregate.output.ts
index 90824433..e54c1bca 100644
--- a/@generated/comment/comment-min-aggregate.output.ts
+++ b/@generated/comment/comment-min-aggregate.output.ts
@@ -3,21 +3,22 @@ import { ObjectType } from '@nestjs/graphql';
 
 @ObjectType()
 export class CommentMinAggregate {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => Date, { nullable: true })
-  createdAt?: Date | string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => Date, { nullable: true })
-  updatedAt?: Date | string;
+    @Field(() => Date, {nullable:true})
+    createdAt?: Date | string;
 
-  @Field(() => String, { nullable: true })
-  body?: string;
+    @Field(() => Date, {nullable:true})
+    updatedAt?: Date | string;
 
-  @Field(() => String, { nullable: true })
-  authorId?: string;
+    @Field(() => String, {nullable:true})
+    body?: string;
 
-  @Field(() => String, { nullable: true })
-  articleId?: string;
+    @Field(() => String, {nullable:true})
+    authorId?: string;
+
+    @Field(() => String, {nullable:true})
+    articleId?: string;
 }
diff --git a/@generated/comment/comment-min-order-by-aggregate.input.ts b/@generated/comment/comment-min-order-by-aggregate.input.ts
index d4910358..abf0a72e 100644
--- a/@generated/comment/comment-min-order-by-aggregate.input.ts
+++ b/@generated/comment/comment-min-order-by-aggregate.input.ts
@@ -4,21 +4,22 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class CommentMinOrderByAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  createdAt?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  updatedAt?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    createdAt?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  body?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    updatedAt?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  authorId?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    body?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  articleId?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    authorId?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    articleId?: keyof typeof SortOrder;
 }
diff --git a/@generated/comment/comment-order-by-relation-aggregate.input.ts b/@generated/comment/comment-order-by-relation-aggregate.input.ts
index 8124b8ab..6e4cb181 100644
--- a/@generated/comment/comment-order-by-relation-aggregate.input.ts
+++ b/@generated/comment/comment-order-by-relation-aggregate.input.ts
@@ -4,6 +4,7 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class CommentOrderByRelationAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  _count?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    _count?: keyof typeof SortOrder;
 }
diff --git a/@generated/comment/comment-order-by-relevance-field.enum.ts b/@generated/comment/comment-order-by-relevance-field.enum.ts
index 9e0adcd2..52e33490 100644
--- a/@generated/comment/comment-order-by-relevance-field.enum.ts
+++ b/@generated/comment/comment-order-by-relevance-field.enum.ts
@@ -1,13 +1,11 @@
 import { registerEnumType } from '@nestjs/graphql';
 
 export enum CommentOrderByRelevanceFieldEnum {
-  id = 'id',
-  body = 'body',
-  authorId = 'authorId',
-  articleId = 'articleId',
+    id = "id",
+    body = "body",
+    authorId = "authorId",
+    articleId = "articleId"
 }
 
-registerEnumType(CommentOrderByRelevanceFieldEnum, {
-  name: 'CommentOrderByRelevanceFieldEnum',
-  description: undefined,
-});
+
+registerEnumType(CommentOrderByRelevanceFieldEnum, { name: 'CommentOrderByRelevanceFieldEnum', description: undefined })
diff --git a/@generated/comment/comment-order-by-relevance.input.ts b/@generated/comment/comment-order-by-relevance.input.ts
index 7ec03576..698e00f1 100644
--- a/@generated/comment/comment-order-by-relevance.input.ts
+++ b/@generated/comment/comment-order-by-relevance.input.ts
@@ -5,12 +5,13 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class CommentOrderByRelevanceInput {
-  @Field(() => [CommentOrderByRelevanceFieldEnum], { nullable: false })
-  fields!: Array<keyof typeof CommentOrderByRelevanceFieldEnum>;
 
-  @Field(() => SortOrder, { nullable: false })
-  sort!: keyof typeof SortOrder;
+    @Field(() => [CommentOrderByRelevanceFieldEnum], {nullable:false})
+    fields!: Array<keyof typeof CommentOrderByRelevanceFieldEnum>;
 
-  @Field(() => String, { nullable: false })
-  search!: string;
+    @Field(() => SortOrder, {nullable:false})
+    sort!: keyof typeof SortOrder;
+
+    @Field(() => String, {nullable:false})
+    search!: string;
 }
diff --git a/@generated/comment/comment-order-by-with-aggregation.input.ts b/@generated/comment/comment-order-by-with-aggregation.input.ts
index 0e4bade7..75a15739 100644
--- a/@generated/comment/comment-order-by-with-aggregation.input.ts
+++ b/@generated/comment/comment-order-by-with-aggregation.input.ts
@@ -8,30 +8,31 @@ import { CommentMinOrderByAggregateInput } from './comment-min-order-by-aggregat
 
 @InputType()
 export class CommentOrderByWithAggregationInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  createdAt?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  updatedAt?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    createdAt?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  body?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    updatedAt?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  authorId?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    body?: keyof typeof SortOrder;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  articleId?: SortOrderInput;
+    @Field(() => SortOrder, {nullable:true})
+    authorId?: keyof typeof SortOrder;
 
-  @Field(() => CommentCountOrderByAggregateInput, { nullable: true })
-  _count?: CommentCountOrderByAggregateInput;
+    @Field(() => SortOrderInput, {nullable:true})
+    articleId?: SortOrderInput;
 
-  @Field(() => CommentMaxOrderByAggregateInput, { nullable: true })
-  _max?: CommentMaxOrderByAggregateInput;
+    @Field(() => CommentCountOrderByAggregateInput, {nullable:true})
+    _count?: CommentCountOrderByAggregateInput;
 
-  @Field(() => CommentMinOrderByAggregateInput, { nullable: true })
-  _min?: CommentMinOrderByAggregateInput;
+    @Field(() => CommentMaxOrderByAggregateInput, {nullable:true})
+    _max?: CommentMaxOrderByAggregateInput;
+
+    @Field(() => CommentMinOrderByAggregateInput, {nullable:true})
+    _min?: CommentMinOrderByAggregateInput;
 }
diff --git a/@generated/comment/comment-order-by-with-relation-and-search-relevance.input.ts b/@generated/comment/comment-order-by-with-relation-and-search-relevance.input.ts
index ac12030c..f76d6aec 100644
--- a/@generated/comment/comment-order-by-with-relation-and-search-relevance.input.ts
+++ b/@generated/comment/comment-order-by-with-relation-and-search-relevance.input.ts
@@ -9,32 +9,33 @@ import { CommentOrderByRelevanceInput } from './comment-order-by-relevance.input
 
 @InputType()
 export class CommentOrderByWithRelationAndSearchRelevanceInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  createdAt?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  updatedAt?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    createdAt?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  body?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    updatedAt?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  authorId?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    body?: keyof typeof SortOrder;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  articleId?: SortOrderInput;
+    @Field(() => SortOrder, {nullable:true})
+    authorId?: keyof typeof SortOrder;
 
-  @Field(() => UserOrderByWithRelationAndSearchRelevanceInput, { nullable: true })
-  @Type(() => UserOrderByWithRelationAndSearchRelevanceInput)
-  author?: UserOrderByWithRelationAndSearchRelevanceInput;
+    @Field(() => SortOrderInput, {nullable:true})
+    articleId?: SortOrderInput;
 
-  @Field(() => ArticleOrderByWithRelationAndSearchRelevanceInput, { nullable: true })
-  @Type(() => ArticleOrderByWithRelationAndSearchRelevanceInput)
-  article?: ArticleOrderByWithRelationAndSearchRelevanceInput;
+    @Field(() => UserOrderByWithRelationAndSearchRelevanceInput, {nullable:true})
+    @Type(() => UserOrderByWithRelationAndSearchRelevanceInput)
+    author?: UserOrderByWithRelationAndSearchRelevanceInput;
 
-  @Field(() => CommentOrderByRelevanceInput, { nullable: true })
-  _relevance?: CommentOrderByRelevanceInput;
+    @Field(() => ArticleOrderByWithRelationAndSearchRelevanceInput, {nullable:true})
+    @Type(() => ArticleOrderByWithRelationAndSearchRelevanceInput)
+    article?: ArticleOrderByWithRelationAndSearchRelevanceInput;
+
+    @Field(() => CommentOrderByRelevanceInput, {nullable:true})
+    _relevance?: CommentOrderByRelevanceInput;
 }
diff --git a/@generated/comment/comment-scalar-field.enum.ts b/@generated/comment/comment-scalar-field.enum.ts
index 075d0872..6abd3a9a 100644
--- a/@generated/comment/comment-scalar-field.enum.ts
+++ b/@generated/comment/comment-scalar-field.enum.ts
@@ -1,15 +1,13 @@
 import { registerEnumType } from '@nestjs/graphql';
 
 export enum CommentScalarFieldEnum {
-  id = 'id',
-  createdAt = 'createdAt',
-  updatedAt = 'updatedAt',
-  body = 'body',
-  authorId = 'authorId',
-  articleId = 'articleId',
+    id = "id",
+    createdAt = "createdAt",
+    updatedAt = "updatedAt",
+    body = "body",
+    authorId = "authorId",
+    articleId = "articleId"
 }
 
-registerEnumType(CommentScalarFieldEnum, {
-  name: 'CommentScalarFieldEnum',
-  description: undefined,
-});
+
+registerEnumType(CommentScalarFieldEnum, { name: 'CommentScalarFieldEnum', description: undefined })
diff --git a/@generated/comment/comment-scalar-where-with-aggregates.input.ts b/@generated/comment/comment-scalar-where-with-aggregates.input.ts
index 8d613335..3d4caaac 100644
--- a/@generated/comment/comment-scalar-where-with-aggregates.input.ts
+++ b/@generated/comment/comment-scalar-where-with-aggregates.input.ts
@@ -6,30 +6,31 @@ import { StringNullableWithAggregatesFilter } from '../prisma/string-nullable-wi
 
 @InputType()
 export class CommentScalarWhereWithAggregatesInput {
-  @Field(() => [CommentScalarWhereWithAggregatesInput], { nullable: true })
-  AND?: Array<CommentScalarWhereWithAggregatesInput>;
 
-  @Field(() => [CommentScalarWhereWithAggregatesInput], { nullable: true })
-  OR?: Array<CommentScalarWhereWithAggregatesInput>;
+    @Field(() => [CommentScalarWhereWithAggregatesInput], {nullable:true})
+    AND?: Array<CommentScalarWhereWithAggregatesInput>;
 
-  @Field(() => [CommentScalarWhereWithAggregatesInput], { nullable: true })
-  NOT?: Array<CommentScalarWhereWithAggregatesInput>;
+    @Field(() => [CommentScalarWhereWithAggregatesInput], {nullable:true})
+    OR?: Array<CommentScalarWhereWithAggregatesInput>;
 
-  @Field(() => StringWithAggregatesFilter, { nullable: true })
-  id?: StringWithAggregatesFilter;
+    @Field(() => [CommentScalarWhereWithAggregatesInput], {nullable:true})
+    NOT?: Array<CommentScalarWhereWithAggregatesInput>;
 
-  @Field(() => DateTimeWithAggregatesFilter, { nullable: true })
-  createdAt?: DateTimeWithAggregatesFilter;
+    @Field(() => StringWithAggregatesFilter, {nullable:true})
+    id?: StringWithAggregatesFilter;
 
-  @Field(() => DateTimeWithAggregatesFilter, { nullable: true })
-  updatedAt?: DateTimeWithAggregatesFilter;
+    @Field(() => DateTimeWithAggregatesFilter, {nullable:true})
+    createdAt?: DateTimeWithAggregatesFilter;
 
-  @Field(() => StringWithAggregatesFilter, { nullable: true })
-  body?: StringWithAggregatesFilter;
+    @Field(() => DateTimeWithAggregatesFilter, {nullable:true})
+    updatedAt?: DateTimeWithAggregatesFilter;
 
-  @Field(() => StringWithAggregatesFilter, { nullable: true })
-  authorId?: StringWithAggregatesFilter;
+    @Field(() => StringWithAggregatesFilter, {nullable:true})
+    body?: StringWithAggregatesFilter;
 
-  @Field(() => StringNullableWithAggregatesFilter, { nullable: true })
-  articleId?: StringNullableWithAggregatesFilter;
+    @Field(() => StringWithAggregatesFilter, {nullable:true})
+    authorId?: StringWithAggregatesFilter;
+
+    @Field(() => StringNullableWithAggregatesFilter, {nullable:true})
+    articleId?: StringNullableWithAggregatesFilter;
 }
diff --git a/@generated/comment/comment-scalar-where.input.ts b/@generated/comment/comment-scalar-where.input.ts
index 2df79cb9..030467d5 100644
--- a/@generated/comment/comment-scalar-where.input.ts
+++ b/@generated/comment/comment-scalar-where.input.ts
@@ -6,30 +6,31 @@ import { StringNullableFilter } from '../prisma/string-nullable-filter.input';
 
 @InputType()
 export class CommentScalarWhereInput {
-  @Field(() => [CommentScalarWhereInput], { nullable: true })
-  AND?: Array<CommentScalarWhereInput>;
 
-  @Field(() => [CommentScalarWhereInput], { nullable: true })
-  OR?: Array<CommentScalarWhereInput>;
+    @Field(() => [CommentScalarWhereInput], {nullable:true})
+    AND?: Array<CommentScalarWhereInput>;
 
-  @Field(() => [CommentScalarWhereInput], { nullable: true })
-  NOT?: Array<CommentScalarWhereInput>;
+    @Field(() => [CommentScalarWhereInput], {nullable:true})
+    OR?: Array<CommentScalarWhereInput>;
 
-  @Field(() => StringFilter, { nullable: true })
-  id?: StringFilter;
+    @Field(() => [CommentScalarWhereInput], {nullable:true})
+    NOT?: Array<CommentScalarWhereInput>;
 
-  @Field(() => DateTimeFilter, { nullable: true })
-  createdAt?: DateTimeFilter;
+    @Field(() => StringFilter, {nullable:true})
+    id?: StringFilter;
 
-  @Field(() => DateTimeFilter, { nullable: true })
-  updatedAt?: DateTimeFilter;
+    @Field(() => DateTimeFilter, {nullable:true})
+    createdAt?: DateTimeFilter;
 
-  @Field(() => StringFilter, { nullable: true })
-  body?: StringFilter;
+    @Field(() => DateTimeFilter, {nullable:true})
+    updatedAt?: DateTimeFilter;
 
-  @Field(() => StringFilter, { nullable: true })
-  authorId?: StringFilter;
+    @Field(() => StringFilter, {nullable:true})
+    body?: StringFilter;
 
-  @Field(() => StringNullableFilter, { nullable: true })
-  articleId?: StringNullableFilter;
+    @Field(() => StringFilter, {nullable:true})
+    authorId?: StringFilter;
+
+    @Field(() => StringNullableFilter, {nullable:true})
+    articleId?: StringNullableFilter;
 }
diff --git a/@generated/comment/comment-unchecked-create-nested-many-without-article.input.ts b/@generated/comment/comment-unchecked-create-nested-many-without-article.input.ts
index 9a93249e..c7ce3c33 100644
--- a/@generated/comment/comment-unchecked-create-nested-many-without-article.input.ts
+++ b/@generated/comment/comment-unchecked-create-nested-many-without-article.input.ts
@@ -4,24 +4,25 @@ import { CommentCreateWithoutArticleInput } from './comment-create-without-artic
 import { Type } from 'class-transformer';
 import { CommentCreateOrConnectWithoutArticleInput } from './comment-create-or-connect-without-article.input';
 import { CommentCreateManyArticleInputEnvelope } from './comment-create-many-article-input-envelope.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { CommentWhereUniqueInput } from './comment-where-unique.input';
 
 @InputType()
 export class CommentUncheckedCreateNestedManyWithoutArticleInput {
-  @Field(() => [CommentCreateWithoutArticleInput], { nullable: true })
-  @Type(() => CommentCreateWithoutArticleInput)
-  create?: Array<CommentCreateWithoutArticleInput>;
 
-  @Field(() => [CommentCreateOrConnectWithoutArticleInput], { nullable: true })
-  @Type(() => CommentCreateOrConnectWithoutArticleInput)
-  connectOrCreate?: Array<CommentCreateOrConnectWithoutArticleInput>;
+    @Field(() => [CommentCreateWithoutArticleInput], {nullable:true})
+    @Type(() => CommentCreateWithoutArticleInput)
+    create?: Array<CommentCreateWithoutArticleInput>;
 
-  @Field(() => CommentCreateManyArticleInputEnvelope, { nullable: true })
-  @Type(() => CommentCreateManyArticleInputEnvelope)
-  createMany?: CommentCreateManyArticleInputEnvelope;
+    @Field(() => [CommentCreateOrConnectWithoutArticleInput], {nullable:true})
+    @Type(() => CommentCreateOrConnectWithoutArticleInput)
+    connectOrCreate?: Array<CommentCreateOrConnectWithoutArticleInput>;
 
-  @Field(() => [CommentWhereUniqueInput], { nullable: true })
-  @Type(() => CommentWhereUniqueInput)
-  connect?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
+    @Field(() => CommentCreateManyArticleInputEnvelope, {nullable:true})
+    @Type(() => CommentCreateManyArticleInputEnvelope)
+    createMany?: CommentCreateManyArticleInputEnvelope;
+
+    @Field(() => [CommentWhereUniqueInput], {nullable:true})
+    @Type(() => CommentWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
 }
diff --git a/@generated/comment/comment-unchecked-create-nested-many-without-author.input.ts b/@generated/comment/comment-unchecked-create-nested-many-without-author.input.ts
index 818e5765..d068961b 100644
--- a/@generated/comment/comment-unchecked-create-nested-many-without-author.input.ts
+++ b/@generated/comment/comment-unchecked-create-nested-many-without-author.input.ts
@@ -4,24 +4,25 @@ import { CommentCreateWithoutAuthorInput } from './comment-create-without-author
 import { Type } from 'class-transformer';
 import { CommentCreateOrConnectWithoutAuthorInput } from './comment-create-or-connect-without-author.input';
 import { CommentCreateManyAuthorInputEnvelope } from './comment-create-many-author-input-envelope.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { CommentWhereUniqueInput } from './comment-where-unique.input';
 
 @InputType()
 export class CommentUncheckedCreateNestedManyWithoutAuthorInput {
-  @Field(() => [CommentCreateWithoutAuthorInput], { nullable: true })
-  @Type(() => CommentCreateWithoutAuthorInput)
-  create?: Array<CommentCreateWithoutAuthorInput>;
 
-  @Field(() => [CommentCreateOrConnectWithoutAuthorInput], { nullable: true })
-  @Type(() => CommentCreateOrConnectWithoutAuthorInput)
-  connectOrCreate?: Array<CommentCreateOrConnectWithoutAuthorInput>;
+    @Field(() => [CommentCreateWithoutAuthorInput], {nullable:true})
+    @Type(() => CommentCreateWithoutAuthorInput)
+    create?: Array<CommentCreateWithoutAuthorInput>;
 
-  @Field(() => CommentCreateManyAuthorInputEnvelope, { nullable: true })
-  @Type(() => CommentCreateManyAuthorInputEnvelope)
-  createMany?: CommentCreateManyAuthorInputEnvelope;
+    @Field(() => [CommentCreateOrConnectWithoutAuthorInput], {nullable:true})
+    @Type(() => CommentCreateOrConnectWithoutAuthorInput)
+    connectOrCreate?: Array<CommentCreateOrConnectWithoutAuthorInput>;
 
-  @Field(() => [CommentWhereUniqueInput], { nullable: true })
-  @Type(() => CommentWhereUniqueInput)
-  connect?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
+    @Field(() => CommentCreateManyAuthorInputEnvelope, {nullable:true})
+    @Type(() => CommentCreateManyAuthorInputEnvelope)
+    createMany?: CommentCreateManyAuthorInputEnvelope;
+
+    @Field(() => [CommentWhereUniqueInput], {nullable:true})
+    @Type(() => CommentWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
 }
diff --git a/@generated/comment/comment-unchecked-create-without-article.input.ts b/@generated/comment/comment-unchecked-create-without-article.input.ts
index 7a7fc62e..0cdb1773 100644
--- a/@generated/comment/comment-unchecked-create-without-article.input.ts
+++ b/@generated/comment/comment-unchecked-create-without-article.input.ts
@@ -3,18 +3,19 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class CommentUncheckedCreateWithoutArticleInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => Date, { nullable: true })
-  createdAt?: Date | string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => Date, { nullable: true })
-  updatedAt?: Date | string;
+    @Field(() => Date, {nullable:true})
+    createdAt?: Date | string;
 
-  @Field(() => String, { nullable: false })
-  body!: string;
+    @Field(() => Date, {nullable:true})
+    updatedAt?: Date | string;
 
-  @Field(() => String, { nullable: false })
-  authorId!: string;
+    @Field(() => String, {nullable:false})
+    body!: string;
+
+    @Field(() => String, {nullable:false})
+    authorId!: string;
 }
diff --git a/@generated/comment/comment-unchecked-create-without-author.input.ts b/@generated/comment/comment-unchecked-create-without-author.input.ts
index e1e5c600..b5e2825a 100644
--- a/@generated/comment/comment-unchecked-create-without-author.input.ts
+++ b/@generated/comment/comment-unchecked-create-without-author.input.ts
@@ -3,18 +3,19 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class CommentUncheckedCreateWithoutAuthorInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => Date, { nullable: true })
-  createdAt?: Date | string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => Date, { nullable: true })
-  updatedAt?: Date | string;
+    @Field(() => Date, {nullable:true})
+    createdAt?: Date | string;
 
-  @Field(() => String, { nullable: false })
-  body!: string;
+    @Field(() => Date, {nullable:true})
+    updatedAt?: Date | string;
 
-  @Field(() => String, { nullable: true })
-  articleId?: string;
+    @Field(() => String, {nullable:false})
+    body!: string;
+
+    @Field(() => String, {nullable:true})
+    articleId?: string;
 }
diff --git a/@generated/comment/comment-unchecked-create.input.ts b/@generated/comment/comment-unchecked-create.input.ts
index f1b76c78..73af0b75 100644
--- a/@generated/comment/comment-unchecked-create.input.ts
+++ b/@generated/comment/comment-unchecked-create.input.ts
@@ -3,21 +3,22 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class CommentUncheckedCreateInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => Date, { nullable: true })
-  createdAt?: Date | string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => Date, { nullable: true })
-  updatedAt?: Date | string;
+    @Field(() => Date, {nullable:true})
+    createdAt?: Date | string;
 
-  @Field(() => String, { nullable: false })
-  body!: string;
+    @Field(() => Date, {nullable:true})
+    updatedAt?: Date | string;
 
-  @Field(() => String, { nullable: false })
-  authorId!: string;
+    @Field(() => String, {nullable:false})
+    body!: string;
 
-  @Field(() => String, { nullable: true })
-  articleId?: string;
+    @Field(() => String, {nullable:false})
+    authorId!: string;
+
+    @Field(() => String, {nullable:true})
+    articleId?: string;
 }
diff --git a/@generated/comment/comment-unchecked-update-many-without-article-nested.input.ts b/@generated/comment/comment-unchecked-update-many-without-article-nested.input.ts
index fbdd8626..e1af7c6f 100644
--- a/@generated/comment/comment-unchecked-update-many-without-article-nested.input.ts
+++ b/@generated/comment/comment-unchecked-update-many-without-article-nested.input.ts
@@ -5,7 +5,7 @@ import { Type } from 'class-transformer';
 import { CommentCreateOrConnectWithoutArticleInput } from './comment-create-or-connect-without-article.input';
 import { CommentUpsertWithWhereUniqueWithoutArticleInput } from './comment-upsert-with-where-unique-without-article.input';
 import { CommentCreateManyArticleInputEnvelope } from './comment-create-many-article-input-envelope.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { CommentWhereUniqueInput } from './comment-where-unique.input';
 import { CommentUpdateWithWhereUniqueWithoutArticleInput } from './comment-update-with-where-unique-without-article.input';
 import { CommentUpdateManyWithWhereWithoutArticleInput } from './comment-update-many-with-where-without-article.input';
@@ -13,47 +13,48 @@ import { CommentScalarWhereInput } from './comment-scalar-where.input';
 
 @InputType()
 export class CommentUncheckedUpdateManyWithoutArticleNestedInput {
-  @Field(() => [CommentCreateWithoutArticleInput], { nullable: true })
-  @Type(() => CommentCreateWithoutArticleInput)
-  create?: Array<CommentCreateWithoutArticleInput>;
 
-  @Field(() => [CommentCreateOrConnectWithoutArticleInput], { nullable: true })
-  @Type(() => CommentCreateOrConnectWithoutArticleInput)
-  connectOrCreate?: Array<CommentCreateOrConnectWithoutArticleInput>;
+    @Field(() => [CommentCreateWithoutArticleInput], {nullable:true})
+    @Type(() => CommentCreateWithoutArticleInput)
+    create?: Array<CommentCreateWithoutArticleInput>;
 
-  @Field(() => [CommentUpsertWithWhereUniqueWithoutArticleInput], { nullable: true })
-  @Type(() => CommentUpsertWithWhereUniqueWithoutArticleInput)
-  upsert?: Array<CommentUpsertWithWhereUniqueWithoutArticleInput>;
+    @Field(() => [CommentCreateOrConnectWithoutArticleInput], {nullable:true})
+    @Type(() => CommentCreateOrConnectWithoutArticleInput)
+    connectOrCreate?: Array<CommentCreateOrConnectWithoutArticleInput>;
 
-  @Field(() => CommentCreateManyArticleInputEnvelope, { nullable: true })
-  @Type(() => CommentCreateManyArticleInputEnvelope)
-  createMany?: CommentCreateManyArticleInputEnvelope;
+    @Field(() => [CommentUpsertWithWhereUniqueWithoutArticleInput], {nullable:true})
+    @Type(() => CommentUpsertWithWhereUniqueWithoutArticleInput)
+    upsert?: Array<CommentUpsertWithWhereUniqueWithoutArticleInput>;
 
-  @Field(() => [CommentWhereUniqueInput], { nullable: true })
-  @Type(() => CommentWhereUniqueInput)
-  set?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
+    @Field(() => CommentCreateManyArticleInputEnvelope, {nullable:true})
+    @Type(() => CommentCreateManyArticleInputEnvelope)
+    createMany?: CommentCreateManyArticleInputEnvelope;
 
-  @Field(() => [CommentWhereUniqueInput], { nullable: true })
-  @Type(() => CommentWhereUniqueInput)
-  disconnect?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
+    @Field(() => [CommentWhereUniqueInput], {nullable:true})
+    @Type(() => CommentWhereUniqueInput)
+    set?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
 
-  @Field(() => [CommentWhereUniqueInput], { nullable: true })
-  @Type(() => CommentWhereUniqueInput)
-  delete?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
+    @Field(() => [CommentWhereUniqueInput], {nullable:true})
+    @Type(() => CommentWhereUniqueInput)
+    disconnect?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
 
-  @Field(() => [CommentWhereUniqueInput], { nullable: true })
-  @Type(() => CommentWhereUniqueInput)
-  connect?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
+    @Field(() => [CommentWhereUniqueInput], {nullable:true})
+    @Type(() => CommentWhereUniqueInput)
+    delete?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
 
-  @Field(() => [CommentUpdateWithWhereUniqueWithoutArticleInput], { nullable: true })
-  @Type(() => CommentUpdateWithWhereUniqueWithoutArticleInput)
-  update?: Array<CommentUpdateWithWhereUniqueWithoutArticleInput>;
+    @Field(() => [CommentWhereUniqueInput], {nullable:true})
+    @Type(() => CommentWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
 
-  @Field(() => [CommentUpdateManyWithWhereWithoutArticleInput], { nullable: true })
-  @Type(() => CommentUpdateManyWithWhereWithoutArticleInput)
-  updateMany?: Array<CommentUpdateManyWithWhereWithoutArticleInput>;
+    @Field(() => [CommentUpdateWithWhereUniqueWithoutArticleInput], {nullable:true})
+    @Type(() => CommentUpdateWithWhereUniqueWithoutArticleInput)
+    update?: Array<CommentUpdateWithWhereUniqueWithoutArticleInput>;
 
-  @Field(() => [CommentScalarWhereInput], { nullable: true })
-  @Type(() => CommentScalarWhereInput)
-  deleteMany?: Array<CommentScalarWhereInput>;
+    @Field(() => [CommentUpdateManyWithWhereWithoutArticleInput], {nullable:true})
+    @Type(() => CommentUpdateManyWithWhereWithoutArticleInput)
+    updateMany?: Array<CommentUpdateManyWithWhereWithoutArticleInput>;
+
+    @Field(() => [CommentScalarWhereInput], {nullable:true})
+    @Type(() => CommentScalarWhereInput)
+    deleteMany?: Array<CommentScalarWhereInput>;
 }
diff --git a/@generated/comment/comment-unchecked-update-many-without-article.input.ts b/@generated/comment/comment-unchecked-update-many-without-article.input.ts
index b9b73272..05ce19da 100644
--- a/@generated/comment/comment-unchecked-update-many-without-article.input.ts
+++ b/@generated/comment/comment-unchecked-update-many-without-article.input.ts
@@ -6,18 +6,19 @@ import { HideField } from '@nestjs/graphql';
 
 @InputType()
 export class CommentUncheckedUpdateManyWithoutArticleInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  createdAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @HideField()
-  updatedAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    createdAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  body?: StringFieldUpdateOperationsInput;
+    @HideField()
+    updatedAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  authorId?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    body?: StringFieldUpdateOperationsInput;
+
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    authorId?: StringFieldUpdateOperationsInput;
 }
diff --git a/@generated/comment/comment-unchecked-update-many-without-author-nested.input.ts b/@generated/comment/comment-unchecked-update-many-without-author-nested.input.ts
index 3ea7f1df..07f4ff77 100644
--- a/@generated/comment/comment-unchecked-update-many-without-author-nested.input.ts
+++ b/@generated/comment/comment-unchecked-update-many-without-author-nested.input.ts
@@ -5,7 +5,7 @@ import { Type } from 'class-transformer';
 import { CommentCreateOrConnectWithoutAuthorInput } from './comment-create-or-connect-without-author.input';
 import { CommentUpsertWithWhereUniqueWithoutAuthorInput } from './comment-upsert-with-where-unique-without-author.input';
 import { CommentCreateManyAuthorInputEnvelope } from './comment-create-many-author-input-envelope.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { CommentWhereUniqueInput } from './comment-where-unique.input';
 import { CommentUpdateWithWhereUniqueWithoutAuthorInput } from './comment-update-with-where-unique-without-author.input';
 import { CommentUpdateManyWithWhereWithoutAuthorInput } from './comment-update-many-with-where-without-author.input';
@@ -13,47 +13,48 @@ import { CommentScalarWhereInput } from './comment-scalar-where.input';
 
 @InputType()
 export class CommentUncheckedUpdateManyWithoutAuthorNestedInput {
-  @Field(() => [CommentCreateWithoutAuthorInput], { nullable: true })
-  @Type(() => CommentCreateWithoutAuthorInput)
-  create?: Array<CommentCreateWithoutAuthorInput>;
 
-  @Field(() => [CommentCreateOrConnectWithoutAuthorInput], { nullable: true })
-  @Type(() => CommentCreateOrConnectWithoutAuthorInput)
-  connectOrCreate?: Array<CommentCreateOrConnectWithoutAuthorInput>;
+    @Field(() => [CommentCreateWithoutAuthorInput], {nullable:true})
+    @Type(() => CommentCreateWithoutAuthorInput)
+    create?: Array<CommentCreateWithoutAuthorInput>;
 
-  @Field(() => [CommentUpsertWithWhereUniqueWithoutAuthorInput], { nullable: true })
-  @Type(() => CommentUpsertWithWhereUniqueWithoutAuthorInput)
-  upsert?: Array<CommentUpsertWithWhereUniqueWithoutAuthorInput>;
+    @Field(() => [CommentCreateOrConnectWithoutAuthorInput], {nullable:true})
+    @Type(() => CommentCreateOrConnectWithoutAuthorInput)
+    connectOrCreate?: Array<CommentCreateOrConnectWithoutAuthorInput>;
 
-  @Field(() => CommentCreateManyAuthorInputEnvelope, { nullable: true })
-  @Type(() => CommentCreateManyAuthorInputEnvelope)
-  createMany?: CommentCreateManyAuthorInputEnvelope;
+    @Field(() => [CommentUpsertWithWhereUniqueWithoutAuthorInput], {nullable:true})
+    @Type(() => CommentUpsertWithWhereUniqueWithoutAuthorInput)
+    upsert?: Array<CommentUpsertWithWhereUniqueWithoutAuthorInput>;
 
-  @Field(() => [CommentWhereUniqueInput], { nullable: true })
-  @Type(() => CommentWhereUniqueInput)
-  set?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
+    @Field(() => CommentCreateManyAuthorInputEnvelope, {nullable:true})
+    @Type(() => CommentCreateManyAuthorInputEnvelope)
+    createMany?: CommentCreateManyAuthorInputEnvelope;
 
-  @Field(() => [CommentWhereUniqueInput], { nullable: true })
-  @Type(() => CommentWhereUniqueInput)
-  disconnect?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
+    @Field(() => [CommentWhereUniqueInput], {nullable:true})
+    @Type(() => CommentWhereUniqueInput)
+    set?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
 
-  @Field(() => [CommentWhereUniqueInput], { nullable: true })
-  @Type(() => CommentWhereUniqueInput)
-  delete?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
+    @Field(() => [CommentWhereUniqueInput], {nullable:true})
+    @Type(() => CommentWhereUniqueInput)
+    disconnect?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
 
-  @Field(() => [CommentWhereUniqueInput], { nullable: true })
-  @Type(() => CommentWhereUniqueInput)
-  connect?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
+    @Field(() => [CommentWhereUniqueInput], {nullable:true})
+    @Type(() => CommentWhereUniqueInput)
+    delete?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
 
-  @Field(() => [CommentUpdateWithWhereUniqueWithoutAuthorInput], { nullable: true })
-  @Type(() => CommentUpdateWithWhereUniqueWithoutAuthorInput)
-  update?: Array<CommentUpdateWithWhereUniqueWithoutAuthorInput>;
+    @Field(() => [CommentWhereUniqueInput], {nullable:true})
+    @Type(() => CommentWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
 
-  @Field(() => [CommentUpdateManyWithWhereWithoutAuthorInput], { nullable: true })
-  @Type(() => CommentUpdateManyWithWhereWithoutAuthorInput)
-  updateMany?: Array<CommentUpdateManyWithWhereWithoutAuthorInput>;
+    @Field(() => [CommentUpdateWithWhereUniqueWithoutAuthorInput], {nullable:true})
+    @Type(() => CommentUpdateWithWhereUniqueWithoutAuthorInput)
+    update?: Array<CommentUpdateWithWhereUniqueWithoutAuthorInput>;
 
-  @Field(() => [CommentScalarWhereInput], { nullable: true })
-  @Type(() => CommentScalarWhereInput)
-  deleteMany?: Array<CommentScalarWhereInput>;
+    @Field(() => [CommentUpdateManyWithWhereWithoutAuthorInput], {nullable:true})
+    @Type(() => CommentUpdateManyWithWhereWithoutAuthorInput)
+    updateMany?: Array<CommentUpdateManyWithWhereWithoutAuthorInput>;
+
+    @Field(() => [CommentScalarWhereInput], {nullable:true})
+    @Type(() => CommentScalarWhereInput)
+    deleteMany?: Array<CommentScalarWhereInput>;
 }
diff --git a/@generated/comment/comment-unchecked-update-many-without-author.input.ts b/@generated/comment/comment-unchecked-update-many-without-author.input.ts
index a2c33a6e..62c4f96c 100644
--- a/@generated/comment/comment-unchecked-update-many-without-author.input.ts
+++ b/@generated/comment/comment-unchecked-update-many-without-author.input.ts
@@ -7,18 +7,19 @@ import { NullableStringFieldUpdateOperationsInput } from '../prisma/nullable-str
 
 @InputType()
 export class CommentUncheckedUpdateManyWithoutAuthorInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  createdAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @HideField()
-  updatedAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    createdAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  body?: StringFieldUpdateOperationsInput;
+    @HideField()
+    updatedAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  articleId?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    body?: StringFieldUpdateOperationsInput;
+
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    articleId?: NullableStringFieldUpdateOperationsInput;
 }
diff --git a/@generated/comment/comment-unchecked-update-many.input.ts b/@generated/comment/comment-unchecked-update-many.input.ts
index 5aef42a4..007ef1e8 100644
--- a/@generated/comment/comment-unchecked-update-many.input.ts
+++ b/@generated/comment/comment-unchecked-update-many.input.ts
@@ -7,21 +7,22 @@ import { NullableStringFieldUpdateOperationsInput } from '../prisma/nullable-str
 
 @InputType()
 export class CommentUncheckedUpdateManyInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  createdAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @HideField()
-  updatedAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    createdAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  body?: StringFieldUpdateOperationsInput;
+    @HideField()
+    updatedAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  authorId?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    body?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  articleId?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    authorId?: StringFieldUpdateOperationsInput;
+
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    articleId?: NullableStringFieldUpdateOperationsInput;
 }
diff --git a/@generated/comment/comment-unchecked-update-without-article.input.ts b/@generated/comment/comment-unchecked-update-without-article.input.ts
index 642fe026..4881765b 100644
--- a/@generated/comment/comment-unchecked-update-without-article.input.ts
+++ b/@generated/comment/comment-unchecked-update-without-article.input.ts
@@ -6,18 +6,19 @@ import { HideField } from '@nestjs/graphql';
 
 @InputType()
 export class CommentUncheckedUpdateWithoutArticleInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  createdAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @HideField()
-  updatedAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    createdAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  body?: StringFieldUpdateOperationsInput;
+    @HideField()
+    updatedAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  authorId?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    body?: StringFieldUpdateOperationsInput;
+
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    authorId?: StringFieldUpdateOperationsInput;
 }
diff --git a/@generated/comment/comment-unchecked-update-without-author.input.ts b/@generated/comment/comment-unchecked-update-without-author.input.ts
index 5973f8ba..f9b8e909 100644
--- a/@generated/comment/comment-unchecked-update-without-author.input.ts
+++ b/@generated/comment/comment-unchecked-update-without-author.input.ts
@@ -7,18 +7,19 @@ import { NullableStringFieldUpdateOperationsInput } from '../prisma/nullable-str
 
 @InputType()
 export class CommentUncheckedUpdateWithoutAuthorInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  createdAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @HideField()
-  updatedAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    createdAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  body?: StringFieldUpdateOperationsInput;
+    @HideField()
+    updatedAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  articleId?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    body?: StringFieldUpdateOperationsInput;
+
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    articleId?: NullableStringFieldUpdateOperationsInput;
 }
diff --git a/@generated/comment/comment-unchecked-update.input.ts b/@generated/comment/comment-unchecked-update.input.ts
index 3cb75246..b4ec369a 100644
--- a/@generated/comment/comment-unchecked-update.input.ts
+++ b/@generated/comment/comment-unchecked-update.input.ts
@@ -7,21 +7,22 @@ import { NullableStringFieldUpdateOperationsInput } from '../prisma/nullable-str
 
 @InputType()
 export class CommentUncheckedUpdateInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  createdAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @HideField()
-  updatedAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    createdAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  body?: StringFieldUpdateOperationsInput;
+    @HideField()
+    updatedAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  authorId?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    body?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  articleId?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    authorId?: StringFieldUpdateOperationsInput;
+
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    articleId?: NullableStringFieldUpdateOperationsInput;
 }
diff --git a/@generated/comment/comment-update-many-mutation.input.ts b/@generated/comment/comment-update-many-mutation.input.ts
index 702eae50..51255562 100644
--- a/@generated/comment/comment-update-many-mutation.input.ts
+++ b/@generated/comment/comment-update-many-mutation.input.ts
@@ -6,15 +6,16 @@ import { HideField } from '@nestjs/graphql';
 
 @InputType()
 export class CommentUpdateManyMutationInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  createdAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @HideField()
-  updatedAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    createdAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  body?: StringFieldUpdateOperationsInput;
+    @HideField()
+    updatedAt?: DateTimeFieldUpdateOperationsInput;
+
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    body?: StringFieldUpdateOperationsInput;
 }
diff --git a/@generated/comment/comment-update-many-with-where-without-article.input.ts b/@generated/comment/comment-update-many-with-where-without-article.input.ts
index 21236f66..5b2e85e0 100644
--- a/@generated/comment/comment-update-many-with-where-without-article.input.ts
+++ b/@generated/comment/comment-update-many-with-where-without-article.input.ts
@@ -6,11 +6,12 @@ import { CommentUpdateManyMutationInput } from './comment-update-many-mutation.i
 
 @InputType()
 export class CommentUpdateManyWithWhereWithoutArticleInput {
-  @Field(() => CommentScalarWhereInput, { nullable: false })
-  @Type(() => CommentScalarWhereInput)
-  where!: CommentScalarWhereInput;
 
-  @Field(() => CommentUpdateManyMutationInput, { nullable: false })
-  @Type(() => CommentUpdateManyMutationInput)
-  data!: CommentUpdateManyMutationInput;
+    @Field(() => CommentScalarWhereInput, {nullable:false})
+    @Type(() => CommentScalarWhereInput)
+    where!: CommentScalarWhereInput;
+
+    @Field(() => CommentUpdateManyMutationInput, {nullable:false})
+    @Type(() => CommentUpdateManyMutationInput)
+    data!: CommentUpdateManyMutationInput;
 }
diff --git a/@generated/comment/comment-update-many-with-where-without-author.input.ts b/@generated/comment/comment-update-many-with-where-without-author.input.ts
index c14e531f..5ddc8df2 100644
--- a/@generated/comment/comment-update-many-with-where-without-author.input.ts
+++ b/@generated/comment/comment-update-many-with-where-without-author.input.ts
@@ -6,11 +6,12 @@ import { CommentUpdateManyMutationInput } from './comment-update-many-mutation.i
 
 @InputType()
 export class CommentUpdateManyWithWhereWithoutAuthorInput {
-  @Field(() => CommentScalarWhereInput, { nullable: false })
-  @Type(() => CommentScalarWhereInput)
-  where!: CommentScalarWhereInput;
 
-  @Field(() => CommentUpdateManyMutationInput, { nullable: false })
-  @Type(() => CommentUpdateManyMutationInput)
-  data!: CommentUpdateManyMutationInput;
+    @Field(() => CommentScalarWhereInput, {nullable:false})
+    @Type(() => CommentScalarWhereInput)
+    where!: CommentScalarWhereInput;
+
+    @Field(() => CommentUpdateManyMutationInput, {nullable:false})
+    @Type(() => CommentUpdateManyMutationInput)
+    data!: CommentUpdateManyMutationInput;
 }
diff --git a/@generated/comment/comment-update-many-without-article-nested.input.ts b/@generated/comment/comment-update-many-without-article-nested.input.ts
index 17549924..26b84680 100644
--- a/@generated/comment/comment-update-many-without-article-nested.input.ts
+++ b/@generated/comment/comment-update-many-without-article-nested.input.ts
@@ -5,7 +5,7 @@ import { Type } from 'class-transformer';
 import { CommentCreateOrConnectWithoutArticleInput } from './comment-create-or-connect-without-article.input';
 import { CommentUpsertWithWhereUniqueWithoutArticleInput } from './comment-upsert-with-where-unique-without-article.input';
 import { CommentCreateManyArticleInputEnvelope } from './comment-create-many-article-input-envelope.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { CommentWhereUniqueInput } from './comment-where-unique.input';
 import { CommentUpdateWithWhereUniqueWithoutArticleInput } from './comment-update-with-where-unique-without-article.input';
 import { CommentUpdateManyWithWhereWithoutArticleInput } from './comment-update-many-with-where-without-article.input';
@@ -13,47 +13,48 @@ import { CommentScalarWhereInput } from './comment-scalar-where.input';
 
 @InputType()
 export class CommentUpdateManyWithoutArticleNestedInput {
-  @Field(() => [CommentCreateWithoutArticleInput], { nullable: true })
-  @Type(() => CommentCreateWithoutArticleInput)
-  create?: Array<CommentCreateWithoutArticleInput>;
 
-  @Field(() => [CommentCreateOrConnectWithoutArticleInput], { nullable: true })
-  @Type(() => CommentCreateOrConnectWithoutArticleInput)
-  connectOrCreate?: Array<CommentCreateOrConnectWithoutArticleInput>;
+    @Field(() => [CommentCreateWithoutArticleInput], {nullable:true})
+    @Type(() => CommentCreateWithoutArticleInput)
+    create?: Array<CommentCreateWithoutArticleInput>;
 
-  @Field(() => [CommentUpsertWithWhereUniqueWithoutArticleInput], { nullable: true })
-  @Type(() => CommentUpsertWithWhereUniqueWithoutArticleInput)
-  upsert?: Array<CommentUpsertWithWhereUniqueWithoutArticleInput>;
+    @Field(() => [CommentCreateOrConnectWithoutArticleInput], {nullable:true})
+    @Type(() => CommentCreateOrConnectWithoutArticleInput)
+    connectOrCreate?: Array<CommentCreateOrConnectWithoutArticleInput>;
 
-  @Field(() => CommentCreateManyArticleInputEnvelope, { nullable: true })
-  @Type(() => CommentCreateManyArticleInputEnvelope)
-  createMany?: CommentCreateManyArticleInputEnvelope;
+    @Field(() => [CommentUpsertWithWhereUniqueWithoutArticleInput], {nullable:true})
+    @Type(() => CommentUpsertWithWhereUniqueWithoutArticleInput)
+    upsert?: Array<CommentUpsertWithWhereUniqueWithoutArticleInput>;
 
-  @Field(() => [CommentWhereUniqueInput], { nullable: true })
-  @Type(() => CommentWhereUniqueInput)
-  set?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
+    @Field(() => CommentCreateManyArticleInputEnvelope, {nullable:true})
+    @Type(() => CommentCreateManyArticleInputEnvelope)
+    createMany?: CommentCreateManyArticleInputEnvelope;
 
-  @Field(() => [CommentWhereUniqueInput], { nullable: true })
-  @Type(() => CommentWhereUniqueInput)
-  disconnect?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
+    @Field(() => [CommentWhereUniqueInput], {nullable:true})
+    @Type(() => CommentWhereUniqueInput)
+    set?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
 
-  @Field(() => [CommentWhereUniqueInput], { nullable: true })
-  @Type(() => CommentWhereUniqueInput)
-  delete?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
+    @Field(() => [CommentWhereUniqueInput], {nullable:true})
+    @Type(() => CommentWhereUniqueInput)
+    disconnect?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
 
-  @Field(() => [CommentWhereUniqueInput], { nullable: true })
-  @Type(() => CommentWhereUniqueInput)
-  connect?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
+    @Field(() => [CommentWhereUniqueInput], {nullable:true})
+    @Type(() => CommentWhereUniqueInput)
+    delete?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
 
-  @Field(() => [CommentUpdateWithWhereUniqueWithoutArticleInput], { nullable: true })
-  @Type(() => CommentUpdateWithWhereUniqueWithoutArticleInput)
-  update?: Array<CommentUpdateWithWhereUniqueWithoutArticleInput>;
+    @Field(() => [CommentWhereUniqueInput], {nullable:true})
+    @Type(() => CommentWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
 
-  @Field(() => [CommentUpdateManyWithWhereWithoutArticleInput], { nullable: true })
-  @Type(() => CommentUpdateManyWithWhereWithoutArticleInput)
-  updateMany?: Array<CommentUpdateManyWithWhereWithoutArticleInput>;
+    @Field(() => [CommentUpdateWithWhereUniqueWithoutArticleInput], {nullable:true})
+    @Type(() => CommentUpdateWithWhereUniqueWithoutArticleInput)
+    update?: Array<CommentUpdateWithWhereUniqueWithoutArticleInput>;
 
-  @Field(() => [CommentScalarWhereInput], { nullable: true })
-  @Type(() => CommentScalarWhereInput)
-  deleteMany?: Array<CommentScalarWhereInput>;
+    @Field(() => [CommentUpdateManyWithWhereWithoutArticleInput], {nullable:true})
+    @Type(() => CommentUpdateManyWithWhereWithoutArticleInput)
+    updateMany?: Array<CommentUpdateManyWithWhereWithoutArticleInput>;
+
+    @Field(() => [CommentScalarWhereInput], {nullable:true})
+    @Type(() => CommentScalarWhereInput)
+    deleteMany?: Array<CommentScalarWhereInput>;
 }
diff --git a/@generated/comment/comment-update-many-without-author-nested.input.ts b/@generated/comment/comment-update-many-without-author-nested.input.ts
index faf72587..accb4c43 100644
--- a/@generated/comment/comment-update-many-without-author-nested.input.ts
+++ b/@generated/comment/comment-update-many-without-author-nested.input.ts
@@ -5,7 +5,7 @@ import { Type } from 'class-transformer';
 import { CommentCreateOrConnectWithoutAuthorInput } from './comment-create-or-connect-without-author.input';
 import { CommentUpsertWithWhereUniqueWithoutAuthorInput } from './comment-upsert-with-where-unique-without-author.input';
 import { CommentCreateManyAuthorInputEnvelope } from './comment-create-many-author-input-envelope.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { CommentWhereUniqueInput } from './comment-where-unique.input';
 import { CommentUpdateWithWhereUniqueWithoutAuthorInput } from './comment-update-with-where-unique-without-author.input';
 import { CommentUpdateManyWithWhereWithoutAuthorInput } from './comment-update-many-with-where-without-author.input';
@@ -13,47 +13,48 @@ import { CommentScalarWhereInput } from './comment-scalar-where.input';
 
 @InputType()
 export class CommentUpdateManyWithoutAuthorNestedInput {
-  @Field(() => [CommentCreateWithoutAuthorInput], { nullable: true })
-  @Type(() => CommentCreateWithoutAuthorInput)
-  create?: Array<CommentCreateWithoutAuthorInput>;
 
-  @Field(() => [CommentCreateOrConnectWithoutAuthorInput], { nullable: true })
-  @Type(() => CommentCreateOrConnectWithoutAuthorInput)
-  connectOrCreate?: Array<CommentCreateOrConnectWithoutAuthorInput>;
+    @Field(() => [CommentCreateWithoutAuthorInput], {nullable:true})
+    @Type(() => CommentCreateWithoutAuthorInput)
+    create?: Array<CommentCreateWithoutAuthorInput>;
 
-  @Field(() => [CommentUpsertWithWhereUniqueWithoutAuthorInput], { nullable: true })
-  @Type(() => CommentUpsertWithWhereUniqueWithoutAuthorInput)
-  upsert?: Array<CommentUpsertWithWhereUniqueWithoutAuthorInput>;
+    @Field(() => [CommentCreateOrConnectWithoutAuthorInput], {nullable:true})
+    @Type(() => CommentCreateOrConnectWithoutAuthorInput)
+    connectOrCreate?: Array<CommentCreateOrConnectWithoutAuthorInput>;
 
-  @Field(() => CommentCreateManyAuthorInputEnvelope, { nullable: true })
-  @Type(() => CommentCreateManyAuthorInputEnvelope)
-  createMany?: CommentCreateManyAuthorInputEnvelope;
+    @Field(() => [CommentUpsertWithWhereUniqueWithoutAuthorInput], {nullable:true})
+    @Type(() => CommentUpsertWithWhereUniqueWithoutAuthorInput)
+    upsert?: Array<CommentUpsertWithWhereUniqueWithoutAuthorInput>;
 
-  @Field(() => [CommentWhereUniqueInput], { nullable: true })
-  @Type(() => CommentWhereUniqueInput)
-  set?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
+    @Field(() => CommentCreateManyAuthorInputEnvelope, {nullable:true})
+    @Type(() => CommentCreateManyAuthorInputEnvelope)
+    createMany?: CommentCreateManyAuthorInputEnvelope;
 
-  @Field(() => [CommentWhereUniqueInput], { nullable: true })
-  @Type(() => CommentWhereUniqueInput)
-  disconnect?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
+    @Field(() => [CommentWhereUniqueInput], {nullable:true})
+    @Type(() => CommentWhereUniqueInput)
+    set?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
 
-  @Field(() => [CommentWhereUniqueInput], { nullable: true })
-  @Type(() => CommentWhereUniqueInput)
-  delete?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
+    @Field(() => [CommentWhereUniqueInput], {nullable:true})
+    @Type(() => CommentWhereUniqueInput)
+    disconnect?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
 
-  @Field(() => [CommentWhereUniqueInput], { nullable: true })
-  @Type(() => CommentWhereUniqueInput)
-  connect?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
+    @Field(() => [CommentWhereUniqueInput], {nullable:true})
+    @Type(() => CommentWhereUniqueInput)
+    delete?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
 
-  @Field(() => [CommentUpdateWithWhereUniqueWithoutAuthorInput], { nullable: true })
-  @Type(() => CommentUpdateWithWhereUniqueWithoutAuthorInput)
-  update?: Array<CommentUpdateWithWhereUniqueWithoutAuthorInput>;
+    @Field(() => [CommentWhereUniqueInput], {nullable:true})
+    @Type(() => CommentWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<CommentWhereUniqueInput, 'id'>>;
 
-  @Field(() => [CommentUpdateManyWithWhereWithoutAuthorInput], { nullable: true })
-  @Type(() => CommentUpdateManyWithWhereWithoutAuthorInput)
-  updateMany?: Array<CommentUpdateManyWithWhereWithoutAuthorInput>;
+    @Field(() => [CommentUpdateWithWhereUniqueWithoutAuthorInput], {nullable:true})
+    @Type(() => CommentUpdateWithWhereUniqueWithoutAuthorInput)
+    update?: Array<CommentUpdateWithWhereUniqueWithoutAuthorInput>;
 
-  @Field(() => [CommentScalarWhereInput], { nullable: true })
-  @Type(() => CommentScalarWhereInput)
-  deleteMany?: Array<CommentScalarWhereInput>;
+    @Field(() => [CommentUpdateManyWithWhereWithoutAuthorInput], {nullable:true})
+    @Type(() => CommentUpdateManyWithWhereWithoutAuthorInput)
+    updateMany?: Array<CommentUpdateManyWithWhereWithoutAuthorInput>;
+
+    @Field(() => [CommentScalarWhereInput], {nullable:true})
+    @Type(() => CommentScalarWhereInput)
+    deleteMany?: Array<CommentScalarWhereInput>;
 }
diff --git a/@generated/comment/comment-update-with-where-unique-without-article.input.ts b/@generated/comment/comment-update-with-where-unique-without-article.input.ts
index a6733187..d61518da 100644
--- a/@generated/comment/comment-update-with-where-unique-without-article.input.ts
+++ b/@generated/comment/comment-update-with-where-unique-without-article.input.ts
@@ -1,17 +1,18 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { CommentWhereUniqueInput } from './comment-where-unique.input';
 import { Type } from 'class-transformer';
 import { CommentUpdateWithoutArticleInput } from './comment-update-without-article.input';
 
 @InputType()
 export class CommentUpdateWithWhereUniqueWithoutArticleInput {
-  @Field(() => CommentWhereUniqueInput, { nullable: false })
-  @Type(() => CommentWhereUniqueInput)
-  where!: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
 
-  @Field(() => CommentUpdateWithoutArticleInput, { nullable: false })
-  @Type(() => CommentUpdateWithoutArticleInput)
-  data!: CommentUpdateWithoutArticleInput;
+    @Field(() => CommentWhereUniqueInput, {nullable:false})
+    @Type(() => CommentWhereUniqueInput)
+    where!: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
+
+    @Field(() => CommentUpdateWithoutArticleInput, {nullable:false})
+    @Type(() => CommentUpdateWithoutArticleInput)
+    data!: CommentUpdateWithoutArticleInput;
 }
diff --git a/@generated/comment/comment-update-with-where-unique-without-author.input.ts b/@generated/comment/comment-update-with-where-unique-without-author.input.ts
index cd37b1a6..bb832912 100644
--- a/@generated/comment/comment-update-with-where-unique-without-author.input.ts
+++ b/@generated/comment/comment-update-with-where-unique-without-author.input.ts
@@ -1,17 +1,18 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { CommentWhereUniqueInput } from './comment-where-unique.input';
 import { Type } from 'class-transformer';
 import { CommentUpdateWithoutAuthorInput } from './comment-update-without-author.input';
 
 @InputType()
 export class CommentUpdateWithWhereUniqueWithoutAuthorInput {
-  @Field(() => CommentWhereUniqueInput, { nullable: false })
-  @Type(() => CommentWhereUniqueInput)
-  where!: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
 
-  @Field(() => CommentUpdateWithoutAuthorInput, { nullable: false })
-  @Type(() => CommentUpdateWithoutAuthorInput)
-  data!: CommentUpdateWithoutAuthorInput;
+    @Field(() => CommentWhereUniqueInput, {nullable:false})
+    @Type(() => CommentWhereUniqueInput)
+    where!: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
+
+    @Field(() => CommentUpdateWithoutAuthorInput, {nullable:false})
+    @Type(() => CommentUpdateWithoutAuthorInput)
+    data!: CommentUpdateWithoutAuthorInput;
 }
diff --git a/@generated/comment/comment-update-without-article.input.ts b/@generated/comment/comment-update-without-article.input.ts
index 4e5949d2..b6648901 100644
--- a/@generated/comment/comment-update-without-article.input.ts
+++ b/@generated/comment/comment-update-without-article.input.ts
@@ -8,19 +8,20 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class CommentUpdateWithoutArticleInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  createdAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @HideField()
-  updatedAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    createdAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  body?: StringFieldUpdateOperationsInput;
+    @HideField()
+    updatedAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => UserUpdateOneRequiredWithoutCommentsNestedInput, { nullable: true })
-  @Type(() => UserUpdateOneRequiredWithoutCommentsNestedInput)
-  author?: UserUpdateOneRequiredWithoutCommentsNestedInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    body?: StringFieldUpdateOperationsInput;
+
+    @Field(() => UserUpdateOneRequiredWithoutCommentsNestedInput, {nullable:true})
+    @Type(() => UserUpdateOneRequiredWithoutCommentsNestedInput)
+    author?: UserUpdateOneRequiredWithoutCommentsNestedInput;
 }
diff --git a/@generated/comment/comment-update-without-author.input.ts b/@generated/comment/comment-update-without-author.input.ts
index 30071334..df893a24 100644
--- a/@generated/comment/comment-update-without-author.input.ts
+++ b/@generated/comment/comment-update-without-author.input.ts
@@ -8,19 +8,20 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class CommentUpdateWithoutAuthorInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  createdAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @HideField()
-  updatedAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    createdAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  body?: StringFieldUpdateOperationsInput;
+    @HideField()
+    updatedAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => ArticleUpdateOneWithoutCommentsNestedInput, { nullable: true })
-  @Type(() => ArticleUpdateOneWithoutCommentsNestedInput)
-  article?: ArticleUpdateOneWithoutCommentsNestedInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    body?: StringFieldUpdateOperationsInput;
+
+    @Field(() => ArticleUpdateOneWithoutCommentsNestedInput, {nullable:true})
+    @Type(() => ArticleUpdateOneWithoutCommentsNestedInput)
+    article?: ArticleUpdateOneWithoutCommentsNestedInput;
 }
diff --git a/@generated/comment/comment-update.input.ts b/@generated/comment/comment-update.input.ts
index 2a56d21d..0b56e2c8 100644
--- a/@generated/comment/comment-update.input.ts
+++ b/@generated/comment/comment-update.input.ts
@@ -9,23 +9,24 @@ import { ArticleUpdateOneWithoutCommentsNestedInput } from '../article/article-u
 
 @InputType()
 export class CommentUpdateInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
-  createdAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @HideField()
-  updatedAt?: DateTimeFieldUpdateOperationsInput;
+    @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
+    createdAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  body?: StringFieldUpdateOperationsInput;
+    @HideField()
+    updatedAt?: DateTimeFieldUpdateOperationsInput;
 
-  @Field(() => UserUpdateOneRequiredWithoutCommentsNestedInput, { nullable: true })
-  @Type(() => UserUpdateOneRequiredWithoutCommentsNestedInput)
-  author?: UserUpdateOneRequiredWithoutCommentsNestedInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    body?: StringFieldUpdateOperationsInput;
 
-  @Field(() => ArticleUpdateOneWithoutCommentsNestedInput, { nullable: true })
-  @Type(() => ArticleUpdateOneWithoutCommentsNestedInput)
-  article?: ArticleUpdateOneWithoutCommentsNestedInput;
+    @Field(() => UserUpdateOneRequiredWithoutCommentsNestedInput, {nullable:true})
+    @Type(() => UserUpdateOneRequiredWithoutCommentsNestedInput)
+    author?: UserUpdateOneRequiredWithoutCommentsNestedInput;
+
+    @Field(() => ArticleUpdateOneWithoutCommentsNestedInput, {nullable:true})
+    @Type(() => ArticleUpdateOneWithoutCommentsNestedInput)
+    article?: ArticleUpdateOneWithoutCommentsNestedInput;
 }
diff --git a/@generated/comment/comment-upsert-with-where-unique-without-article.input.ts b/@generated/comment/comment-upsert-with-where-unique-without-article.input.ts
index 7380580a..29e8813c 100644
--- a/@generated/comment/comment-upsert-with-where-unique-without-article.input.ts
+++ b/@generated/comment/comment-upsert-with-where-unique-without-article.input.ts
@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { CommentWhereUniqueInput } from './comment-where-unique.input';
 import { Type } from 'class-transformer';
 import { CommentUpdateWithoutArticleInput } from './comment-update-without-article.input';
@@ -8,15 +8,16 @@ import { CommentCreateWithoutArticleInput } from './comment-create-without-artic
 
 @InputType()
 export class CommentUpsertWithWhereUniqueWithoutArticleInput {
-  @Field(() => CommentWhereUniqueInput, { nullable: false })
-  @Type(() => CommentWhereUniqueInput)
-  where!: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
 
-  @Field(() => CommentUpdateWithoutArticleInput, { nullable: false })
-  @Type(() => CommentUpdateWithoutArticleInput)
-  update!: CommentUpdateWithoutArticleInput;
+    @Field(() => CommentWhereUniqueInput, {nullable:false})
+    @Type(() => CommentWhereUniqueInput)
+    where!: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
 
-  @Field(() => CommentCreateWithoutArticleInput, { nullable: false })
-  @Type(() => CommentCreateWithoutArticleInput)
-  create!: CommentCreateWithoutArticleInput;
+    @Field(() => CommentUpdateWithoutArticleInput, {nullable:false})
+    @Type(() => CommentUpdateWithoutArticleInput)
+    update!: CommentUpdateWithoutArticleInput;
+
+    @Field(() => CommentCreateWithoutArticleInput, {nullable:false})
+    @Type(() => CommentCreateWithoutArticleInput)
+    create!: CommentCreateWithoutArticleInput;
 }
diff --git a/@generated/comment/comment-upsert-with-where-unique-without-author.input.ts b/@generated/comment/comment-upsert-with-where-unique-without-author.input.ts
index cabb0494..620f4428 100644
--- a/@generated/comment/comment-upsert-with-where-unique-without-author.input.ts
+++ b/@generated/comment/comment-upsert-with-where-unique-without-author.input.ts
@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { CommentWhereUniqueInput } from './comment-where-unique.input';
 import { Type } from 'class-transformer';
 import { CommentUpdateWithoutAuthorInput } from './comment-update-without-author.input';
@@ -8,15 +8,16 @@ import { CommentCreateWithoutAuthorInput } from './comment-create-without-author
 
 @InputType()
 export class CommentUpsertWithWhereUniqueWithoutAuthorInput {
-  @Field(() => CommentWhereUniqueInput, { nullable: false })
-  @Type(() => CommentWhereUniqueInput)
-  where!: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
 
-  @Field(() => CommentUpdateWithoutAuthorInput, { nullable: false })
-  @Type(() => CommentUpdateWithoutAuthorInput)
-  update!: CommentUpdateWithoutAuthorInput;
+    @Field(() => CommentWhereUniqueInput, {nullable:false})
+    @Type(() => CommentWhereUniqueInput)
+    where!: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
 
-  @Field(() => CommentCreateWithoutAuthorInput, { nullable: false })
-  @Type(() => CommentCreateWithoutAuthorInput)
-  create!: CommentCreateWithoutAuthorInput;
+    @Field(() => CommentUpdateWithoutAuthorInput, {nullable:false})
+    @Type(() => CommentUpdateWithoutAuthorInput)
+    update!: CommentUpdateWithoutAuthorInput;
+
+    @Field(() => CommentCreateWithoutAuthorInput, {nullable:false})
+    @Type(() => CommentCreateWithoutAuthorInput)
+    create!: CommentCreateWithoutAuthorInput;
 }
diff --git a/@generated/comment/comment-where-unique.input.ts b/@generated/comment/comment-where-unique.input.ts
index b472a8e4..5231a890 100644
--- a/@generated/comment/comment-where-unique.input.ts
+++ b/@generated/comment/comment-where-unique.input.ts
@@ -10,38 +10,39 @@ import { ArticleNullableRelationFilter } from '../article/article-nullable-relat
 
 @InputType()
 export class CommentWhereUniqueInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => [CommentWhereInput], { nullable: true })
-  AND?: Array<CommentWhereInput>;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => [CommentWhereInput], { nullable: true })
-  OR?: Array<CommentWhereInput>;
+    @Field(() => [CommentWhereInput], {nullable:true})
+    AND?: Array<CommentWhereInput>;
 
-  @Field(() => [CommentWhereInput], { nullable: true })
-  NOT?: Array<CommentWhereInput>;
+    @Field(() => [CommentWhereInput], {nullable:true})
+    OR?: Array<CommentWhereInput>;
 
-  @Field(() => DateTimeFilter, { nullable: true })
-  createdAt?: DateTimeFilter;
+    @Field(() => [CommentWhereInput], {nullable:true})
+    NOT?: Array<CommentWhereInput>;
 
-  @Field(() => DateTimeFilter, { nullable: true })
-  updatedAt?: DateTimeFilter;
+    @Field(() => DateTimeFilter, {nullable:true})
+    createdAt?: DateTimeFilter;
 
-  @Field(() => StringFilter, { nullable: true })
-  body?: StringFilter;
+    @Field(() => DateTimeFilter, {nullable:true})
+    updatedAt?: DateTimeFilter;
 
-  @Field(() => StringFilter, { nullable: true })
-  authorId?: StringFilter;
+    @Field(() => StringFilter, {nullable:true})
+    body?: StringFilter;
 
-  @Field(() => StringNullableFilter, { nullable: true })
-  articleId?: StringNullableFilter;
+    @Field(() => StringFilter, {nullable:true})
+    authorId?: StringFilter;
 
-  @Field(() => UserRelationFilter, { nullable: true })
-  @Type(() => UserRelationFilter)
-  author?: UserRelationFilter;
+    @Field(() => StringNullableFilter, {nullable:true})
+    articleId?: StringNullableFilter;
 
-  @Field(() => ArticleNullableRelationFilter, { nullable: true })
-  @Type(() => ArticleNullableRelationFilter)
-  article?: ArticleNullableRelationFilter;
+    @Field(() => UserRelationFilter, {nullable:true})
+    @Type(() => UserRelationFilter)
+    author?: UserRelationFilter;
+
+    @Field(() => ArticleNullableRelationFilter, {nullable:true})
+    @Type(() => ArticleNullableRelationFilter)
+    article?: ArticleNullableRelationFilter;
 }
diff --git a/@generated/comment/comment-where.input.ts b/@generated/comment/comment-where.input.ts
index 35c2965c..fb66a1c0 100644
--- a/@generated/comment/comment-where.input.ts
+++ b/@generated/comment/comment-where.input.ts
@@ -9,38 +9,39 @@ import { ArticleWhereInput } from '../article/article-where.input';
 
 @InputType()
 export class CommentWhereInput {
-  @Field(() => [CommentWhereInput], { nullable: true })
-  AND?: Array<CommentWhereInput>;
 
-  @Field(() => [CommentWhereInput], { nullable: true })
-  OR?: Array<CommentWhereInput>;
+    @Field(() => [CommentWhereInput], {nullable:true})
+    AND?: Array<CommentWhereInput>;
 
-  @Field(() => [CommentWhereInput], { nullable: true })
-  NOT?: Array<CommentWhereInput>;
+    @Field(() => [CommentWhereInput], {nullable:true})
+    OR?: Array<CommentWhereInput>;
 
-  @Field(() => StringFilter, { nullable: true })
-  id?: StringFilter;
+    @Field(() => [CommentWhereInput], {nullable:true})
+    NOT?: Array<CommentWhereInput>;
 
-  @Field(() => DateTimeFilter, { nullable: true })
-  createdAt?: DateTimeFilter;
+    @Field(() => StringFilter, {nullable:true})
+    id?: StringFilter;
 
-  @Field(() => DateTimeFilter, { nullable: true })
-  updatedAt?: DateTimeFilter;
+    @Field(() => DateTimeFilter, {nullable:true})
+    createdAt?: DateTimeFilter;
 
-  @Field(() => StringFilter, { nullable: true })
-  body?: StringFilter;
+    @Field(() => DateTimeFilter, {nullable:true})
+    updatedAt?: DateTimeFilter;
 
-  @Field(() => StringFilter, { nullable: true })
-  authorId?: StringFilter;
+    @Field(() => StringFilter, {nullable:true})
+    body?: StringFilter;
 
-  @Field(() => StringNullableFilter, { nullable: true })
-  articleId?: StringNullableFilter;
+    @Field(() => StringFilter, {nullable:true})
+    authorId?: StringFilter;
 
-  @Field(() => UserWhereInput, { nullable: true })
-  @Type(() => UserWhereInput)
-  author?: UserWhereInput;
+    @Field(() => StringNullableFilter, {nullable:true})
+    articleId?: StringNullableFilter;
 
-  @Field(() => ArticleWhereInput, { nullable: true })
-  @Type(() => ArticleWhereInput)
-  article?: ArticleWhereInput;
+    @Field(() => UserWhereInput, {nullable:true})
+    @Type(() => UserWhereInput)
+    author?: UserWhereInput;
+
+    @Field(() => ArticleWhereInput, {nullable:true})
+    @Type(() => ArticleWhereInput)
+    article?: ArticleWhereInput;
 }
diff --git a/@generated/comment/comment.model.ts b/@generated/comment/comment.model.ts
index 9a468df3..ad7b130f 100644
--- a/@generated/comment/comment.model.ts
+++ b/@generated/comment/comment.model.ts
@@ -6,27 +6,28 @@ import { Article } from '../article/article.model';
 
 @ObjectType()
 export class Comment {
-  @Field(() => ID, { nullable: false })
-  id!: string;
 
-  @Field(() => Date, { nullable: false })
-  createdAt!: Date;
+    @Field(() => ID, {nullable:false})
+    id!: string;
 
-  @Field(() => Date, { nullable: false })
-  updatedAt!: Date;
+    @Field(() => Date, {nullable:false})
+    createdAt!: Date;
 
-  @Field(() => String, { nullable: false })
-  body!: string;
+    @Field(() => Date, {nullable:false})
+    updatedAt!: Date;
 
-  @Field(() => String, { nullable: false })
-  authorId!: string;
+    @Field(() => String, {nullable:false})
+    body!: string;
 
-  @Field(() => String, { nullable: true })
-  articleId!: string | null;
+    @Field(() => String, {nullable:false})
+    authorId!: string;
 
-  @Field(() => User, { nullable: false })
-  author?: User;
+    @Field(() => String, {nullable:true})
+    articleId!: string | null;
 
-  @Field(() => Article, { nullable: true })
-  article?: Article | null;
+    @Field(() => User, {nullable:false})
+    author?: User;
+
+    @Field(() => Article, {nullable:true})
+    article?: Article | null;
 }
diff --git a/@generated/comment/create-many-comment.args.ts b/@generated/comment/create-many-comment.args.ts
index 4f66f49c..51b3f472 100644
--- a/@generated/comment/create-many-comment.args.ts
+++ b/@generated/comment/create-many-comment.args.ts
@@ -5,10 +5,11 @@ import { Type } from 'class-transformer';
 
 @ArgsType()
 export class CreateManyCommentArgs {
-  @Field(() => [CommentCreateManyInput], { nullable: false })
-  @Type(() => CommentCreateManyInput)
-  data!: Array<CommentCreateManyInput>;
 
-  @Field(() => Boolean, { nullable: true })
-  skipDuplicates?: boolean;
+    @Field(() => [CommentCreateManyInput], {nullable:false})
+    @Type(() => CommentCreateManyInput)
+    data!: Array<CommentCreateManyInput>;
+
+    @Field(() => Boolean, {nullable:true})
+    skipDuplicates?: boolean;
 }
diff --git a/@generated/comment/create-one-comment.args.ts b/@generated/comment/create-one-comment.args.ts
index 0867c2ea..66568894 100644
--- a/@generated/comment/create-one-comment.args.ts
+++ b/@generated/comment/create-one-comment.args.ts
@@ -5,7 +5,8 @@ import { Type } from 'class-transformer';
 
 @ArgsType()
 export class CreateOneCommentArgs {
-  @Field(() => CommentCreateInput, { nullable: false })
-  @Type(() => CommentCreateInput)
-  data!: CommentCreateInput;
+
+    @Field(() => CommentCreateInput, {nullable:false})
+    @Type(() => CommentCreateInput)
+    data!: CommentCreateInput;
 }
diff --git a/@generated/comment/delete-many-comment.args.ts b/@generated/comment/delete-many-comment.args.ts
index f224a9cb..4570f331 100644
--- a/@generated/comment/delete-many-comment.args.ts
+++ b/@generated/comment/delete-many-comment.args.ts
@@ -5,7 +5,8 @@ import { Type } from 'class-transformer';
 
 @ArgsType()
 export class DeleteManyCommentArgs {
-  @Field(() => CommentWhereInput, { nullable: true })
-  @Type(() => CommentWhereInput)
-  where?: CommentWhereInput;
+
+    @Field(() => CommentWhereInput, {nullable:true})
+    @Type(() => CommentWhereInput)
+    where?: CommentWhereInput;
 }
diff --git a/@generated/comment/delete-one-comment.args.ts b/@generated/comment/delete-one-comment.args.ts
index 3cf95886..c5eb1c7d 100644
--- a/@generated/comment/delete-one-comment.args.ts
+++ b/@generated/comment/delete-one-comment.args.ts
@@ -1,12 +1,13 @@
 import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { CommentWhereUniqueInput } from './comment-where-unique.input';
 import { Type } from 'class-transformer';
 
 @ArgsType()
 export class DeleteOneCommentArgs {
-  @Field(() => CommentWhereUniqueInput, { nullable: false })
-  @Type(() => CommentWhereUniqueInput)
-  where!: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
+
+    @Field(() => CommentWhereUniqueInput, {nullable:false})
+    @Type(() => CommentWhereUniqueInput)
+    where!: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
 }
diff --git a/@generated/comment/find-first-comment-or-throw.args.ts b/@generated/comment/find-first-comment-or-throw.args.ts
index d47a3362..961b2046 100644
--- a/@generated/comment/find-first-comment-or-throw.args.ts
+++ b/@generated/comment/find-first-comment-or-throw.args.ts
@@ -3,29 +3,30 @@ import { ArgsType } from '@nestjs/graphql';
 import { CommentWhereInput } from './comment-where.input';
 import { Type } from 'class-transformer';
 import { CommentOrderByWithRelationAndSearchRelevanceInput } from './comment-order-by-with-relation-and-search-relevance.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { CommentWhereUniqueInput } from './comment-where-unique.input';
 import { Int } from '@nestjs/graphql';
 import { CommentScalarFieldEnum } from './comment-scalar-field.enum';
 
 @ArgsType()
 export class FindFirstCommentOrThrowArgs {
-  @Field(() => CommentWhereInput, { nullable: true })
-  @Type(() => CommentWhereInput)
-  where?: CommentWhereInput;
 
-  @Field(() => [CommentOrderByWithRelationAndSearchRelevanceInput], { nullable: true })
-  orderBy?: Array<CommentOrderByWithRelationAndSearchRelevanceInput>;
+    @Field(() => CommentWhereInput, {nullable:true})
+    @Type(() => CommentWhereInput)
+    where?: CommentWhereInput;
 
-  @Field(() => CommentWhereUniqueInput, { nullable: true })
-  cursor?: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
+    @Field(() => [CommentOrderByWithRelationAndSearchRelevanceInput], {nullable:true})
+    orderBy?: Array<CommentOrderByWithRelationAndSearchRelevanceInput>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => CommentWhereUniqueInput, {nullable:true})
+    cursor?: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => [CommentScalarFieldEnum], { nullable: true })
-  distinct?: Array<keyof typeof CommentScalarFieldEnum>;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
+
+    @Field(() => [CommentScalarFieldEnum], {nullable:true})
+    distinct?: Array<keyof typeof CommentScalarFieldEnum>;
 }
diff --git a/@generated/comment/find-first-comment.args.ts b/@generated/comment/find-first-comment.args.ts
index e5c9ef56..38bacdad 100644
--- a/@generated/comment/find-first-comment.args.ts
+++ b/@generated/comment/find-first-comment.args.ts
@@ -3,29 +3,30 @@ import { ArgsType } from '@nestjs/graphql';
 import { CommentWhereInput } from './comment-where.input';
 import { Type } from 'class-transformer';
 import { CommentOrderByWithRelationAndSearchRelevanceInput } from './comment-order-by-with-relation-and-search-relevance.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { CommentWhereUniqueInput } from './comment-where-unique.input';
 import { Int } from '@nestjs/graphql';
 import { CommentScalarFieldEnum } from './comment-scalar-field.enum';
 
 @ArgsType()
 export class FindFirstCommentArgs {
-  @Field(() => CommentWhereInput, { nullable: true })
-  @Type(() => CommentWhereInput)
-  where?: CommentWhereInput;
 
-  @Field(() => [CommentOrderByWithRelationAndSearchRelevanceInput], { nullable: true })
-  orderBy?: Array<CommentOrderByWithRelationAndSearchRelevanceInput>;
+    @Field(() => CommentWhereInput, {nullable:true})
+    @Type(() => CommentWhereInput)
+    where?: CommentWhereInput;
 
-  @Field(() => CommentWhereUniqueInput, { nullable: true })
-  cursor?: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
+    @Field(() => [CommentOrderByWithRelationAndSearchRelevanceInput], {nullable:true})
+    orderBy?: Array<CommentOrderByWithRelationAndSearchRelevanceInput>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => CommentWhereUniqueInput, {nullable:true})
+    cursor?: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => [CommentScalarFieldEnum], { nullable: true })
-  distinct?: Array<keyof typeof CommentScalarFieldEnum>;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
+
+    @Field(() => [CommentScalarFieldEnum], {nullable:true})
+    distinct?: Array<keyof typeof CommentScalarFieldEnum>;
 }
diff --git a/@generated/comment/find-many-comment.args.ts b/@generated/comment/find-many-comment.args.ts
index cb056472..61b28d15 100644
--- a/@generated/comment/find-many-comment.args.ts
+++ b/@generated/comment/find-many-comment.args.ts
@@ -3,29 +3,30 @@ import { ArgsType } from '@nestjs/graphql';
 import { CommentWhereInput } from './comment-where.input';
 import { Type } from 'class-transformer';
 import { CommentOrderByWithRelationAndSearchRelevanceInput } from './comment-order-by-with-relation-and-search-relevance.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { CommentWhereUniqueInput } from './comment-where-unique.input';
 import { Int } from '@nestjs/graphql';
 import { CommentScalarFieldEnum } from './comment-scalar-field.enum';
 
 @ArgsType()
 export class FindManyCommentArgs {
-  @Field(() => CommentWhereInput, { nullable: true })
-  @Type(() => CommentWhereInput)
-  where?: CommentWhereInput;
 
-  @Field(() => [CommentOrderByWithRelationAndSearchRelevanceInput], { nullable: true })
-  orderBy?: Array<CommentOrderByWithRelationAndSearchRelevanceInput>;
+    @Field(() => CommentWhereInput, {nullable:true})
+    @Type(() => CommentWhereInput)
+    where?: CommentWhereInput;
 
-  @Field(() => CommentWhereUniqueInput, { nullable: true })
-  cursor?: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
+    @Field(() => [CommentOrderByWithRelationAndSearchRelevanceInput], {nullable:true})
+    orderBy?: Array<CommentOrderByWithRelationAndSearchRelevanceInput>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => CommentWhereUniqueInput, {nullable:true})
+    cursor?: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => [CommentScalarFieldEnum], { nullable: true })
-  distinct?: Array<keyof typeof CommentScalarFieldEnum>;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
+
+    @Field(() => [CommentScalarFieldEnum], {nullable:true})
+    distinct?: Array<keyof typeof CommentScalarFieldEnum>;
 }
diff --git a/@generated/comment/find-unique-comment-or-throw.args.ts b/@generated/comment/find-unique-comment-or-throw.args.ts
index 11e90587..96adec12 100644
--- a/@generated/comment/find-unique-comment-or-throw.args.ts
+++ b/@generated/comment/find-unique-comment-or-throw.args.ts
@@ -1,12 +1,13 @@
 import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { CommentWhereUniqueInput } from './comment-where-unique.input';
 import { Type } from 'class-transformer';
 
 @ArgsType()
 export class FindUniqueCommentOrThrowArgs {
-  @Field(() => CommentWhereUniqueInput, { nullable: false })
-  @Type(() => CommentWhereUniqueInput)
-  where!: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
+
+    @Field(() => CommentWhereUniqueInput, {nullable:false})
+    @Type(() => CommentWhereUniqueInput)
+    where!: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
 }
diff --git a/@generated/comment/find-unique-comment.args.ts b/@generated/comment/find-unique-comment.args.ts
index c83da804..7d867224 100644
--- a/@generated/comment/find-unique-comment.args.ts
+++ b/@generated/comment/find-unique-comment.args.ts
@@ -1,12 +1,13 @@
 import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { CommentWhereUniqueInput } from './comment-where-unique.input';
 import { Type } from 'class-transformer';
 
 @ArgsType()
 export class FindUniqueCommentArgs {
-  @Field(() => CommentWhereUniqueInput, { nullable: false })
-  @Type(() => CommentWhereUniqueInput)
-  where!: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
+
+    @Field(() => CommentWhereUniqueInput, {nullable:false})
+    @Type(() => CommentWhereUniqueInput)
+    where!: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
 }
diff --git a/@generated/comment/update-many-comment.args.ts b/@generated/comment/update-many-comment.args.ts
index 3cc46548..0f562576 100644
--- a/@generated/comment/update-many-comment.args.ts
+++ b/@generated/comment/update-many-comment.args.ts
@@ -6,11 +6,12 @@ import { CommentWhereInput } from './comment-where.input';
 
 @ArgsType()
 export class UpdateManyCommentArgs {
-  @Field(() => CommentUpdateManyMutationInput, { nullable: false })
-  @Type(() => CommentUpdateManyMutationInput)
-  data!: CommentUpdateManyMutationInput;
 
-  @Field(() => CommentWhereInput, { nullable: true })
-  @Type(() => CommentWhereInput)
-  where?: CommentWhereInput;
+    @Field(() => CommentUpdateManyMutationInput, {nullable:false})
+    @Type(() => CommentUpdateManyMutationInput)
+    data!: CommentUpdateManyMutationInput;
+
+    @Field(() => CommentWhereInput, {nullable:true})
+    @Type(() => CommentWhereInput)
+    where?: CommentWhereInput;
 }
diff --git a/@generated/comment/update-one-comment.args.ts b/@generated/comment/update-one-comment.args.ts
index a4af5988..e8f6f2fa 100644
--- a/@generated/comment/update-one-comment.args.ts
+++ b/@generated/comment/update-one-comment.args.ts
@@ -2,16 +2,17 @@ import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
 import { CommentUpdateInput } from './comment-update.input';
 import { Type } from 'class-transformer';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { CommentWhereUniqueInput } from './comment-where-unique.input';
 
 @ArgsType()
 export class UpdateOneCommentArgs {
-  @Field(() => CommentUpdateInput, { nullable: false })
-  @Type(() => CommentUpdateInput)
-  data!: CommentUpdateInput;
 
-  @Field(() => CommentWhereUniqueInput, { nullable: false })
-  @Type(() => CommentWhereUniqueInput)
-  where!: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
+    @Field(() => CommentUpdateInput, {nullable:false})
+    @Type(() => CommentUpdateInput)
+    data!: CommentUpdateInput;
+
+    @Field(() => CommentWhereUniqueInput, {nullable:false})
+    @Type(() => CommentWhereUniqueInput)
+    where!: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
 }
diff --git a/@generated/comment/upsert-one-comment.args.ts b/@generated/comment/upsert-one-comment.args.ts
index 49e7d49a..f46671db 100644
--- a/@generated/comment/upsert-one-comment.args.ts
+++ b/@generated/comment/upsert-one-comment.args.ts
@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { CommentWhereUniqueInput } from './comment-where-unique.input';
 import { Type } from 'class-transformer';
 import { CommentCreateInput } from './comment-create.input';
@@ -8,15 +8,16 @@ import { CommentUpdateInput } from './comment-update.input';
 
 @ArgsType()
 export class UpsertOneCommentArgs {
-  @Field(() => CommentWhereUniqueInput, { nullable: false })
-  @Type(() => CommentWhereUniqueInput)
-  where!: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
 
-  @Field(() => CommentCreateInput, { nullable: false })
-  @Type(() => CommentCreateInput)
-  create!: CommentCreateInput;
+    @Field(() => CommentWhereUniqueInput, {nullable:false})
+    @Type(() => CommentWhereUniqueInput)
+    where!: Prisma.AtLeast<CommentWhereUniqueInput, 'id'>;
 
-  @Field(() => CommentUpdateInput, { nullable: false })
-  @Type(() => CommentUpdateInput)
-  update!: CommentUpdateInput;
+    @Field(() => CommentCreateInput, {nullable:false})
+    @Type(() => CommentCreateInput)
+    create!: CommentCreateInput;
+
+    @Field(() => CommentUpdateInput, {nullable:false})
+    @Type(() => CommentUpdateInput)
+    update!: CommentUpdateInput;
 }
diff --git a/@generated/dummy/aggregate-dummy.output.ts b/@generated/dummy/aggregate-dummy.output.ts
index 7e8da3a8..c6afb2cb 100644
--- a/@generated/dummy/aggregate-dummy.output.ts
+++ b/@generated/dummy/aggregate-dummy.output.ts
@@ -8,18 +8,19 @@ import { DummyMaxAggregate } from './dummy-max-aggregate.output';
 
 @ObjectType()
 export class AggregateDummy {
-  @Field(() => DummyCountAggregate, { nullable: true })
-  _count?: DummyCountAggregate;
 
-  @Field(() => DummyAvgAggregate, { nullable: true })
-  _avg?: DummyAvgAggregate;
+    @Field(() => DummyCountAggregate, {nullable:true})
+    _count?: DummyCountAggregate;
 
-  @Field(() => DummySumAggregate, { nullable: true })
-  _sum?: DummySumAggregate;
+    @Field(() => DummyAvgAggregate, {nullable:true})
+    _avg?: DummyAvgAggregate;
 
-  @Field(() => DummyMinAggregate, { nullable: true })
-  _min?: DummyMinAggregate;
+    @Field(() => DummySumAggregate, {nullable:true})
+    _sum?: DummySumAggregate;
 
-  @Field(() => DummyMaxAggregate, { nullable: true })
-  _max?: DummyMaxAggregate;
+    @Field(() => DummyMinAggregate, {nullable:true})
+    _min?: DummyMinAggregate;
+
+    @Field(() => DummyMaxAggregate, {nullable:true})
+    _max?: DummyMaxAggregate;
 }
diff --git a/@generated/dummy/create-many-dummy.args.ts b/@generated/dummy/create-many-dummy.args.ts
index c6e17c4c..0439f3f4 100644
--- a/@generated/dummy/create-many-dummy.args.ts
+++ b/@generated/dummy/create-many-dummy.args.ts
@@ -5,10 +5,11 @@ import { Type } from 'class-transformer';
 
 @ArgsType()
 export class CreateManyDummyArgs {
-  @Field(() => [DummyCreateManyInput], { nullable: false })
-  @Type(() => DummyCreateManyInput)
-  data!: Array<DummyCreateManyInput>;
 
-  @Field(() => Boolean, { nullable: true })
-  skipDuplicates?: boolean;
+    @Field(() => [DummyCreateManyInput], {nullable:false})
+    @Type(() => DummyCreateManyInput)
+    data!: Array<DummyCreateManyInput>;
+
+    @Field(() => Boolean, {nullable:true})
+    skipDuplicates?: boolean;
 }
diff --git a/@generated/dummy/create-one-dummy.args.ts b/@generated/dummy/create-one-dummy.args.ts
index b74233bb..07749581 100644
--- a/@generated/dummy/create-one-dummy.args.ts
+++ b/@generated/dummy/create-one-dummy.args.ts
@@ -5,7 +5,8 @@ import { Type } from 'class-transformer';
 
 @ArgsType()
 export class CreateOneDummyArgs {
-  @Field(() => DummyCreateInput, { nullable: false })
-  @Type(() => DummyCreateInput)
-  data!: DummyCreateInput;
+
+    @Field(() => DummyCreateInput, {nullable:false})
+    @Type(() => DummyCreateInput)
+    data!: DummyCreateInput;
 }
diff --git a/@generated/dummy/delete-many-dummy.args.ts b/@generated/dummy/delete-many-dummy.args.ts
index 0e6c001b..1bf80dff 100644
--- a/@generated/dummy/delete-many-dummy.args.ts
+++ b/@generated/dummy/delete-many-dummy.args.ts
@@ -5,7 +5,8 @@ import { Type } from 'class-transformer';
 
 @ArgsType()
 export class DeleteManyDummyArgs {
-  @Field(() => DummyWhereInput, { nullable: true })
-  @Type(() => DummyWhereInput)
-  where?: DummyWhereInput;
+
+    @Field(() => DummyWhereInput, {nullable:true})
+    @Type(() => DummyWhereInput)
+    where?: DummyWhereInput;
 }
diff --git a/@generated/dummy/delete-one-dummy.args.ts b/@generated/dummy/delete-one-dummy.args.ts
index 09de5ce1..66b9ae0c 100644
--- a/@generated/dummy/delete-one-dummy.args.ts
+++ b/@generated/dummy/delete-one-dummy.args.ts
@@ -1,12 +1,13 @@
 import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { DummyWhereUniqueInput } from './dummy-where-unique.input';
 import { Type } from 'class-transformer';
 
 @ArgsType()
 export class DeleteOneDummyArgs {
-  @Field(() => DummyWhereUniqueInput, { nullable: false })
-  @Type(() => DummyWhereUniqueInput)
-  where!: Prisma.AtLeast<DummyWhereUniqueInput, 'id'>;
+
+    @Field(() => DummyWhereUniqueInput, {nullable:false})
+    @Type(() => DummyWhereUniqueInput)
+    where!: Prisma.AtLeast<DummyWhereUniqueInput, 'id'>;
 }
diff --git a/@generated/dummy/dummy-aggregate.args.ts b/@generated/dummy/dummy-aggregate.args.ts
index f59d48a1..efd4af26 100644
--- a/@generated/dummy/dummy-aggregate.args.ts
+++ b/@generated/dummy/dummy-aggregate.args.ts
@@ -3,7 +3,7 @@ import { ArgsType } from '@nestjs/graphql';
 import { DummyWhereInput } from './dummy-where.input';
 import { Type } from 'class-transformer';
 import { DummyOrderByWithRelationAndSearchRelevanceInput } from './dummy-order-by-with-relation-and-search-relevance.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { DummyWhereUniqueInput } from './dummy-where-unique.input';
 import { Int } from '@nestjs/graphql';
 import { DummyCountAggregateInput } from './dummy-count-aggregate.input';
@@ -14,41 +14,42 @@ import { DummyMaxAggregateInput } from './dummy-max-aggregate.input';
 
 @ArgsType()
 export class DummyAggregateArgs {
-  @Field(() => DummyWhereInput, { nullable: true })
-  @Type(() => DummyWhereInput)
-  where?: DummyWhereInput;
 
-  @Field(() => [DummyOrderByWithRelationAndSearchRelevanceInput], { nullable: true })
-  @Type(() => DummyOrderByWithRelationAndSearchRelevanceInput)
-  orderBy?: Array<DummyOrderByWithRelationAndSearchRelevanceInput>;
+    @Field(() => DummyWhereInput, {nullable:true})
+    @Type(() => DummyWhereInput)
+    where?: DummyWhereInput;
 
-  @Field(() => DummyWhereUniqueInput, { nullable: true })
-  @Type(() => DummyWhereUniqueInput)
-  cursor?: Prisma.AtLeast<DummyWhereUniqueInput, 'id'>;
+    @Field(() => [DummyOrderByWithRelationAndSearchRelevanceInput], {nullable:true})
+    @Type(() => DummyOrderByWithRelationAndSearchRelevanceInput)
+    orderBy?: Array<DummyOrderByWithRelationAndSearchRelevanceInput>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => DummyWhereUniqueInput, {nullable:true})
+    @Type(() => DummyWhereUniqueInput)
+    cursor?: Prisma.AtLeast<DummyWhereUniqueInput, 'id'>;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => DummyCountAggregateInput, { nullable: true })
-  @Type(() => DummyCountAggregateInput)
-  _count?: DummyCountAggregateInput;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
 
-  @Field(() => DummyAvgAggregateInput, { nullable: true })
-  @Type(() => DummyAvgAggregateInput)
-  _avg?: DummyAvgAggregateInput;
+    @Field(() => DummyCountAggregateInput, {nullable:true})
+    @Type(() => DummyCountAggregateInput)
+    _count?: DummyCountAggregateInput;
 
-  @Field(() => DummySumAggregateInput, { nullable: true })
-  @Type(() => DummySumAggregateInput)
-  _sum?: DummySumAggregateInput;
+    @Field(() => DummyAvgAggregateInput, {nullable:true})
+    @Type(() => DummyAvgAggregateInput)
+    _avg?: DummyAvgAggregateInput;
 
-  @Field(() => DummyMinAggregateInput, { nullable: true })
-  @Type(() => DummyMinAggregateInput)
-  _min?: DummyMinAggregateInput;
+    @Field(() => DummySumAggregateInput, {nullable:true})
+    @Type(() => DummySumAggregateInput)
+    _sum?: DummySumAggregateInput;
 
-  @Field(() => DummyMaxAggregateInput, { nullable: true })
-  @Type(() => DummyMaxAggregateInput)
-  _max?: DummyMaxAggregateInput;
+    @Field(() => DummyMinAggregateInput, {nullable:true})
+    @Type(() => DummyMinAggregateInput)
+    _min?: DummyMinAggregateInput;
+
+    @Field(() => DummyMaxAggregateInput, {nullable:true})
+    @Type(() => DummyMaxAggregateInput)
+    _max?: DummyMaxAggregateInput;
 }
diff --git a/@generated/dummy/dummy-avg-aggregate.input.ts b/@generated/dummy/dummy-avg-aggregate.input.ts
index 7c96f099..fca0eac3 100644
--- a/@generated/dummy/dummy-avg-aggregate.input.ts
+++ b/@generated/dummy/dummy-avg-aggregate.input.ts
@@ -3,18 +3,19 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class DummyAvgAggregateInput {
-  @Field(() => Boolean, { nullable: true })
-  int?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  float?: true;
+    @Field(() => Boolean, {nullable:true})
+    int?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  decimal?: true;
+    @Field(() => Boolean, {nullable:true})
+    float?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  decimals?: true;
+    @Field(() => Boolean, {nullable:true})
+    decimal?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  bigInt?: true;
+    @Field(() => Boolean, {nullable:true})
+    decimals?: true;
+
+    @Field(() => Boolean, {nullable:true})
+    bigInt?: true;
 }
diff --git a/@generated/dummy/dummy-avg-aggregate.output.ts b/@generated/dummy/dummy-avg-aggregate.output.ts
index c9e6e1d6..6aaa4bba 100644
--- a/@generated/dummy/dummy-avg-aggregate.output.ts
+++ b/@generated/dummy/dummy-avg-aggregate.output.ts
@@ -1,23 +1,24 @@
 import { Field } from '@nestjs/graphql';
 import { ObjectType } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 
 @ObjectType()
 export class DummyAvgAggregate {
-  @Field(() => Float, { nullable: true })
-  int?: number;
 
-  @Field(() => Float, { nullable: true })
-  float?: number;
+    @Field(() => Float, {nullable:true})
+    int?: number;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  decimal?: Decimal;
+    @Field(() => Float, {nullable:true})
+    float?: number;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  decimals?: Decimal;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    decimal?: Decimal;
 
-  @Field(() => Float, { nullable: true })
-  bigInt?: number;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    decimals?: Decimal;
+
+    @Field(() => Float, {nullable:true})
+    bigInt?: number;
 }
diff --git a/@generated/dummy/dummy-avg-order-by-aggregate.input.ts b/@generated/dummy/dummy-avg-order-by-aggregate.input.ts
index 97920d08..c989f44a 100644
--- a/@generated/dummy/dummy-avg-order-by-aggregate.input.ts
+++ b/@generated/dummy/dummy-avg-order-by-aggregate.input.ts
@@ -4,18 +4,19 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class DummyAvgOrderByAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  int?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  float?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    int?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  decimal?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    float?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  decimals?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    decimal?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  bigInt?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    decimals?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    bigInt?: keyof typeof SortOrder;
 }
diff --git a/@generated/dummy/dummy-count-aggregate.input.ts b/@generated/dummy/dummy-count-aggregate.input.ts
index 0f22252a..e647daae 100644
--- a/@generated/dummy/dummy-count-aggregate.input.ts
+++ b/@generated/dummy/dummy-count-aggregate.input.ts
@@ -3,36 +3,37 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class DummyCountAggregateInput {
-  @Field(() => Boolean, { nullable: true })
-  id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  date?: true;
+    @Field(() => Boolean, {nullable:true})
+    id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  int?: true;
+    @Field(() => Boolean, {nullable:true})
+    date?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  float?: true;
+    @Field(() => Boolean, {nullable:true})
+    int?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  bytes?: true;
+    @Field(() => Boolean, {nullable:true})
+    float?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  decimal?: true;
+    @Field(() => Boolean, {nullable:true})
+    bytes?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  decimals?: true;
+    @Field(() => Boolean, {nullable:true})
+    decimal?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  bigInt?: true;
+    @Field(() => Boolean, {nullable:true})
+    decimals?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  json?: true;
+    @Field(() => Boolean, {nullable:true})
+    bigInt?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  friends?: true;
+    @Field(() => Boolean, {nullable:true})
+    json?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  _all?: true;
+    @Field(() => Boolean, {nullable:true})
+    friends?: true;
+
+    @Field(() => Boolean, {nullable:true})
+    _all?: true;
 }
diff --git a/@generated/dummy/dummy-count-aggregate.output.ts b/@generated/dummy/dummy-count-aggregate.output.ts
index d6c2ed05..b588d018 100644
--- a/@generated/dummy/dummy-count-aggregate.output.ts
+++ b/@generated/dummy/dummy-count-aggregate.output.ts
@@ -4,36 +4,37 @@ import { Int } from '@nestjs/graphql';
 
 @ObjectType()
 export class DummyCountAggregate {
-  @Field(() => Int, { nullable: false })
-  id!: number;
 
-  @Field(() => Int, { nullable: false })
-  date!: number;
+    @Field(() => Int, {nullable:false})
+    id!: number;
 
-  @Field(() => Int, { nullable: false })
-  int!: number;
+    @Field(() => Int, {nullable:false})
+    date!: number;
 
-  @Field(() => Int, { nullable: false })
-  float!: number;
+    @Field(() => Int, {nullable:false})
+    int!: number;
 
-  @Field(() => Int, { nullable: false })
-  bytes!: number;
+    @Field(() => Int, {nullable:false})
+    float!: number;
 
-  @Field(() => Int, { nullable: false })
-  decimal!: number;
+    @Field(() => Int, {nullable:false})
+    bytes!: number;
 
-  @Field(() => Int, { nullable: false })
-  decimals!: number;
+    @Field(() => Int, {nullable:false})
+    decimal!: number;
 
-  @Field(() => Int, { nullable: false })
-  bigInt!: number;
+    @Field(() => Int, {nullable:false})
+    decimals!: number;
 
-  @Field(() => Int, { nullable: false })
-  json!: number;
+    @Field(() => Int, {nullable:false})
+    bigInt!: number;
 
-  @Field(() => Int, { nullable: false })
-  friends!: number;
+    @Field(() => Int, {nullable:false})
+    json!: number;
 
-  @Field(() => Int, { nullable: false })
-  _all!: number;
+    @Field(() => Int, {nullable:false})
+    friends!: number;
+
+    @Field(() => Int, {nullable:false})
+    _all!: number;
 }
diff --git a/@generated/dummy/dummy-count-order-by-aggregate.input.ts b/@generated/dummy/dummy-count-order-by-aggregate.input.ts
index ec70cd56..fe31a65f 100644
--- a/@generated/dummy/dummy-count-order-by-aggregate.input.ts
+++ b/@generated/dummy/dummy-count-order-by-aggregate.input.ts
@@ -4,33 +4,34 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class DummyCountOrderByAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  date?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  int?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    date?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  float?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    int?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  bytes?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    float?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  decimal?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    bytes?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  decimals?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    decimal?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  bigInt?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    decimals?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  json?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    bigInt?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  friends?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    json?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    friends?: keyof typeof SortOrder;
 }
diff --git a/@generated/dummy/dummy-create-many.input.ts b/@generated/dummy/dummy-create-many.input.ts
index 46539d76..dc111cb1 100644
--- a/@generated/dummy/dummy-create-many.input.ts
+++ b/@generated/dummy/dummy-create-many.input.ts
@@ -2,7 +2,7 @@ import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
 import { Int } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -13,37 +13,38 @@ import { DummyCreatefriendsInput } from './dummy-createfriends.input';
 
 @InputType()
 export class DummyCreateManyInput {
-  @Field(() => String, { nullable: false })
-  id!: string;
 
-  @Field(() => Date, { nullable: true })
-  date?: Date | string;
+    @Field(() => String, {nullable:false})
+    id!: string;
 
-  @Field(() => Int, { nullable: true })
-  int?: number;
+    @Field(() => Date, {nullable:true})
+    date?: Date | string;
 
-  @Field(() => Float, { nullable: true })
-  float?: number;
+    @Field(() => Int, {nullable:true})
+    int?: number;
 
-  @Field(() => String, { nullable: true })
-  bytes?: Buffer;
+    @Field(() => Float, {nullable:true})
+    float?: number;
 
-  @Field(() => GraphQLDecimal, { nullable: false })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  decimal!: Decimal;
+    @Field(() => String, {nullable:true})
+    bytes?: Buffer;
 
-  @Field(() => DummyCreatedecimalsInput, { nullable: true })
-  @Type(() => DummyCreatedecimalsInput)
-  decimals?: DummyCreatedecimalsInput;
+    @Field(() => GraphQLDecimal, {nullable:false})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    decimal!: Decimal;
 
-  @Field(() => String, { nullable: true })
-  bigInt?: bigint | number;
+    @Field(() => DummyCreatedecimalsInput, {nullable:true})
+    @Type(() => DummyCreatedecimalsInput)
+    decimals?: DummyCreatedecimalsInput;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  json?: any;
+    @Field(() => String, {nullable:true})
+    bigInt?: bigint | number;
 
-  @Field(() => DummyCreatefriendsInput, { nullable: true })
-  @Type(() => DummyCreatefriendsInput)
-  friends?: DummyCreatefriendsInput;
+    @Field(() => GraphQLJSON, {nullable:true})
+    json?: any;
+
+    @Field(() => DummyCreatefriendsInput, {nullable:true})
+    @Type(() => DummyCreatefriendsInput)
+    friends?: DummyCreatefriendsInput;
 }
diff --git a/@generated/dummy/dummy-create.input.ts b/@generated/dummy/dummy-create.input.ts
index e4836df6..f90692bc 100644
--- a/@generated/dummy/dummy-create.input.ts
+++ b/@generated/dummy/dummy-create.input.ts
@@ -2,7 +2,7 @@ import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
 import { Int } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -13,37 +13,38 @@ import { DummyCreatefriendsInput } from './dummy-createfriends.input';
 
 @InputType()
 export class DummyCreateInput {
-  @Field(() => String, { nullable: false })
-  id!: string;
 
-  @Field(() => Date, { nullable: true })
-  date?: Date | string;
+    @Field(() => String, {nullable:false})
+    id!: string;
 
-  @Field(() => Int, { nullable: true })
-  int?: number;
+    @Field(() => Date, {nullable:true})
+    date?: Date | string;
 
-  @Field(() => Float, { nullable: true })
-  float?: number;
+    @Field(() => Int, {nullable:true})
+    int?: number;
 
-  @Field(() => String, { nullable: true })
-  bytes?: Buffer;
+    @Field(() => Float, {nullable:true})
+    float?: number;
 
-  @Field(() => GraphQLDecimal, { nullable: false })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  decimal!: Decimal;
+    @Field(() => String, {nullable:true})
+    bytes?: Buffer;
 
-  @Field(() => DummyCreatedecimalsInput, { nullable: true })
-  @Type(() => DummyCreatedecimalsInput)
-  decimals?: DummyCreatedecimalsInput;
+    @Field(() => GraphQLDecimal, {nullable:false})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    decimal!: Decimal;
 
-  @Field(() => String, { nullable: true })
-  bigInt?: bigint | number;
+    @Field(() => DummyCreatedecimalsInput, {nullable:true})
+    @Type(() => DummyCreatedecimalsInput)
+    decimals?: DummyCreatedecimalsInput;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  json?: any;
+    @Field(() => String, {nullable:true})
+    bigInt?: bigint | number;
 
-  @Field(() => DummyCreatefriendsInput, { nullable: true })
-  @Type(() => DummyCreatefriendsInput)
-  friends?: DummyCreatefriendsInput;
+    @Field(() => GraphQLJSON, {nullable:true})
+    json?: any;
+
+    @Field(() => DummyCreatefriendsInput, {nullable:true})
+    @Type(() => DummyCreatefriendsInput)
+    friends?: DummyCreatefriendsInput;
 }
diff --git a/@generated/dummy/dummy-createdecimals.input.ts b/@generated/dummy/dummy-createdecimals.input.ts
index da8e8ca9..033e31e7 100644
--- a/@generated/dummy/dummy-createdecimals.input.ts
+++ b/@generated/dummy/dummy-createdecimals.input.ts
@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -8,8 +8,9 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class DummyCreatedecimalsInput {
-  @Field(() => [GraphQLDecimal], { nullable: false })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  set!: Array<Decimal>;
+
+    @Field(() => [GraphQLDecimal], {nullable:false})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    set!: Array<Decimal>;
 }
diff --git a/@generated/dummy/dummy-createfriends.input.ts b/@generated/dummy/dummy-createfriends.input.ts
index a0c11969..800f32b7 100644
--- a/@generated/dummy/dummy-createfriends.input.ts
+++ b/@generated/dummy/dummy-createfriends.input.ts
@@ -3,6 +3,7 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class DummyCreatefriendsInput {
-  @Field(() => [String], { nullable: false })
-  set!: Array<string>;
+
+    @Field(() => [String], {nullable:false})
+    set!: Array<string>;
 }
diff --git a/@generated/dummy/dummy-group-by.args.ts b/@generated/dummy/dummy-group-by.args.ts
index 32273253..6479d236 100644
--- a/@generated/dummy/dummy-group-by.args.ts
+++ b/@generated/dummy/dummy-group-by.args.ts
@@ -14,44 +14,45 @@ import { DummyMaxAggregateInput } from './dummy-max-aggregate.input';
 
 @ArgsType()
 export class DummyGroupByArgs {
-  @Field(() => DummyWhereInput, { nullable: true })
-  @Type(() => DummyWhereInput)
-  where?: DummyWhereInput;
 
-  @Field(() => [DummyOrderByWithAggregationInput], { nullable: true })
-  @Type(() => DummyOrderByWithAggregationInput)
-  orderBy?: Array<DummyOrderByWithAggregationInput>;
+    @Field(() => DummyWhereInput, {nullable:true})
+    @Type(() => DummyWhereInput)
+    where?: DummyWhereInput;
 
-  @Field(() => [DummyScalarFieldEnum], { nullable: false })
-  by!: Array<keyof typeof DummyScalarFieldEnum>;
+    @Field(() => [DummyOrderByWithAggregationInput], {nullable:true})
+    @Type(() => DummyOrderByWithAggregationInput)
+    orderBy?: Array<DummyOrderByWithAggregationInput>;
 
-  @Field(() => DummyScalarWhereWithAggregatesInput, { nullable: true })
-  @Type(() => DummyScalarWhereWithAggregatesInput)
-  having?: DummyScalarWhereWithAggregatesInput;
+    @Field(() => [DummyScalarFieldEnum], {nullable:false})
+    by!: Array<keyof typeof DummyScalarFieldEnum>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => DummyScalarWhereWithAggregatesInput, {nullable:true})
+    @Type(() => DummyScalarWhereWithAggregatesInput)
+    having?: DummyScalarWhereWithAggregatesInput;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => DummyCountAggregateInput, { nullable: true })
-  @Type(() => DummyCountAggregateInput)
-  _count?: DummyCountAggregateInput;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
 
-  @Field(() => DummyAvgAggregateInput, { nullable: true })
-  @Type(() => DummyAvgAggregateInput)
-  _avg?: DummyAvgAggregateInput;
+    @Field(() => DummyCountAggregateInput, {nullable:true})
+    @Type(() => DummyCountAggregateInput)
+    _count?: DummyCountAggregateInput;
 
-  @Field(() => DummySumAggregateInput, { nullable: true })
-  @Type(() => DummySumAggregateInput)
-  _sum?: DummySumAggregateInput;
+    @Field(() => DummyAvgAggregateInput, {nullable:true})
+    @Type(() => DummyAvgAggregateInput)
+    _avg?: DummyAvgAggregateInput;
 
-  @Field(() => DummyMinAggregateInput, { nullable: true })
-  @Type(() => DummyMinAggregateInput)
-  _min?: DummyMinAggregateInput;
+    @Field(() => DummySumAggregateInput, {nullable:true})
+    @Type(() => DummySumAggregateInput)
+    _sum?: DummySumAggregateInput;
 
-  @Field(() => DummyMaxAggregateInput, { nullable: true })
-  @Type(() => DummyMaxAggregateInput)
-  _max?: DummyMaxAggregateInput;
+    @Field(() => DummyMinAggregateInput, {nullable:true})
+    @Type(() => DummyMinAggregateInput)
+    _min?: DummyMinAggregateInput;
+
+    @Field(() => DummyMaxAggregateInput, {nullable:true})
+    @Type(() => DummyMaxAggregateInput)
+    _max?: DummyMaxAggregateInput;
 }
diff --git a/@generated/dummy/dummy-group-by.output.ts b/@generated/dummy/dummy-group-by.output.ts
index 43c28161..9f802c3c 100644
--- a/@generated/dummy/dummy-group-by.output.ts
+++ b/@generated/dummy/dummy-group-by.output.ts
@@ -2,7 +2,7 @@ import { Field } from '@nestjs/graphql';
 import { ObjectType } from '@nestjs/graphql';
 import { Int } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { GraphQLJSON } from 'graphql-type-json';
 import { DummyCountAggregate } from './dummy-count-aggregate.output';
@@ -13,48 +13,49 @@ import { DummyMaxAggregate } from './dummy-max-aggregate.output';
 
 @ObjectType()
 export class DummyGroupBy {
-  @Field(() => String, { nullable: false })
-  id!: string;
 
-  @Field(() => Date, { nullable: true })
-  date?: Date | string;
+    @Field(() => String, {nullable:false})
+    id!: string;
 
-  @Field(() => Int, { nullable: true })
-  int?: number;
+    @Field(() => Date, {nullable:true})
+    date?: Date | string;
 
-  @Field(() => Float, { nullable: true })
-  float?: number;
+    @Field(() => Int, {nullable:true})
+    int?: number;
 
-  @Field(() => String, { nullable: true })
-  bytes?: Buffer;
+    @Field(() => Float, {nullable:true})
+    float?: number;
 
-  @Field(() => GraphQLDecimal, { nullable: false })
-  decimal!: Decimal;
+    @Field(() => String, {nullable:true})
+    bytes?: Buffer;
 
-  @Field(() => [GraphQLDecimal], { nullable: true })
-  decimals?: Array<Decimal>;
+    @Field(() => GraphQLDecimal, {nullable:false})
+    decimal!: Decimal;
 
-  @Field(() => String, { nullable: true })
-  bigInt?: bigint | number;
+    @Field(() => [GraphQLDecimal], {nullable:true})
+    decimals?: Array<Decimal>;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  json?: any;
+    @Field(() => String, {nullable:true})
+    bigInt?: bigint | number;
 
-  @Field(() => [String], { nullable: true })
-  friends?: Array<string>;
+    @Field(() => GraphQLJSON, {nullable:true})
+    json?: any;
 
-  @Field(() => DummyCountAggregate, { nullable: true })
-  _count?: DummyCountAggregate;
+    @Field(() => [String], {nullable:true})
+    friends?: Array<string>;
 
-  @Field(() => DummyAvgAggregate, { nullable: true })
-  _avg?: DummyAvgAggregate;
+    @Field(() => DummyCountAggregate, {nullable:true})
+    _count?: DummyCountAggregate;
 
-  @Field(() => DummySumAggregate, { nullable: true })
-  _sum?: DummySumAggregate;
+    @Field(() => DummyAvgAggregate, {nullable:true})
+    _avg?: DummyAvgAggregate;
 
-  @Field(() => DummyMinAggregate, { nullable: true })
-  _min?: DummyMinAggregate;
+    @Field(() => DummySumAggregate, {nullable:true})
+    _sum?: DummySumAggregate;
 
-  @Field(() => DummyMaxAggregate, { nullable: true })
-  _max?: DummyMaxAggregate;
+    @Field(() => DummyMinAggregate, {nullable:true})
+    _min?: DummyMinAggregate;
+
+    @Field(() => DummyMaxAggregate, {nullable:true})
+    _max?: DummyMaxAggregate;
 }
diff --git a/@generated/dummy/dummy-max-aggregate.input.ts b/@generated/dummy/dummy-max-aggregate.input.ts
index 584e4f7a..38878789 100644
--- a/@generated/dummy/dummy-max-aggregate.input.ts
+++ b/@generated/dummy/dummy-max-aggregate.input.ts
@@ -3,24 +3,25 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class DummyMaxAggregateInput {
-  @Field(() => Boolean, { nullable: true })
-  id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  date?: true;
+    @Field(() => Boolean, {nullable:true})
+    id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  int?: true;
+    @Field(() => Boolean, {nullable:true})
+    date?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  float?: true;
+    @Field(() => Boolean, {nullable:true})
+    int?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  bytes?: true;
+    @Field(() => Boolean, {nullable:true})
+    float?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  decimal?: true;
+    @Field(() => Boolean, {nullable:true})
+    bytes?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  bigInt?: true;
+    @Field(() => Boolean, {nullable:true})
+    decimal?: true;
+
+    @Field(() => Boolean, {nullable:true})
+    bigInt?: true;
 }
diff --git a/@generated/dummy/dummy-max-aggregate.output.ts b/@generated/dummy/dummy-max-aggregate.output.ts
index 852095fa..aa857bb0 100644
--- a/@generated/dummy/dummy-max-aggregate.output.ts
+++ b/@generated/dummy/dummy-max-aggregate.output.ts
@@ -2,29 +2,30 @@ import { Field } from '@nestjs/graphql';
 import { ObjectType } from '@nestjs/graphql';
 import { Int } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 
 @ObjectType()
 export class DummyMaxAggregate {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => Date, { nullable: true })
-  date?: Date | string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => Int, { nullable: true })
-  int?: number;
+    @Field(() => Date, {nullable:true})
+    date?: Date | string;
 
-  @Field(() => Float, { nullable: true })
-  float?: number;
+    @Field(() => Int, {nullable:true})
+    int?: number;
 
-  @Field(() => String, { nullable: true })
-  bytes?: Buffer;
+    @Field(() => Float, {nullable:true})
+    float?: number;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  decimal?: Decimal;
+    @Field(() => String, {nullable:true})
+    bytes?: Buffer;
 
-  @Field(() => String, { nullable: true })
-  bigInt?: bigint | number;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    decimal?: Decimal;
+
+    @Field(() => String, {nullable:true})
+    bigInt?: bigint | number;
 }
diff --git a/@generated/dummy/dummy-max-order-by-aggregate.input.ts b/@generated/dummy/dummy-max-order-by-aggregate.input.ts
index bed3aaba..ce2b0a3f 100644
--- a/@generated/dummy/dummy-max-order-by-aggregate.input.ts
+++ b/@generated/dummy/dummy-max-order-by-aggregate.input.ts
@@ -4,24 +4,25 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class DummyMaxOrderByAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  date?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  int?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    date?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  float?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    int?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  bytes?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    float?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  decimal?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    bytes?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  bigInt?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    decimal?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    bigInt?: keyof typeof SortOrder;
 }
diff --git a/@generated/dummy/dummy-min-aggregate.input.ts b/@generated/dummy/dummy-min-aggregate.input.ts
index 472704ed..ca819cdc 100644
--- a/@generated/dummy/dummy-min-aggregate.input.ts
+++ b/@generated/dummy/dummy-min-aggregate.input.ts
@@ -3,24 +3,25 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class DummyMinAggregateInput {
-  @Field(() => Boolean, { nullable: true })
-  id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  date?: true;
+    @Field(() => Boolean, {nullable:true})
+    id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  int?: true;
+    @Field(() => Boolean, {nullable:true})
+    date?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  float?: true;
+    @Field(() => Boolean, {nullable:true})
+    int?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  bytes?: true;
+    @Field(() => Boolean, {nullable:true})
+    float?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  decimal?: true;
+    @Field(() => Boolean, {nullable:true})
+    bytes?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  bigInt?: true;
+    @Field(() => Boolean, {nullable:true})
+    decimal?: true;
+
+    @Field(() => Boolean, {nullable:true})
+    bigInt?: true;
 }
diff --git a/@generated/dummy/dummy-min-aggregate.output.ts b/@generated/dummy/dummy-min-aggregate.output.ts
index bb39fbcc..610ef912 100644
--- a/@generated/dummy/dummy-min-aggregate.output.ts
+++ b/@generated/dummy/dummy-min-aggregate.output.ts
@@ -2,29 +2,30 @@ import { Field } from '@nestjs/graphql';
 import { ObjectType } from '@nestjs/graphql';
 import { Int } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 
 @ObjectType()
 export class DummyMinAggregate {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => Date, { nullable: true })
-  date?: Date | string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => Int, { nullable: true })
-  int?: number;
+    @Field(() => Date, {nullable:true})
+    date?: Date | string;
 
-  @Field(() => Float, { nullable: true })
-  float?: number;
+    @Field(() => Int, {nullable:true})
+    int?: number;
 
-  @Field(() => String, { nullable: true })
-  bytes?: Buffer;
+    @Field(() => Float, {nullable:true})
+    float?: number;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  decimal?: Decimal;
+    @Field(() => String, {nullable:true})
+    bytes?: Buffer;
 
-  @Field(() => String, { nullable: true })
-  bigInt?: bigint | number;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    decimal?: Decimal;
+
+    @Field(() => String, {nullable:true})
+    bigInt?: bigint | number;
 }
diff --git a/@generated/dummy/dummy-min-order-by-aggregate.input.ts b/@generated/dummy/dummy-min-order-by-aggregate.input.ts
index ecce96f4..6d162068 100644
--- a/@generated/dummy/dummy-min-order-by-aggregate.input.ts
+++ b/@generated/dummy/dummy-min-order-by-aggregate.input.ts
@@ -4,24 +4,25 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class DummyMinOrderByAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  date?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  int?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    date?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  float?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    int?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  bytes?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    float?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  decimal?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    bytes?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  bigInt?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    decimal?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    bigInt?: keyof typeof SortOrder;
 }
diff --git a/@generated/dummy/dummy-order-by-relevance-field.enum.ts b/@generated/dummy/dummy-order-by-relevance-field.enum.ts
index 534e7081..70303b0b 100644
--- a/@generated/dummy/dummy-order-by-relevance-field.enum.ts
+++ b/@generated/dummy/dummy-order-by-relevance-field.enum.ts
@@ -1,11 +1,9 @@
 import { registerEnumType } from '@nestjs/graphql';
 
 export enum DummyOrderByRelevanceFieldEnum {
-  id = 'id',
-  friends = 'friends',
+    id = "id",
+    friends = "friends"
 }
 
-registerEnumType(DummyOrderByRelevanceFieldEnum, {
-  name: 'DummyOrderByRelevanceFieldEnum',
-  description: undefined,
-});
+
+registerEnumType(DummyOrderByRelevanceFieldEnum, { name: 'DummyOrderByRelevanceFieldEnum', description: undefined })
diff --git a/@generated/dummy/dummy-order-by-relevance.input.ts b/@generated/dummy/dummy-order-by-relevance.input.ts
index d3bf234d..28506023 100644
--- a/@generated/dummy/dummy-order-by-relevance.input.ts
+++ b/@generated/dummy/dummy-order-by-relevance.input.ts
@@ -5,12 +5,13 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class DummyOrderByRelevanceInput {
-  @Field(() => [DummyOrderByRelevanceFieldEnum], { nullable: false })
-  fields!: Array<keyof typeof DummyOrderByRelevanceFieldEnum>;
 
-  @Field(() => SortOrder, { nullable: false })
-  sort!: keyof typeof SortOrder;
+    @Field(() => [DummyOrderByRelevanceFieldEnum], {nullable:false})
+    fields!: Array<keyof typeof DummyOrderByRelevanceFieldEnum>;
 
-  @Field(() => String, { nullable: false })
-  search!: string;
+    @Field(() => SortOrder, {nullable:false})
+    sort!: keyof typeof SortOrder;
+
+    @Field(() => String, {nullable:false})
+    search!: string;
 }
diff --git a/@generated/dummy/dummy-order-by-with-aggregation.input.ts b/@generated/dummy/dummy-order-by-with-aggregation.input.ts
index 5da3c521..17515894 100644
--- a/@generated/dummy/dummy-order-by-with-aggregation.input.ts
+++ b/@generated/dummy/dummy-order-by-with-aggregation.input.ts
@@ -11,53 +11,54 @@ import { DummySumOrderByAggregateInput } from './dummy-sum-order-by-aggregate.in
 
 @InputType()
 export class DummyOrderByWithAggregationInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  date?: SortOrderInput;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  int?: SortOrderInput;
+    @Field(() => SortOrderInput, {nullable:true})
+    date?: SortOrderInput;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  float?: SortOrderInput;
+    @Field(() => SortOrderInput, {nullable:true})
+    int?: SortOrderInput;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  bytes?: SortOrderInput;
+    @Field(() => SortOrderInput, {nullable:true})
+    float?: SortOrderInput;
 
-  @Field(() => SortOrder, { nullable: true })
-  decimal?: keyof typeof SortOrder;
+    @Field(() => SortOrderInput, {nullable:true})
+    bytes?: SortOrderInput;
 
-  @Field(() => SortOrder, { nullable: true })
-  decimals?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    decimal?: keyof typeof SortOrder;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  bigInt?: SortOrderInput;
+    @Field(() => SortOrder, {nullable:true})
+    decimals?: keyof typeof SortOrder;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  json?: SortOrderInput;
+    @Field(() => SortOrderInput, {nullable:true})
+    bigInt?: SortOrderInput;
 
-  @Field(() => SortOrder, { nullable: true })
-  friends?: keyof typeof SortOrder;
+    @Field(() => SortOrderInput, {nullable:true})
+    json?: SortOrderInput;
 
-  @Field(() => DummyCountOrderByAggregateInput, { nullable: true })
-  @Type(() => DummyCountOrderByAggregateInput)
-  _count?: DummyCountOrderByAggregateInput;
+    @Field(() => SortOrder, {nullable:true})
+    friends?: keyof typeof SortOrder;
 
-  @Field(() => DummyAvgOrderByAggregateInput, { nullable: true })
-  @Type(() => DummyAvgOrderByAggregateInput)
-  _avg?: DummyAvgOrderByAggregateInput;
+    @Field(() => DummyCountOrderByAggregateInput, {nullable:true})
+    @Type(() => DummyCountOrderByAggregateInput)
+    _count?: DummyCountOrderByAggregateInput;
 
-  @Field(() => DummyMaxOrderByAggregateInput, { nullable: true })
-  @Type(() => DummyMaxOrderByAggregateInput)
-  _max?: DummyMaxOrderByAggregateInput;
+    @Field(() => DummyAvgOrderByAggregateInput, {nullable:true})
+    @Type(() => DummyAvgOrderByAggregateInput)
+    _avg?: DummyAvgOrderByAggregateInput;
 
-  @Field(() => DummyMinOrderByAggregateInput, { nullable: true })
-  @Type(() => DummyMinOrderByAggregateInput)
-  _min?: DummyMinOrderByAggregateInput;
+    @Field(() => DummyMaxOrderByAggregateInput, {nullable:true})
+    @Type(() => DummyMaxOrderByAggregateInput)
+    _max?: DummyMaxOrderByAggregateInput;
 
-  @Field(() => DummySumOrderByAggregateInput, { nullable: true })
-  @Type(() => DummySumOrderByAggregateInput)
-  _sum?: DummySumOrderByAggregateInput;
+    @Field(() => DummyMinOrderByAggregateInput, {nullable:true})
+    @Type(() => DummyMinOrderByAggregateInput)
+    _min?: DummyMinOrderByAggregateInput;
+
+    @Field(() => DummySumOrderByAggregateInput, {nullable:true})
+    @Type(() => DummySumOrderByAggregateInput)
+    _sum?: DummySumOrderByAggregateInput;
 }
diff --git a/@generated/dummy/dummy-order-by-with-relation-and-search-relevance.input.ts b/@generated/dummy/dummy-order-by-with-relation-and-search-relevance.input.ts
index 3ef3cab8..803710b0 100644
--- a/@generated/dummy/dummy-order-by-with-relation-and-search-relevance.input.ts
+++ b/@generated/dummy/dummy-order-by-with-relation-and-search-relevance.input.ts
@@ -7,37 +7,38 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class DummyOrderByWithRelationAndSearchRelevanceInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  date?: SortOrderInput;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  int?: SortOrderInput;
+    @Field(() => SortOrderInput, {nullable:true})
+    date?: SortOrderInput;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  float?: SortOrderInput;
+    @Field(() => SortOrderInput, {nullable:true})
+    int?: SortOrderInput;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  bytes?: SortOrderInput;
+    @Field(() => SortOrderInput, {nullable:true})
+    float?: SortOrderInput;
 
-  @Field(() => SortOrder, { nullable: true })
-  decimal?: keyof typeof SortOrder;
+    @Field(() => SortOrderInput, {nullable:true})
+    bytes?: SortOrderInput;
 
-  @Field(() => SortOrder, { nullable: true })
-  decimals?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    decimal?: keyof typeof SortOrder;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  bigInt?: SortOrderInput;
+    @Field(() => SortOrder, {nullable:true})
+    decimals?: keyof typeof SortOrder;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  json?: SortOrderInput;
+    @Field(() => SortOrderInput, {nullable:true})
+    bigInt?: SortOrderInput;
 
-  @Field(() => SortOrder, { nullable: true })
-  friends?: keyof typeof SortOrder;
+    @Field(() => SortOrderInput, {nullable:true})
+    json?: SortOrderInput;
 
-  @Field(() => DummyOrderByRelevanceInput, { nullable: true })
-  @Type(() => DummyOrderByRelevanceInput)
-  _relevance?: DummyOrderByRelevanceInput;
+    @Field(() => SortOrder, {nullable:true})
+    friends?: keyof typeof SortOrder;
+
+    @Field(() => DummyOrderByRelevanceInput, {nullable:true})
+    @Type(() => DummyOrderByRelevanceInput)
+    _relevance?: DummyOrderByRelevanceInput;
 }
diff --git a/@generated/dummy/dummy-scalar-field.enum.ts b/@generated/dummy/dummy-scalar-field.enum.ts
index 2f59deaa..b92836c1 100644
--- a/@generated/dummy/dummy-scalar-field.enum.ts
+++ b/@generated/dummy/dummy-scalar-field.enum.ts
@@ -1,19 +1,17 @@
 import { registerEnumType } from '@nestjs/graphql';
 
 export enum DummyScalarFieldEnum {
-  id = 'id',
-  date = 'date',
-  int = 'int',
-  float = 'float',
-  bytes = 'bytes',
-  decimal = 'decimal',
-  decimals = 'decimals',
-  bigInt = 'bigInt',
-  json = 'json',
-  friends = 'friends',
+    id = "id",
+    date = "date",
+    int = "int",
+    float = "float",
+    bytes = "bytes",
+    decimal = "decimal",
+    decimals = "decimals",
+    bigInt = "bigInt",
+    json = "json",
+    friends = "friends"
 }
 
-registerEnumType(DummyScalarFieldEnum, {
-  name: 'DummyScalarFieldEnum',
-  description: undefined,
-});
+
+registerEnumType(DummyScalarFieldEnum, { name: 'DummyScalarFieldEnum', description: undefined })
diff --git a/@generated/dummy/dummy-scalar-where-with-aggregates.input.ts b/@generated/dummy/dummy-scalar-where-with-aggregates.input.ts
index 029516da..2b66609d 100644
--- a/@generated/dummy/dummy-scalar-where-with-aggregates.input.ts
+++ b/@generated/dummy/dummy-scalar-where-with-aggregates.input.ts
@@ -14,47 +14,48 @@ import { StringNullableListFilter } from '../prisma/string-nullable-list-filter.
 
 @InputType()
 export class DummyScalarWhereWithAggregatesInput {
-  @Field(() => [DummyScalarWhereWithAggregatesInput], { nullable: true })
-  @Type(() => DummyScalarWhereWithAggregatesInput)
-  AND?: Array<DummyScalarWhereWithAggregatesInput>;
 
-  @Field(() => [DummyScalarWhereWithAggregatesInput], { nullable: true })
-  @Type(() => DummyScalarWhereWithAggregatesInput)
-  OR?: Array<DummyScalarWhereWithAggregatesInput>;
+    @Field(() => [DummyScalarWhereWithAggregatesInput], {nullable:true})
+    @Type(() => DummyScalarWhereWithAggregatesInput)
+    AND?: Array<DummyScalarWhereWithAggregatesInput>;
 
-  @Field(() => [DummyScalarWhereWithAggregatesInput], { nullable: true })
-  @Type(() => DummyScalarWhereWithAggregatesInput)
-  NOT?: Array<DummyScalarWhereWithAggregatesInput>;
+    @Field(() => [DummyScalarWhereWithAggregatesInput], {nullable:true})
+    @Type(() => DummyScalarWhereWithAggregatesInput)
+    OR?: Array<DummyScalarWhereWithAggregatesInput>;
 
-  @Field(() => StringWithAggregatesFilter, { nullable: true })
-  id?: StringWithAggregatesFilter;
+    @Field(() => [DummyScalarWhereWithAggregatesInput], {nullable:true})
+    @Type(() => DummyScalarWhereWithAggregatesInput)
+    NOT?: Array<DummyScalarWhereWithAggregatesInput>;
 
-  @Field(() => DateTimeNullableWithAggregatesFilter, { nullable: true })
-  date?: DateTimeNullableWithAggregatesFilter;
+    @Field(() => StringWithAggregatesFilter, {nullable:true})
+    id?: StringWithAggregatesFilter;
 
-  @Field(() => IntNullableWithAggregatesFilter, { nullable: true })
-  int?: IntNullableWithAggregatesFilter;
+    @Field(() => DateTimeNullableWithAggregatesFilter, {nullable:true})
+    date?: DateTimeNullableWithAggregatesFilter;
 
-  @Field(() => FloatNullableWithAggregatesFilter, { nullable: true })
-  float?: FloatNullableWithAggregatesFilter;
+    @Field(() => IntNullableWithAggregatesFilter, {nullable:true})
+    int?: IntNullableWithAggregatesFilter;
 
-  @Field(() => BytesNullableWithAggregatesFilter, { nullable: true })
-  bytes?: BytesNullableWithAggregatesFilter;
+    @Field(() => FloatNullableWithAggregatesFilter, {nullable:true})
+    float?: FloatNullableWithAggregatesFilter;
 
-  @Field(() => DecimalWithAggregatesFilter, { nullable: true })
-  @Type(() => DecimalWithAggregatesFilter)
-  decimal?: DecimalWithAggregatesFilter;
+    @Field(() => BytesNullableWithAggregatesFilter, {nullable:true})
+    bytes?: BytesNullableWithAggregatesFilter;
 
-  @Field(() => DecimalNullableListFilter, { nullable: true })
-  @Type(() => DecimalNullableListFilter)
-  decimals?: DecimalNullableListFilter;
+    @Field(() => DecimalWithAggregatesFilter, {nullable:true})
+    @Type(() => DecimalWithAggregatesFilter)
+    decimal?: DecimalWithAggregatesFilter;
 
-  @Field(() => BigIntNullableWithAggregatesFilter, { nullable: true })
-  bigInt?: BigIntNullableWithAggregatesFilter;
+    @Field(() => DecimalNullableListFilter, {nullable:true})
+    @Type(() => DecimalNullableListFilter)
+    decimals?: DecimalNullableListFilter;
 
-  @Field(() => JsonNullableWithAggregatesFilter, { nullable: true })
-  json?: JsonNullableWithAggregatesFilter;
+    @Field(() => BigIntNullableWithAggregatesFilter, {nullable:true})
+    bigInt?: BigIntNullableWithAggregatesFilter;
 
-  @Field(() => StringNullableListFilter, { nullable: true })
-  friends?: StringNullableListFilter;
+    @Field(() => JsonNullableWithAggregatesFilter, {nullable:true})
+    json?: JsonNullableWithAggregatesFilter;
+
+    @Field(() => StringNullableListFilter, {nullable:true})
+    friends?: StringNullableListFilter;
 }
diff --git a/@generated/dummy/dummy-sum-aggregate.input.ts b/@generated/dummy/dummy-sum-aggregate.input.ts
index 7c01517d..3ea8e643 100644
--- a/@generated/dummy/dummy-sum-aggregate.input.ts
+++ b/@generated/dummy/dummy-sum-aggregate.input.ts
@@ -3,18 +3,19 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class DummySumAggregateInput {
-  @Field(() => Boolean, { nullable: true })
-  int?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  float?: true;
+    @Field(() => Boolean, {nullable:true})
+    int?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  decimal?: true;
+    @Field(() => Boolean, {nullable:true})
+    float?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  decimals?: true;
+    @Field(() => Boolean, {nullable:true})
+    decimal?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  bigInt?: true;
+    @Field(() => Boolean, {nullable:true})
+    decimals?: true;
+
+    @Field(() => Boolean, {nullable:true})
+    bigInt?: true;
 }
diff --git a/@generated/dummy/dummy-sum-aggregate.output.ts b/@generated/dummy/dummy-sum-aggregate.output.ts
index a68045db..36f927e7 100644
--- a/@generated/dummy/dummy-sum-aggregate.output.ts
+++ b/@generated/dummy/dummy-sum-aggregate.output.ts
@@ -2,23 +2,24 @@ import { Field } from '@nestjs/graphql';
 import { ObjectType } from '@nestjs/graphql';
 import { Int } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 
 @ObjectType()
 export class DummySumAggregate {
-  @Field(() => Int, { nullable: true })
-  int?: number;
 
-  @Field(() => Float, { nullable: true })
-  float?: number;
+    @Field(() => Int, {nullable:true})
+    int?: number;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  decimal?: Decimal;
+    @Field(() => Float, {nullable:true})
+    float?: number;
 
-  @Field(() => [GraphQLDecimal], { nullable: true })
-  decimals?: Array<Decimal>;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    decimal?: Decimal;
 
-  @Field(() => String, { nullable: true })
-  bigInt?: bigint | number;
+    @Field(() => [GraphQLDecimal], {nullable:true})
+    decimals?: Array<Decimal>;
+
+    @Field(() => String, {nullable:true})
+    bigInt?: bigint | number;
 }
diff --git a/@generated/dummy/dummy-sum-order-by-aggregate.input.ts b/@generated/dummy/dummy-sum-order-by-aggregate.input.ts
index e26de4fd..784d6b96 100644
--- a/@generated/dummy/dummy-sum-order-by-aggregate.input.ts
+++ b/@generated/dummy/dummy-sum-order-by-aggregate.input.ts
@@ -4,18 +4,19 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class DummySumOrderByAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  int?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  float?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    int?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  decimal?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    float?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  decimals?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    decimal?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  bigInt?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    decimals?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    bigInt?: keyof typeof SortOrder;
 }
diff --git a/@generated/dummy/dummy-unchecked-create.input.ts b/@generated/dummy/dummy-unchecked-create.input.ts
index 1b53b386..b90f30bd 100644
--- a/@generated/dummy/dummy-unchecked-create.input.ts
+++ b/@generated/dummy/dummy-unchecked-create.input.ts
@@ -2,7 +2,7 @@ import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
 import { Int } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -13,37 +13,38 @@ import { DummyCreatefriendsInput } from './dummy-createfriends.input';
 
 @InputType()
 export class DummyUncheckedCreateInput {
-  @Field(() => String, { nullable: false })
-  id!: string;
 
-  @Field(() => Date, { nullable: true })
-  date?: Date | string;
+    @Field(() => String, {nullable:false})
+    id!: string;
 
-  @Field(() => Int, { nullable: true })
-  int?: number;
+    @Field(() => Date, {nullable:true})
+    date?: Date | string;
 
-  @Field(() => Float, { nullable: true })
-  float?: number;
+    @Field(() => Int, {nullable:true})
+    int?: number;
 
-  @Field(() => String, { nullable: true })
-  bytes?: Buffer;
+    @Field(() => Float, {nullable:true})
+    float?: number;
 
-  @Field(() => GraphQLDecimal, { nullable: false })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  decimal!: Decimal;
+    @Field(() => String, {nullable:true})
+    bytes?: Buffer;
 
-  @Field(() => DummyCreatedecimalsInput, { nullable: true })
-  @Type(() => DummyCreatedecimalsInput)
-  decimals?: DummyCreatedecimalsInput;
+    @Field(() => GraphQLDecimal, {nullable:false})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    decimal!: Decimal;
 
-  @Field(() => String, { nullable: true })
-  bigInt?: bigint | number;
+    @Field(() => DummyCreatedecimalsInput, {nullable:true})
+    @Type(() => DummyCreatedecimalsInput)
+    decimals?: DummyCreatedecimalsInput;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  json?: any;
+    @Field(() => String, {nullable:true})
+    bigInt?: bigint | number;
 
-  @Field(() => DummyCreatefriendsInput, { nullable: true })
-  @Type(() => DummyCreatefriendsInput)
-  friends?: DummyCreatefriendsInput;
+    @Field(() => GraphQLJSON, {nullable:true})
+    json?: any;
+
+    @Field(() => DummyCreatefriendsInput, {nullable:true})
+    @Type(() => DummyCreatefriendsInput)
+    friends?: DummyCreatefriendsInput;
 }
diff --git a/@generated/dummy/dummy-unchecked-update-many.input.ts b/@generated/dummy/dummy-unchecked-update-many.input.ts
index 655b1f05..7fb0c772 100644
--- a/@generated/dummy/dummy-unchecked-update-many.input.ts
+++ b/@generated/dummy/dummy-unchecked-update-many.input.ts
@@ -14,36 +14,37 @@ import { DummyUpdatefriendsInput } from './dummy-updatefriends.input';
 
 @InputType()
 export class DummyUncheckedUpdateManyInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true })
-  date?: NullableDateTimeFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableIntFieldUpdateOperationsInput, { nullable: true })
-  int?: NullableIntFieldUpdateOperationsInput;
+    @Field(() => NullableDateTimeFieldUpdateOperationsInput, {nullable:true})
+    date?: NullableDateTimeFieldUpdateOperationsInput;
 
-  @Field(() => NullableFloatFieldUpdateOperationsInput, { nullable: true })
-  float?: NullableFloatFieldUpdateOperationsInput;
+    @Field(() => NullableIntFieldUpdateOperationsInput, {nullable:true})
+    int?: NullableIntFieldUpdateOperationsInput;
 
-  @Field(() => NullableBytesFieldUpdateOperationsInput, { nullable: true })
-  bytes?: NullableBytesFieldUpdateOperationsInput;
+    @Field(() => NullableFloatFieldUpdateOperationsInput, {nullable:true})
+    float?: NullableFloatFieldUpdateOperationsInput;
 
-  @Field(() => DecimalFieldUpdateOperationsInput, { nullable: true })
-  @Type(() => DecimalFieldUpdateOperationsInput)
-  decimal?: DecimalFieldUpdateOperationsInput;
+    @Field(() => NullableBytesFieldUpdateOperationsInput, {nullable:true})
+    bytes?: NullableBytesFieldUpdateOperationsInput;
 
-  @Field(() => DummyUpdatedecimalsInput, { nullable: true })
-  @Type(() => DummyUpdatedecimalsInput)
-  decimals?: DummyUpdatedecimalsInput;
+    @Field(() => DecimalFieldUpdateOperationsInput, {nullable:true})
+    @Type(() => DecimalFieldUpdateOperationsInput)
+    decimal?: DecimalFieldUpdateOperationsInput;
 
-  @Field(() => NullableBigIntFieldUpdateOperationsInput, { nullable: true })
-  bigInt?: NullableBigIntFieldUpdateOperationsInput;
+    @Field(() => DummyUpdatedecimalsInput, {nullable:true})
+    @Type(() => DummyUpdatedecimalsInput)
+    decimals?: DummyUpdatedecimalsInput;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  json?: any;
+    @Field(() => NullableBigIntFieldUpdateOperationsInput, {nullable:true})
+    bigInt?: NullableBigIntFieldUpdateOperationsInput;
 
-  @Field(() => DummyUpdatefriendsInput, { nullable: true })
-  @Type(() => DummyUpdatefriendsInput)
-  friends?: DummyUpdatefriendsInput;
+    @Field(() => GraphQLJSON, {nullable:true})
+    json?: any;
+
+    @Field(() => DummyUpdatefriendsInput, {nullable:true})
+    @Type(() => DummyUpdatefriendsInput)
+    friends?: DummyUpdatefriendsInput;
 }
diff --git a/@generated/dummy/dummy-unchecked-update.input.ts b/@generated/dummy/dummy-unchecked-update.input.ts
index 6ed7ceed..3b075b56 100644
--- a/@generated/dummy/dummy-unchecked-update.input.ts
+++ b/@generated/dummy/dummy-unchecked-update.input.ts
@@ -14,36 +14,37 @@ import { DummyUpdatefriendsInput } from './dummy-updatefriends.input';
 
 @InputType()
 export class DummyUncheckedUpdateInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true })
-  date?: NullableDateTimeFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableIntFieldUpdateOperationsInput, { nullable: true })
-  int?: NullableIntFieldUpdateOperationsInput;
+    @Field(() => NullableDateTimeFieldUpdateOperationsInput, {nullable:true})
+    date?: NullableDateTimeFieldUpdateOperationsInput;
 
-  @Field(() => NullableFloatFieldUpdateOperationsInput, { nullable: true })
-  float?: NullableFloatFieldUpdateOperationsInput;
+    @Field(() => NullableIntFieldUpdateOperationsInput, {nullable:true})
+    int?: NullableIntFieldUpdateOperationsInput;
 
-  @Field(() => NullableBytesFieldUpdateOperationsInput, { nullable: true })
-  bytes?: NullableBytesFieldUpdateOperationsInput;
+    @Field(() => NullableFloatFieldUpdateOperationsInput, {nullable:true})
+    float?: NullableFloatFieldUpdateOperationsInput;
 
-  @Field(() => DecimalFieldUpdateOperationsInput, { nullable: true })
-  @Type(() => DecimalFieldUpdateOperationsInput)
-  decimal?: DecimalFieldUpdateOperationsInput;
+    @Field(() => NullableBytesFieldUpdateOperationsInput, {nullable:true})
+    bytes?: NullableBytesFieldUpdateOperationsInput;
 
-  @Field(() => DummyUpdatedecimalsInput, { nullable: true })
-  @Type(() => DummyUpdatedecimalsInput)
-  decimals?: DummyUpdatedecimalsInput;
+    @Field(() => DecimalFieldUpdateOperationsInput, {nullable:true})
+    @Type(() => DecimalFieldUpdateOperationsInput)
+    decimal?: DecimalFieldUpdateOperationsInput;
 
-  @Field(() => NullableBigIntFieldUpdateOperationsInput, { nullable: true })
-  bigInt?: NullableBigIntFieldUpdateOperationsInput;
+    @Field(() => DummyUpdatedecimalsInput, {nullable:true})
+    @Type(() => DummyUpdatedecimalsInput)
+    decimals?: DummyUpdatedecimalsInput;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  json?: any;
+    @Field(() => NullableBigIntFieldUpdateOperationsInput, {nullable:true})
+    bigInt?: NullableBigIntFieldUpdateOperationsInput;
 
-  @Field(() => DummyUpdatefriendsInput, { nullable: true })
-  @Type(() => DummyUpdatefriendsInput)
-  friends?: DummyUpdatefriendsInput;
+    @Field(() => GraphQLJSON, {nullable:true})
+    json?: any;
+
+    @Field(() => DummyUpdatefriendsInput, {nullable:true})
+    @Type(() => DummyUpdatefriendsInput)
+    friends?: DummyUpdatefriendsInput;
 }
diff --git a/@generated/dummy/dummy-update-many-mutation.input.ts b/@generated/dummy/dummy-update-many-mutation.input.ts
index 31c7ffa2..6c62e46b 100644
--- a/@generated/dummy/dummy-update-many-mutation.input.ts
+++ b/@generated/dummy/dummy-update-many-mutation.input.ts
@@ -14,36 +14,37 @@ import { DummyUpdatefriendsInput } from './dummy-updatefriends.input';
 
 @InputType()
 export class DummyUpdateManyMutationInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true })
-  date?: NullableDateTimeFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableIntFieldUpdateOperationsInput, { nullable: true })
-  int?: NullableIntFieldUpdateOperationsInput;
+    @Field(() => NullableDateTimeFieldUpdateOperationsInput, {nullable:true})
+    date?: NullableDateTimeFieldUpdateOperationsInput;
 
-  @Field(() => NullableFloatFieldUpdateOperationsInput, { nullable: true })
-  float?: NullableFloatFieldUpdateOperationsInput;
+    @Field(() => NullableIntFieldUpdateOperationsInput, {nullable:true})
+    int?: NullableIntFieldUpdateOperationsInput;
 
-  @Field(() => NullableBytesFieldUpdateOperationsInput, { nullable: true })
-  bytes?: NullableBytesFieldUpdateOperationsInput;
+    @Field(() => NullableFloatFieldUpdateOperationsInput, {nullable:true})
+    float?: NullableFloatFieldUpdateOperationsInput;
 
-  @Field(() => DecimalFieldUpdateOperationsInput, { nullable: true })
-  @Type(() => DecimalFieldUpdateOperationsInput)
-  decimal?: DecimalFieldUpdateOperationsInput;
+    @Field(() => NullableBytesFieldUpdateOperationsInput, {nullable:true})
+    bytes?: NullableBytesFieldUpdateOperationsInput;
 
-  @Field(() => DummyUpdatedecimalsInput, { nullable: true })
-  @Type(() => DummyUpdatedecimalsInput)
-  decimals?: DummyUpdatedecimalsInput;
+    @Field(() => DecimalFieldUpdateOperationsInput, {nullable:true})
+    @Type(() => DecimalFieldUpdateOperationsInput)
+    decimal?: DecimalFieldUpdateOperationsInput;
 
-  @Field(() => NullableBigIntFieldUpdateOperationsInput, { nullable: true })
-  bigInt?: NullableBigIntFieldUpdateOperationsInput;
+    @Field(() => DummyUpdatedecimalsInput, {nullable:true})
+    @Type(() => DummyUpdatedecimalsInput)
+    decimals?: DummyUpdatedecimalsInput;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  json?: any;
+    @Field(() => NullableBigIntFieldUpdateOperationsInput, {nullable:true})
+    bigInt?: NullableBigIntFieldUpdateOperationsInput;
 
-  @Field(() => DummyUpdatefriendsInput, { nullable: true })
-  @Type(() => DummyUpdatefriendsInput)
-  friends?: DummyUpdatefriendsInput;
+    @Field(() => GraphQLJSON, {nullable:true})
+    json?: any;
+
+    @Field(() => DummyUpdatefriendsInput, {nullable:true})
+    @Type(() => DummyUpdatefriendsInput)
+    friends?: DummyUpdatefriendsInput;
 }
diff --git a/@generated/dummy/dummy-update.input.ts b/@generated/dummy/dummy-update.input.ts
index 5302abff..1fc470c3 100644
--- a/@generated/dummy/dummy-update.input.ts
+++ b/@generated/dummy/dummy-update.input.ts
@@ -14,36 +14,37 @@ import { DummyUpdatefriendsInput } from './dummy-updatefriends.input';
 
 @InputType()
 export class DummyUpdateInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true })
-  date?: NullableDateTimeFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableIntFieldUpdateOperationsInput, { nullable: true })
-  int?: NullableIntFieldUpdateOperationsInput;
+    @Field(() => NullableDateTimeFieldUpdateOperationsInput, {nullable:true})
+    date?: NullableDateTimeFieldUpdateOperationsInput;
 
-  @Field(() => NullableFloatFieldUpdateOperationsInput, { nullable: true })
-  float?: NullableFloatFieldUpdateOperationsInput;
+    @Field(() => NullableIntFieldUpdateOperationsInput, {nullable:true})
+    int?: NullableIntFieldUpdateOperationsInput;
 
-  @Field(() => NullableBytesFieldUpdateOperationsInput, { nullable: true })
-  bytes?: NullableBytesFieldUpdateOperationsInput;
+    @Field(() => NullableFloatFieldUpdateOperationsInput, {nullable:true})
+    float?: NullableFloatFieldUpdateOperationsInput;
 
-  @Field(() => DecimalFieldUpdateOperationsInput, { nullable: true })
-  @Type(() => DecimalFieldUpdateOperationsInput)
-  decimal?: DecimalFieldUpdateOperationsInput;
+    @Field(() => NullableBytesFieldUpdateOperationsInput, {nullable:true})
+    bytes?: NullableBytesFieldUpdateOperationsInput;
 
-  @Field(() => DummyUpdatedecimalsInput, { nullable: true })
-  @Type(() => DummyUpdatedecimalsInput)
-  decimals?: DummyUpdatedecimalsInput;
+    @Field(() => DecimalFieldUpdateOperationsInput, {nullable:true})
+    @Type(() => DecimalFieldUpdateOperationsInput)
+    decimal?: DecimalFieldUpdateOperationsInput;
 
-  @Field(() => NullableBigIntFieldUpdateOperationsInput, { nullable: true })
-  bigInt?: NullableBigIntFieldUpdateOperationsInput;
+    @Field(() => DummyUpdatedecimalsInput, {nullable:true})
+    @Type(() => DummyUpdatedecimalsInput)
+    decimals?: DummyUpdatedecimalsInput;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  json?: any;
+    @Field(() => NullableBigIntFieldUpdateOperationsInput, {nullable:true})
+    bigInt?: NullableBigIntFieldUpdateOperationsInput;
 
-  @Field(() => DummyUpdatefriendsInput, { nullable: true })
-  @Type(() => DummyUpdatefriendsInput)
-  friends?: DummyUpdatefriendsInput;
+    @Field(() => GraphQLJSON, {nullable:true})
+    json?: any;
+
+    @Field(() => DummyUpdatefriendsInput, {nullable:true})
+    @Type(() => DummyUpdatefriendsInput)
+    friends?: DummyUpdatefriendsInput;
 }
diff --git a/@generated/dummy/dummy-updatedecimals.input.ts b/@generated/dummy/dummy-updatedecimals.input.ts
index 94b0cf60..cab93618 100644
--- a/@generated/dummy/dummy-updatedecimals.input.ts
+++ b/@generated/dummy/dummy-updatedecimals.input.ts
@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -8,13 +8,14 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class DummyUpdatedecimalsInput {
-  @Field(() => [GraphQLDecimal], { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  set?: Array<Decimal>;
 
-  @Field(() => [GraphQLDecimal], { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  push?: Array<Decimal>;
+    @Field(() => [GraphQLDecimal], {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    set?: Array<Decimal>;
+
+    @Field(() => [GraphQLDecimal], {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    push?: Array<Decimal>;
 }
diff --git a/@generated/dummy/dummy-updatefriends.input.ts b/@generated/dummy/dummy-updatefriends.input.ts
index 9638210e..47a68101 100644
--- a/@generated/dummy/dummy-updatefriends.input.ts
+++ b/@generated/dummy/dummy-updatefriends.input.ts
@@ -3,9 +3,10 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class DummyUpdatefriendsInput {
-  @Field(() => [String], { nullable: true })
-  set?: Array<string>;
 
-  @Field(() => [String], { nullable: true })
-  push?: Array<string>;
+    @Field(() => [String], {nullable:true})
+    set?: Array<string>;
+
+    @Field(() => [String], {nullable:true})
+    push?: Array<string>;
 }
diff --git a/@generated/dummy/dummy-where-unique.input.ts b/@generated/dummy/dummy-where-unique.input.ts
index c1933691..211c2d44 100644
--- a/@generated/dummy/dummy-where-unique.input.ts
+++ b/@generated/dummy/dummy-where-unique.input.ts
@@ -14,47 +14,48 @@ import { StringNullableListFilter } from '../prisma/string-nullable-list-filter.
 
 @InputType()
 export class DummyWhereUniqueInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => [DummyWhereInput], { nullable: true })
-  @Type(() => DummyWhereInput)
-  AND?: Array<DummyWhereInput>;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => [DummyWhereInput], { nullable: true })
-  @Type(() => DummyWhereInput)
-  OR?: Array<DummyWhereInput>;
+    @Field(() => [DummyWhereInput], {nullable:true})
+    @Type(() => DummyWhereInput)
+    AND?: Array<DummyWhereInput>;
 
-  @Field(() => [DummyWhereInput], { nullable: true })
-  @Type(() => DummyWhereInput)
-  NOT?: Array<DummyWhereInput>;
+    @Field(() => [DummyWhereInput], {nullable:true})
+    @Type(() => DummyWhereInput)
+    OR?: Array<DummyWhereInput>;
 
-  @Field(() => DateTimeNullableFilter, { nullable: true })
-  date?: DateTimeNullableFilter;
+    @Field(() => [DummyWhereInput], {nullable:true})
+    @Type(() => DummyWhereInput)
+    NOT?: Array<DummyWhereInput>;
 
-  @Field(() => IntNullableFilter, { nullable: true })
-  int?: IntNullableFilter;
+    @Field(() => DateTimeNullableFilter, {nullable:true})
+    date?: DateTimeNullableFilter;
 
-  @Field(() => FloatNullableFilter, { nullable: true })
-  float?: FloatNullableFilter;
+    @Field(() => IntNullableFilter, {nullable:true})
+    int?: IntNullableFilter;
 
-  @Field(() => BytesNullableFilter, { nullable: true })
-  bytes?: BytesNullableFilter;
+    @Field(() => FloatNullableFilter, {nullable:true})
+    float?: FloatNullableFilter;
 
-  @Field(() => DecimalFilter, { nullable: true })
-  @Type(() => DecimalFilter)
-  decimal?: DecimalFilter;
+    @Field(() => BytesNullableFilter, {nullable:true})
+    bytes?: BytesNullableFilter;
 
-  @Field(() => DecimalNullableListFilter, { nullable: true })
-  @Type(() => DecimalNullableListFilter)
-  decimals?: DecimalNullableListFilter;
+    @Field(() => DecimalFilter, {nullable:true})
+    @Type(() => DecimalFilter)
+    decimal?: DecimalFilter;
 
-  @Field(() => BigIntNullableFilter, { nullable: true })
-  bigInt?: BigIntNullableFilter;
+    @Field(() => DecimalNullableListFilter, {nullable:true})
+    @Type(() => DecimalNullableListFilter)
+    decimals?: DecimalNullableListFilter;
 
-  @Field(() => JsonNullableFilter, { nullable: true })
-  json?: JsonNullableFilter;
+    @Field(() => BigIntNullableFilter, {nullable:true})
+    bigInt?: BigIntNullableFilter;
 
-  @Field(() => StringNullableListFilter, { nullable: true })
-  friends?: StringNullableListFilter;
+    @Field(() => JsonNullableFilter, {nullable:true})
+    json?: JsonNullableFilter;
+
+    @Field(() => StringNullableListFilter, {nullable:true})
+    friends?: StringNullableListFilter;
 }
diff --git a/@generated/dummy/dummy-where.input.ts b/@generated/dummy/dummy-where.input.ts
index a9d5dc51..a6d4ad1a 100644
--- a/@generated/dummy/dummy-where.input.ts
+++ b/@generated/dummy/dummy-where.input.ts
@@ -14,47 +14,48 @@ import { StringNullableListFilter } from '../prisma/string-nullable-list-filter.
 
 @InputType()
 export class DummyWhereInput {
-  @Field(() => [DummyWhereInput], { nullable: true })
-  @Type(() => DummyWhereInput)
-  AND?: Array<DummyWhereInput>;
 
-  @Field(() => [DummyWhereInput], { nullable: true })
-  @Type(() => DummyWhereInput)
-  OR?: Array<DummyWhereInput>;
+    @Field(() => [DummyWhereInput], {nullable:true})
+    @Type(() => DummyWhereInput)
+    AND?: Array<DummyWhereInput>;
 
-  @Field(() => [DummyWhereInput], { nullable: true })
-  @Type(() => DummyWhereInput)
-  NOT?: Array<DummyWhereInput>;
+    @Field(() => [DummyWhereInput], {nullable:true})
+    @Type(() => DummyWhereInput)
+    OR?: Array<DummyWhereInput>;
 
-  @Field(() => StringFilter, { nullable: true })
-  id?: StringFilter;
+    @Field(() => [DummyWhereInput], {nullable:true})
+    @Type(() => DummyWhereInput)
+    NOT?: Array<DummyWhereInput>;
 
-  @Field(() => DateTimeNullableFilter, { nullable: true })
-  date?: DateTimeNullableFilter;
+    @Field(() => StringFilter, {nullable:true})
+    id?: StringFilter;
 
-  @Field(() => IntNullableFilter, { nullable: true })
-  int?: IntNullableFilter;
+    @Field(() => DateTimeNullableFilter, {nullable:true})
+    date?: DateTimeNullableFilter;
 
-  @Field(() => FloatNullableFilter, { nullable: true })
-  float?: FloatNullableFilter;
+    @Field(() => IntNullableFilter, {nullable:true})
+    int?: IntNullableFilter;
 
-  @Field(() => BytesNullableFilter, { nullable: true })
-  bytes?: BytesNullableFilter;
+    @Field(() => FloatNullableFilter, {nullable:true})
+    float?: FloatNullableFilter;
 
-  @Field(() => DecimalFilter, { nullable: true })
-  @Type(() => DecimalFilter)
-  decimal?: DecimalFilter;
+    @Field(() => BytesNullableFilter, {nullable:true})
+    bytes?: BytesNullableFilter;
 
-  @Field(() => DecimalNullableListFilter, { nullable: true })
-  @Type(() => DecimalNullableListFilter)
-  decimals?: DecimalNullableListFilter;
+    @Field(() => DecimalFilter, {nullable:true})
+    @Type(() => DecimalFilter)
+    decimal?: DecimalFilter;
 
-  @Field(() => BigIntNullableFilter, { nullable: true })
-  bigInt?: BigIntNullableFilter;
+    @Field(() => DecimalNullableListFilter, {nullable:true})
+    @Type(() => DecimalNullableListFilter)
+    decimals?: DecimalNullableListFilter;
 
-  @Field(() => JsonNullableFilter, { nullable: true })
-  json?: JsonNullableFilter;
+    @Field(() => BigIntNullableFilter, {nullable:true})
+    bigInt?: BigIntNullableFilter;
 
-  @Field(() => StringNullableListFilter, { nullable: true })
-  friends?: StringNullableListFilter;
+    @Field(() => JsonNullableFilter, {nullable:true})
+    json?: JsonNullableFilter;
+
+    @Field(() => StringNullableListFilter, {nullable:true})
+    friends?: StringNullableListFilter;
 }
diff --git a/@generated/dummy/dummy.model.ts b/@generated/dummy/dummy.model.ts
index 98d5db77..3e1912ca 100644
--- a/@generated/dummy/dummy.model.ts
+++ b/@generated/dummy/dummy.model.ts
@@ -4,38 +4,39 @@ import { ID } from '@nestjs/graphql';
 import { Int } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLJSON } from 'graphql-type-json';
 
 @ObjectType()
 export class Dummy {
-  @Field(() => ID, { nullable: false })
-  id!: string;
 
-  @Field(() => Date, { nullable: true })
-  date!: Date | null;
+    @Field(() => ID, {nullable:false})
+    id!: string;
 
-  @Field(() => Int, { nullable: true })
-  int!: number | null;
+    @Field(() => Date, {nullable:true})
+    date!: Date | null;
 
-  @Field(() => Float, { nullable: true })
-  float!: number | null;
+    @Field(() => Int, {nullable:true})
+    int!: number | null;
 
-  @Field(() => String, { nullable: true })
-  bytes!: Buffer | null;
+    @Field(() => Float, {nullable:true})
+    float!: number | null;
 
-  @Field(() => GraphQLDecimal, { nullable: false })
-  decimal!: Decimal;
+    @Field(() => String, {nullable:true})
+    bytes!: Buffer | null;
 
-  @Field(() => [GraphQLDecimal], { nullable: true })
-  decimals!: Array<Decimal>;
+    @Field(() => GraphQLDecimal, {nullable:false})
+    decimal!: Decimal;
 
-  @Field(() => String, { nullable: true })
-  bigInt!: bigint | null;
+    @Field(() => [GraphQLDecimal], {nullable:true})
+    decimals!: Array<Decimal>;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  json!: any | null;
+    @Field(() => String, {nullable:true})
+    bigInt!: bigint | null;
 
-  @Field(() => [String], { nullable: true })
-  friends!: Array<string>;
+    @Field(() => GraphQLJSON, {nullable:true})
+    json!: any | null;
+
+    @Field(() => [String], {nullable:true})
+    friends!: Array<string>;
 }
diff --git a/@generated/dummy/find-first-dummy-or-throw.args.ts b/@generated/dummy/find-first-dummy-or-throw.args.ts
index d544c468..8bf78bbc 100644
--- a/@generated/dummy/find-first-dummy-or-throw.args.ts
+++ b/@generated/dummy/find-first-dummy-or-throw.args.ts
@@ -3,31 +3,32 @@ import { ArgsType } from '@nestjs/graphql';
 import { DummyWhereInput } from './dummy-where.input';
 import { Type } from 'class-transformer';
 import { DummyOrderByWithRelationAndSearchRelevanceInput } from './dummy-order-by-with-relation-and-search-relevance.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { DummyWhereUniqueInput } from './dummy-where-unique.input';
 import { Int } from '@nestjs/graphql';
 import { DummyScalarFieldEnum } from './dummy-scalar-field.enum';
 
 @ArgsType()
 export class FindFirstDummyOrThrowArgs {
-  @Field(() => DummyWhereInput, { nullable: true })
-  @Type(() => DummyWhereInput)
-  where?: DummyWhereInput;
 
-  @Field(() => [DummyOrderByWithRelationAndSearchRelevanceInput], { nullable: true })
-  @Type(() => DummyOrderByWithRelationAndSearchRelevanceInput)
-  orderBy?: Array<DummyOrderByWithRelationAndSearchRelevanceInput>;
+    @Field(() => DummyWhereInput, {nullable:true})
+    @Type(() => DummyWhereInput)
+    where?: DummyWhereInput;
 
-  @Field(() => DummyWhereUniqueInput, { nullable: true })
-  @Type(() => DummyWhereUniqueInput)
-  cursor?: Prisma.AtLeast<DummyWhereUniqueInput, 'id'>;
+    @Field(() => [DummyOrderByWithRelationAndSearchRelevanceInput], {nullable:true})
+    @Type(() => DummyOrderByWithRelationAndSearchRelevanceInput)
+    orderBy?: Array<DummyOrderByWithRelationAndSearchRelevanceInput>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => DummyWhereUniqueInput, {nullable:true})
+    @Type(() => DummyWhereUniqueInput)
+    cursor?: Prisma.AtLeast<DummyWhereUniqueInput, 'id'>;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => [DummyScalarFieldEnum], { nullable: true })
-  distinct?: Array<keyof typeof DummyScalarFieldEnum>;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
+
+    @Field(() => [DummyScalarFieldEnum], {nullable:true})
+    distinct?: Array<keyof typeof DummyScalarFieldEnum>;
 }
diff --git a/@generated/dummy/find-first-dummy.args.ts b/@generated/dummy/find-first-dummy.args.ts
index 9065bcd5..58c1191a 100644
--- a/@generated/dummy/find-first-dummy.args.ts
+++ b/@generated/dummy/find-first-dummy.args.ts
@@ -3,31 +3,32 @@ import { ArgsType } from '@nestjs/graphql';
 import { DummyWhereInput } from './dummy-where.input';
 import { Type } from 'class-transformer';
 import { DummyOrderByWithRelationAndSearchRelevanceInput } from './dummy-order-by-with-relation-and-search-relevance.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { DummyWhereUniqueInput } from './dummy-where-unique.input';
 import { Int } from '@nestjs/graphql';
 import { DummyScalarFieldEnum } from './dummy-scalar-field.enum';
 
 @ArgsType()
 export class FindFirstDummyArgs {
-  @Field(() => DummyWhereInput, { nullable: true })
-  @Type(() => DummyWhereInput)
-  where?: DummyWhereInput;
 
-  @Field(() => [DummyOrderByWithRelationAndSearchRelevanceInput], { nullable: true })
-  @Type(() => DummyOrderByWithRelationAndSearchRelevanceInput)
-  orderBy?: Array<DummyOrderByWithRelationAndSearchRelevanceInput>;
+    @Field(() => DummyWhereInput, {nullable:true})
+    @Type(() => DummyWhereInput)
+    where?: DummyWhereInput;
 
-  @Field(() => DummyWhereUniqueInput, { nullable: true })
-  @Type(() => DummyWhereUniqueInput)
-  cursor?: Prisma.AtLeast<DummyWhereUniqueInput, 'id'>;
+    @Field(() => [DummyOrderByWithRelationAndSearchRelevanceInput], {nullable:true})
+    @Type(() => DummyOrderByWithRelationAndSearchRelevanceInput)
+    orderBy?: Array<DummyOrderByWithRelationAndSearchRelevanceInput>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => DummyWhereUniqueInput, {nullable:true})
+    @Type(() => DummyWhereUniqueInput)
+    cursor?: Prisma.AtLeast<DummyWhereUniqueInput, 'id'>;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => [DummyScalarFieldEnum], { nullable: true })
-  distinct?: Array<keyof typeof DummyScalarFieldEnum>;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
+
+    @Field(() => [DummyScalarFieldEnum], {nullable:true})
+    distinct?: Array<keyof typeof DummyScalarFieldEnum>;
 }
diff --git a/@generated/dummy/find-many-dummy.args.ts b/@generated/dummy/find-many-dummy.args.ts
index 801bc022..f2c640e5 100644
--- a/@generated/dummy/find-many-dummy.args.ts
+++ b/@generated/dummy/find-many-dummy.args.ts
@@ -3,31 +3,32 @@ import { ArgsType } from '@nestjs/graphql';
 import { DummyWhereInput } from './dummy-where.input';
 import { Type } from 'class-transformer';
 import { DummyOrderByWithRelationAndSearchRelevanceInput } from './dummy-order-by-with-relation-and-search-relevance.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { DummyWhereUniqueInput } from './dummy-where-unique.input';
 import { Int } from '@nestjs/graphql';
 import { DummyScalarFieldEnum } from './dummy-scalar-field.enum';
 
 @ArgsType()
 export class FindManyDummyArgs {
-  @Field(() => DummyWhereInput, { nullable: true })
-  @Type(() => DummyWhereInput)
-  where?: DummyWhereInput;
 
-  @Field(() => [DummyOrderByWithRelationAndSearchRelevanceInput], { nullable: true })
-  @Type(() => DummyOrderByWithRelationAndSearchRelevanceInput)
-  orderBy?: Array<DummyOrderByWithRelationAndSearchRelevanceInput>;
+    @Field(() => DummyWhereInput, {nullable:true})
+    @Type(() => DummyWhereInput)
+    where?: DummyWhereInput;
 
-  @Field(() => DummyWhereUniqueInput, { nullable: true })
-  @Type(() => DummyWhereUniqueInput)
-  cursor?: Prisma.AtLeast<DummyWhereUniqueInput, 'id'>;
+    @Field(() => [DummyOrderByWithRelationAndSearchRelevanceInput], {nullable:true})
+    @Type(() => DummyOrderByWithRelationAndSearchRelevanceInput)
+    orderBy?: Array<DummyOrderByWithRelationAndSearchRelevanceInput>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => DummyWhereUniqueInput, {nullable:true})
+    @Type(() => DummyWhereUniqueInput)
+    cursor?: Prisma.AtLeast<DummyWhereUniqueInput, 'id'>;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => [DummyScalarFieldEnum], { nullable: true })
-  distinct?: Array<keyof typeof DummyScalarFieldEnum>;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
+
+    @Field(() => [DummyScalarFieldEnum], {nullable:true})
+    distinct?: Array<keyof typeof DummyScalarFieldEnum>;
 }
diff --git a/@generated/dummy/find-unique-dummy-or-throw.args.ts b/@generated/dummy/find-unique-dummy-or-throw.args.ts
index 49e0aa4c..72e9d5c4 100644
--- a/@generated/dummy/find-unique-dummy-or-throw.args.ts
+++ b/@generated/dummy/find-unique-dummy-or-throw.args.ts
@@ -1,12 +1,13 @@
 import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { DummyWhereUniqueInput } from './dummy-where-unique.input';
 import { Type } from 'class-transformer';
 
 @ArgsType()
 export class FindUniqueDummyOrThrowArgs {
-  @Field(() => DummyWhereUniqueInput, { nullable: false })
-  @Type(() => DummyWhereUniqueInput)
-  where!: Prisma.AtLeast<DummyWhereUniqueInput, 'id'>;
+
+    @Field(() => DummyWhereUniqueInput, {nullable:false})
+    @Type(() => DummyWhereUniqueInput)
+    where!: Prisma.AtLeast<DummyWhereUniqueInput, 'id'>;
 }
diff --git a/@generated/dummy/find-unique-dummy.args.ts b/@generated/dummy/find-unique-dummy.args.ts
index 9ada9c1e..2c1870a9 100644
--- a/@generated/dummy/find-unique-dummy.args.ts
+++ b/@generated/dummy/find-unique-dummy.args.ts
@@ -1,12 +1,13 @@
 import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { DummyWhereUniqueInput } from './dummy-where-unique.input';
 import { Type } from 'class-transformer';
 
 @ArgsType()
 export class FindUniqueDummyArgs {
-  @Field(() => DummyWhereUniqueInput, { nullable: false })
-  @Type(() => DummyWhereUniqueInput)
-  where!: Prisma.AtLeast<DummyWhereUniqueInput, 'id'>;
+
+    @Field(() => DummyWhereUniqueInput, {nullable:false})
+    @Type(() => DummyWhereUniqueInput)
+    where!: Prisma.AtLeast<DummyWhereUniqueInput, 'id'>;
 }
diff --git a/@generated/dummy/update-many-dummy.args.ts b/@generated/dummy/update-many-dummy.args.ts
index 05f7acc4..7807648b 100644
--- a/@generated/dummy/update-many-dummy.args.ts
+++ b/@generated/dummy/update-many-dummy.args.ts
@@ -6,11 +6,12 @@ import { DummyWhereInput } from './dummy-where.input';
 
 @ArgsType()
 export class UpdateManyDummyArgs {
-  @Field(() => DummyUpdateManyMutationInput, { nullable: false })
-  @Type(() => DummyUpdateManyMutationInput)
-  data!: DummyUpdateManyMutationInput;
 
-  @Field(() => DummyWhereInput, { nullable: true })
-  @Type(() => DummyWhereInput)
-  where?: DummyWhereInput;
+    @Field(() => DummyUpdateManyMutationInput, {nullable:false})
+    @Type(() => DummyUpdateManyMutationInput)
+    data!: DummyUpdateManyMutationInput;
+
+    @Field(() => DummyWhereInput, {nullable:true})
+    @Type(() => DummyWhereInput)
+    where?: DummyWhereInput;
 }
diff --git a/@generated/dummy/update-one-dummy.args.ts b/@generated/dummy/update-one-dummy.args.ts
index 2ad690bf..0f18d1f0 100644
--- a/@generated/dummy/update-one-dummy.args.ts
+++ b/@generated/dummy/update-one-dummy.args.ts
@@ -2,16 +2,17 @@ import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
 import { DummyUpdateInput } from './dummy-update.input';
 import { Type } from 'class-transformer';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { DummyWhereUniqueInput } from './dummy-where-unique.input';
 
 @ArgsType()
 export class UpdateOneDummyArgs {
-  @Field(() => DummyUpdateInput, { nullable: false })
-  @Type(() => DummyUpdateInput)
-  data!: DummyUpdateInput;
 
-  @Field(() => DummyWhereUniqueInput, { nullable: false })
-  @Type(() => DummyWhereUniqueInput)
-  where!: Prisma.AtLeast<DummyWhereUniqueInput, 'id'>;
+    @Field(() => DummyUpdateInput, {nullable:false})
+    @Type(() => DummyUpdateInput)
+    data!: DummyUpdateInput;
+
+    @Field(() => DummyWhereUniqueInput, {nullable:false})
+    @Type(() => DummyWhereUniqueInput)
+    where!: Prisma.AtLeast<DummyWhereUniqueInput, 'id'>;
 }
diff --git a/@generated/dummy/upsert-one-dummy.args.ts b/@generated/dummy/upsert-one-dummy.args.ts
index 78c1c3c1..6423d438 100644
--- a/@generated/dummy/upsert-one-dummy.args.ts
+++ b/@generated/dummy/upsert-one-dummy.args.ts
@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { DummyWhereUniqueInput } from './dummy-where-unique.input';
 import { Type } from 'class-transformer';
 import { DummyCreateInput } from './dummy-create.input';
@@ -8,15 +8,16 @@ import { DummyUpdateInput } from './dummy-update.input';
 
 @ArgsType()
 export class UpsertOneDummyArgs {
-  @Field(() => DummyWhereUniqueInput, { nullable: false })
-  @Type(() => DummyWhereUniqueInput)
-  where!: Prisma.AtLeast<DummyWhereUniqueInput, 'id'>;
 
-  @Field(() => DummyCreateInput, { nullable: false })
-  @Type(() => DummyCreateInput)
-  create!: DummyCreateInput;
+    @Field(() => DummyWhereUniqueInput, {nullable:false})
+    @Type(() => DummyWhereUniqueInput)
+    where!: Prisma.AtLeast<DummyWhereUniqueInput, 'id'>;
 
-  @Field(() => DummyUpdateInput, { nullable: false })
-  @Type(() => DummyUpdateInput)
-  update!: DummyUpdateInput;
+    @Field(() => DummyCreateInput, {nullable:false})
+    @Type(() => DummyCreateInput)
+    create!: DummyCreateInput;
+
+    @Field(() => DummyUpdateInput, {nullable:false})
+    @Type(() => DummyUpdateInput)
+    update!: DummyUpdateInput;
 }
diff --git a/@generated/prisma/affected-rows.output.ts b/@generated/prisma/affected-rows.output.ts
index b43eddcc..05e4950d 100644
--- a/@generated/prisma/affected-rows.output.ts
+++ b/@generated/prisma/affected-rows.output.ts
@@ -4,6 +4,7 @@ import { Int } from '@nestjs/graphql';
 
 @ObjectType()
 export class AffectedRows {
-  @Field(() => Int, { nullable: false })
-  count!: number;
+
+    @Field(() => Int, {nullable:false})
+    count!: number;
 }
diff --git a/@generated/prisma/big-int-nullable-filter.input.ts b/@generated/prisma/big-int-nullable-filter.input.ts
index 5d289c52..ba72745f 100644
--- a/@generated/prisma/big-int-nullable-filter.input.ts
+++ b/@generated/prisma/big-int-nullable-filter.input.ts
@@ -4,27 +4,28 @@ import { NestedBigIntNullableFilter } from './nested-big-int-nullable-filter.inp
 
 @InputType()
 export class BigIntNullableFilter {
-  @Field(() => String, { nullable: true })
-  equals?: bigint | number;
 
-  @Field(() => [String], { nullable: true })
-  in?: Array<bigint> | Array<number>;
+    @Field(() => String, {nullable:true})
+    equals?: bigint | number;
 
-  @Field(() => [String], { nullable: true })
-  notIn?: Array<bigint> | Array<number>;
+    @Field(() => [String], {nullable:true})
+    in?: Array<bigint> | Array<number>;
 
-  @Field(() => String, { nullable: true })
-  lt?: bigint | number;
+    @Field(() => [String], {nullable:true})
+    notIn?: Array<bigint> | Array<number>;
 
-  @Field(() => String, { nullable: true })
-  lte?: bigint | number;
+    @Field(() => String, {nullable:true})
+    lt?: bigint | number;
 
-  @Field(() => String, { nullable: true })
-  gt?: bigint | number;
+    @Field(() => String, {nullable:true})
+    lte?: bigint | number;
 
-  @Field(() => String, { nullable: true })
-  gte?: bigint | number;
+    @Field(() => String, {nullable:true})
+    gt?: bigint | number;
 
-  @Field(() => NestedBigIntNullableFilter, { nullable: true })
-  not?: NestedBigIntNullableFilter;
+    @Field(() => String, {nullable:true})
+    gte?: bigint | number;
+
+    @Field(() => NestedBigIntNullableFilter, {nullable:true})
+    not?: NestedBigIntNullableFilter;
 }
diff --git a/@generated/prisma/big-int-nullable-with-aggregates-filter.input.ts b/@generated/prisma/big-int-nullable-with-aggregates-filter.input.ts
index 0fd6a394..468c6bad 100644
--- a/@generated/prisma/big-int-nullable-with-aggregates-filter.input.ts
+++ b/@generated/prisma/big-int-nullable-with-aggregates-filter.input.ts
@@ -7,42 +7,43 @@ import { NestedBigIntNullableFilter } from './nested-big-int-nullable-filter.inp
 
 @InputType()
 export class BigIntNullableWithAggregatesFilter {
-  @Field(() => String, { nullable: true })
-  equals?: bigint | number;
 
-  @Field(() => [String], { nullable: true })
-  in?: Array<bigint> | Array<number>;
+    @Field(() => String, {nullable:true})
+    equals?: bigint | number;
 
-  @Field(() => [String], { nullable: true })
-  notIn?: Array<bigint> | Array<number>;
+    @Field(() => [String], {nullable:true})
+    in?: Array<bigint> | Array<number>;
 
-  @Field(() => String, { nullable: true })
-  lt?: bigint | number;
+    @Field(() => [String], {nullable:true})
+    notIn?: Array<bigint> | Array<number>;
 
-  @Field(() => String, { nullable: true })
-  lte?: bigint | number;
+    @Field(() => String, {nullable:true})
+    lt?: bigint | number;
 
-  @Field(() => String, { nullable: true })
-  gt?: bigint | number;
+    @Field(() => String, {nullable:true})
+    lte?: bigint | number;
 
-  @Field(() => String, { nullable: true })
-  gte?: bigint | number;
+    @Field(() => String, {nullable:true})
+    gt?: bigint | number;
 
-  @Field(() => NestedBigIntNullableWithAggregatesFilter, { nullable: true })
-  not?: NestedBigIntNullableWithAggregatesFilter;
+    @Field(() => String, {nullable:true})
+    gte?: bigint | number;
 
-  @Field(() => NestedIntNullableFilter, { nullable: true })
-  _count?: NestedIntNullableFilter;
+    @Field(() => NestedBigIntNullableWithAggregatesFilter, {nullable:true})
+    not?: NestedBigIntNullableWithAggregatesFilter;
 
-  @Field(() => NestedFloatNullableFilter, { nullable: true })
-  _avg?: NestedFloatNullableFilter;
+    @Field(() => NestedIntNullableFilter, {nullable:true})
+    _count?: NestedIntNullableFilter;
 
-  @Field(() => NestedBigIntNullableFilter, { nullable: true })
-  _sum?: NestedBigIntNullableFilter;
+    @Field(() => NestedFloatNullableFilter, {nullable:true})
+    _avg?: NestedFloatNullableFilter;
 
-  @Field(() => NestedBigIntNullableFilter, { nullable: true })
-  _min?: NestedBigIntNullableFilter;
+    @Field(() => NestedBigIntNullableFilter, {nullable:true})
+    _sum?: NestedBigIntNullableFilter;
 
-  @Field(() => NestedBigIntNullableFilter, { nullable: true })
-  _max?: NestedBigIntNullableFilter;
+    @Field(() => NestedBigIntNullableFilter, {nullable:true})
+    _min?: NestedBigIntNullableFilter;
+
+    @Field(() => NestedBigIntNullableFilter, {nullable:true})
+    _max?: NestedBigIntNullableFilter;
 }
diff --git a/@generated/prisma/bool-nullable-filter.input.ts b/@generated/prisma/bool-nullable-filter.input.ts
index 9cfaa1ce..3a6f82bd 100644
--- a/@generated/prisma/bool-nullable-filter.input.ts
+++ b/@generated/prisma/bool-nullable-filter.input.ts
@@ -4,9 +4,10 @@ import { NestedBoolNullableFilter } from './nested-bool-nullable-filter.input';
 
 @InputType()
 export class BoolNullableFilter {
-  @Field(() => Boolean, { nullable: true })
-  equals?: boolean;
 
-  @Field(() => NestedBoolNullableFilter, { nullable: true })
-  not?: NestedBoolNullableFilter;
+    @Field(() => Boolean, {nullable:true})
+    equals?: boolean;
+
+    @Field(() => NestedBoolNullableFilter, {nullable:true})
+    not?: NestedBoolNullableFilter;
 }
diff --git a/@generated/prisma/bool-nullable-with-aggregates-filter.input.ts b/@generated/prisma/bool-nullable-with-aggregates-filter.input.ts
index 52864619..d9ffa370 100644
--- a/@generated/prisma/bool-nullable-with-aggregates-filter.input.ts
+++ b/@generated/prisma/bool-nullable-with-aggregates-filter.input.ts
@@ -6,18 +6,19 @@ import { NestedBoolNullableFilter } from './nested-bool-nullable-filter.input';
 
 @InputType()
 export class BoolNullableWithAggregatesFilter {
-  @Field(() => Boolean, { nullable: true })
-  equals?: boolean;
 
-  @Field(() => NestedBoolNullableWithAggregatesFilter, { nullable: true })
-  not?: NestedBoolNullableWithAggregatesFilter;
+    @Field(() => Boolean, {nullable:true})
+    equals?: boolean;
 
-  @Field(() => NestedIntNullableFilter, { nullable: true })
-  _count?: NestedIntNullableFilter;
+    @Field(() => NestedBoolNullableWithAggregatesFilter, {nullable:true})
+    not?: NestedBoolNullableWithAggregatesFilter;
 
-  @Field(() => NestedBoolNullableFilter, { nullable: true })
-  _min?: NestedBoolNullableFilter;
+    @Field(() => NestedIntNullableFilter, {nullable:true})
+    _count?: NestedIntNullableFilter;
 
-  @Field(() => NestedBoolNullableFilter, { nullable: true })
-  _max?: NestedBoolNullableFilter;
+    @Field(() => NestedBoolNullableFilter, {nullable:true})
+    _min?: NestedBoolNullableFilter;
+
+    @Field(() => NestedBoolNullableFilter, {nullable:true})
+    _max?: NestedBoolNullableFilter;
 }
diff --git a/@generated/prisma/bytes-nullable-filter.input.ts b/@generated/prisma/bytes-nullable-filter.input.ts
index cbc2acde..afa87639 100644
--- a/@generated/prisma/bytes-nullable-filter.input.ts
+++ b/@generated/prisma/bytes-nullable-filter.input.ts
@@ -4,15 +4,16 @@ import { NestedBytesNullableFilter } from './nested-bytes-nullable-filter.input'
 
 @InputType()
 export class BytesNullableFilter {
-  @Field(() => String, { nullable: true })
-  equals?: Buffer;
 
-  @Field(() => [String], { nullable: true })
-  in?: Array<Buffer>;
+    @Field(() => String, {nullable:true})
+    equals?: Buffer;
 
-  @Field(() => [String], { nullable: true })
-  notIn?: Array<Buffer>;
+    @Field(() => [String], {nullable:true})
+    in?: Array<Buffer>;
 
-  @Field(() => NestedBytesNullableFilter, { nullable: true })
-  not?: NestedBytesNullableFilter;
+    @Field(() => [String], {nullable:true})
+    notIn?: Array<Buffer>;
+
+    @Field(() => NestedBytesNullableFilter, {nullable:true})
+    not?: NestedBytesNullableFilter;
 }
diff --git a/@generated/prisma/bytes-nullable-with-aggregates-filter.input.ts b/@generated/prisma/bytes-nullable-with-aggregates-filter.input.ts
index a953d1a5..e470099d 100644
--- a/@generated/prisma/bytes-nullable-with-aggregates-filter.input.ts
+++ b/@generated/prisma/bytes-nullable-with-aggregates-filter.input.ts
@@ -6,24 +6,25 @@ import { NestedBytesNullableFilter } from './nested-bytes-nullable-filter.input'
 
 @InputType()
 export class BytesNullableWithAggregatesFilter {
-  @Field(() => String, { nullable: true })
-  equals?: Buffer;
 
-  @Field(() => [String], { nullable: true })
-  in?: Array<Buffer>;
+    @Field(() => String, {nullable:true})
+    equals?: Buffer;
 
-  @Field(() => [String], { nullable: true })
-  notIn?: Array<Buffer>;
+    @Field(() => [String], {nullable:true})
+    in?: Array<Buffer>;
 
-  @Field(() => NestedBytesNullableWithAggregatesFilter, { nullable: true })
-  not?: NestedBytesNullableWithAggregatesFilter;
+    @Field(() => [String], {nullable:true})
+    notIn?: Array<Buffer>;
 
-  @Field(() => NestedIntNullableFilter, { nullable: true })
-  _count?: NestedIntNullableFilter;
+    @Field(() => NestedBytesNullableWithAggregatesFilter, {nullable:true})
+    not?: NestedBytesNullableWithAggregatesFilter;
 
-  @Field(() => NestedBytesNullableFilter, { nullable: true })
-  _min?: NestedBytesNullableFilter;
+    @Field(() => NestedIntNullableFilter, {nullable:true})
+    _count?: NestedIntNullableFilter;
 
-  @Field(() => NestedBytesNullableFilter, { nullable: true })
-  _max?: NestedBytesNullableFilter;
+    @Field(() => NestedBytesNullableFilter, {nullable:true})
+    _min?: NestedBytesNullableFilter;
+
+    @Field(() => NestedBytesNullableFilter, {nullable:true})
+    _max?: NestedBytesNullableFilter;
 }
diff --git a/@generated/prisma/date-time-field-update-operations.input.ts b/@generated/prisma/date-time-field-update-operations.input.ts
index 98976cb5..d53a5ddf 100644
--- a/@generated/prisma/date-time-field-update-operations.input.ts
+++ b/@generated/prisma/date-time-field-update-operations.input.ts
@@ -3,6 +3,7 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class DateTimeFieldUpdateOperationsInput {
-  @Field(() => Date, { nullable: true })
-  set?: Date | string;
+
+    @Field(() => Date, {nullable:true})
+    set?: Date | string;
 }
diff --git a/@generated/prisma/date-time-filter.input.ts b/@generated/prisma/date-time-filter.input.ts
index c93b003c..6bccf55d 100644
--- a/@generated/prisma/date-time-filter.input.ts
+++ b/@generated/prisma/date-time-filter.input.ts
@@ -4,27 +4,28 @@ import { NestedDateTimeFilter } from './nested-date-time-filter.input';
 
 @InputType()
 export class DateTimeFilter {
-  @Field(() => Date, { nullable: true })
-  equals?: Date | string;
 
-  @Field(() => [Date], { nullable: true })
-  in?: Array<Date> | Array<string>;
+    @Field(() => Date, {nullable:true})
+    equals?: Date | string;
 
-  @Field(() => [Date], { nullable: true })
-  notIn?: Array<Date> | Array<string>;
+    @Field(() => [Date], {nullable:true})
+    in?: Array<Date> | Array<string>;
 
-  @Field(() => Date, { nullable: true })
-  lt?: Date | string;
+    @Field(() => [Date], {nullable:true})
+    notIn?: Array<Date> | Array<string>;
 
-  @Field(() => Date, { nullable: true })
-  lte?: Date | string;
+    @Field(() => Date, {nullable:true})
+    lt?: Date | string;
 
-  @Field(() => Date, { nullable: true })
-  gt?: Date | string;
+    @Field(() => Date, {nullable:true})
+    lte?: Date | string;
 
-  @Field(() => Date, { nullable: true })
-  gte?: Date | string;
+    @Field(() => Date, {nullable:true})
+    gt?: Date | string;
 
-  @Field(() => NestedDateTimeFilter, { nullable: true })
-  not?: NestedDateTimeFilter;
+    @Field(() => Date, {nullable:true})
+    gte?: Date | string;
+
+    @Field(() => NestedDateTimeFilter, {nullable:true})
+    not?: NestedDateTimeFilter;
 }
diff --git a/@generated/prisma/date-time-nullable-filter.input.ts b/@generated/prisma/date-time-nullable-filter.input.ts
index 88fca8aa..0a134909 100644
--- a/@generated/prisma/date-time-nullable-filter.input.ts
+++ b/@generated/prisma/date-time-nullable-filter.input.ts
@@ -4,27 +4,28 @@ import { NestedDateTimeNullableFilter } from './nested-date-time-nullable-filter
 
 @InputType()
 export class DateTimeNullableFilter {
-  @Field(() => Date, { nullable: true })
-  equals?: Date | string;
 
-  @Field(() => [Date], { nullable: true })
-  in?: Array<Date> | Array<string>;
+    @Field(() => Date, {nullable:true})
+    equals?: Date | string;
 
-  @Field(() => [Date], { nullable: true })
-  notIn?: Array<Date> | Array<string>;
+    @Field(() => [Date], {nullable:true})
+    in?: Array<Date> | Array<string>;
 
-  @Field(() => Date, { nullable: true })
-  lt?: Date | string;
+    @Field(() => [Date], {nullable:true})
+    notIn?: Array<Date> | Array<string>;
 
-  @Field(() => Date, { nullable: true })
-  lte?: Date | string;
+    @Field(() => Date, {nullable:true})
+    lt?: Date | string;
 
-  @Field(() => Date, { nullable: true })
-  gt?: Date | string;
+    @Field(() => Date, {nullable:true})
+    lte?: Date | string;
 
-  @Field(() => Date, { nullable: true })
-  gte?: Date | string;
+    @Field(() => Date, {nullable:true})
+    gt?: Date | string;
 
-  @Field(() => NestedDateTimeNullableFilter, { nullable: true })
-  not?: NestedDateTimeNullableFilter;
+    @Field(() => Date, {nullable:true})
+    gte?: Date | string;
+
+    @Field(() => NestedDateTimeNullableFilter, {nullable:true})
+    not?: NestedDateTimeNullableFilter;
 }
diff --git a/@generated/prisma/date-time-nullable-with-aggregates-filter.input.ts b/@generated/prisma/date-time-nullable-with-aggregates-filter.input.ts
index 2f84adf2..8af95d8e 100644
--- a/@generated/prisma/date-time-nullable-with-aggregates-filter.input.ts
+++ b/@generated/prisma/date-time-nullable-with-aggregates-filter.input.ts
@@ -6,36 +6,37 @@ import { NestedDateTimeNullableFilter } from './nested-date-time-nullable-filter
 
 @InputType()
 export class DateTimeNullableWithAggregatesFilter {
-  @Field(() => Date, { nullable: true })
-  equals?: Date | string;
 
-  @Field(() => [Date], { nullable: true })
-  in?: Array<Date> | Array<string>;
+    @Field(() => Date, {nullable:true})
+    equals?: Date | string;
 
-  @Field(() => [Date], { nullable: true })
-  notIn?: Array<Date> | Array<string>;
+    @Field(() => [Date], {nullable:true})
+    in?: Array<Date> | Array<string>;
 
-  @Field(() => Date, { nullable: true })
-  lt?: Date | string;
+    @Field(() => [Date], {nullable:true})
+    notIn?: Array<Date> | Array<string>;
 
-  @Field(() => Date, { nullable: true })
-  lte?: Date | string;
+    @Field(() => Date, {nullable:true})
+    lt?: Date | string;
 
-  @Field(() => Date, { nullable: true })
-  gt?: Date | string;
+    @Field(() => Date, {nullable:true})
+    lte?: Date | string;
 
-  @Field(() => Date, { nullable: true })
-  gte?: Date | string;
+    @Field(() => Date, {nullable:true})
+    gt?: Date | string;
 
-  @Field(() => NestedDateTimeNullableWithAggregatesFilter, { nullable: true })
-  not?: NestedDateTimeNullableWithAggregatesFilter;
+    @Field(() => Date, {nullable:true})
+    gte?: Date | string;
 
-  @Field(() => NestedIntNullableFilter, { nullable: true })
-  _count?: NestedIntNullableFilter;
+    @Field(() => NestedDateTimeNullableWithAggregatesFilter, {nullable:true})
+    not?: NestedDateTimeNullableWithAggregatesFilter;
 
-  @Field(() => NestedDateTimeNullableFilter, { nullable: true })
-  _min?: NestedDateTimeNullableFilter;
+    @Field(() => NestedIntNullableFilter, {nullable:true})
+    _count?: NestedIntNullableFilter;
 
-  @Field(() => NestedDateTimeNullableFilter, { nullable: true })
-  _max?: NestedDateTimeNullableFilter;
+    @Field(() => NestedDateTimeNullableFilter, {nullable:true})
+    _min?: NestedDateTimeNullableFilter;
+
+    @Field(() => NestedDateTimeNullableFilter, {nullable:true})
+    _max?: NestedDateTimeNullableFilter;
 }
diff --git a/@generated/prisma/date-time-with-aggregates-filter.input.ts b/@generated/prisma/date-time-with-aggregates-filter.input.ts
index 47fba5e3..ab663c4f 100644
--- a/@generated/prisma/date-time-with-aggregates-filter.input.ts
+++ b/@generated/prisma/date-time-with-aggregates-filter.input.ts
@@ -6,36 +6,37 @@ import { NestedDateTimeFilter } from './nested-date-time-filter.input';
 
 @InputType()
 export class DateTimeWithAggregatesFilter {
-  @Field(() => Date, { nullable: true })
-  equals?: Date | string;
 
-  @Field(() => [Date], { nullable: true })
-  in?: Array<Date> | Array<string>;
+    @Field(() => Date, {nullable:true})
+    equals?: Date | string;
 
-  @Field(() => [Date], { nullable: true })
-  notIn?: Array<Date> | Array<string>;
+    @Field(() => [Date], {nullable:true})
+    in?: Array<Date> | Array<string>;
 
-  @Field(() => Date, { nullable: true })
-  lt?: Date | string;
+    @Field(() => [Date], {nullable:true})
+    notIn?: Array<Date> | Array<string>;
 
-  @Field(() => Date, { nullable: true })
-  lte?: Date | string;
+    @Field(() => Date, {nullable:true})
+    lt?: Date | string;
 
-  @Field(() => Date, { nullable: true })
-  gt?: Date | string;
+    @Field(() => Date, {nullable:true})
+    lte?: Date | string;
 
-  @Field(() => Date, { nullable: true })
-  gte?: Date | string;
+    @Field(() => Date, {nullable:true})
+    gt?: Date | string;
 
-  @Field(() => NestedDateTimeWithAggregatesFilter, { nullable: true })
-  not?: NestedDateTimeWithAggregatesFilter;
+    @Field(() => Date, {nullable:true})
+    gte?: Date | string;
 
-  @Field(() => NestedIntFilter, { nullable: true })
-  _count?: NestedIntFilter;
+    @Field(() => NestedDateTimeWithAggregatesFilter, {nullable:true})
+    not?: NestedDateTimeWithAggregatesFilter;
 
-  @Field(() => NestedDateTimeFilter, { nullable: true })
-  _min?: NestedDateTimeFilter;
+    @Field(() => NestedIntFilter, {nullable:true})
+    _count?: NestedIntFilter;
 
-  @Field(() => NestedDateTimeFilter, { nullable: true })
-  _max?: NestedDateTimeFilter;
+    @Field(() => NestedDateTimeFilter, {nullable:true})
+    _min?: NestedDateTimeFilter;
+
+    @Field(() => NestedDateTimeFilter, {nullable:true})
+    _max?: NestedDateTimeFilter;
 }
diff --git a/@generated/prisma/decimal-field-update-operations.input.ts b/@generated/prisma/decimal-field-update-operations.input.ts
index 7ea9b88f..729e7918 100644
--- a/@generated/prisma/decimal-field-update-operations.input.ts
+++ b/@generated/prisma/decimal-field-update-operations.input.ts
@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -8,28 +8,29 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class DecimalFieldUpdateOperationsInput {
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  set?: Decimal;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  increment?: Decimal;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    set?: Decimal;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  decrement?: Decimal;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    increment?: Decimal;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  multiply?: Decimal;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    decrement?: Decimal;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  divide?: Decimal;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    multiply?: Decimal;
+
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    divide?: Decimal;
 }
diff --git a/@generated/prisma/decimal-filter.input.ts b/@generated/prisma/decimal-filter.input.ts
index f169fac7..28bf22c5 100644
--- a/@generated/prisma/decimal-filter.input.ts
+++ b/@generated/prisma/decimal-filter.input.ts
@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -9,41 +9,42 @@ import { NestedDecimalFilter } from './nested-decimal-filter.input';
 
 @InputType()
 export class DecimalFilter {
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  equals?: Decimal;
-
-  @Field(() => [GraphQLDecimal], { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  in?: Array<Decimal>;
-
-  @Field(() => [GraphQLDecimal], { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  notIn?: Array<Decimal>;
-
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  lt?: Decimal;
-
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  lte?: Decimal;
-
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  gt?: Decimal;
-
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  gte?: Decimal;
-
-  @Field(() => NestedDecimalFilter, { nullable: true })
-  not?: NestedDecimalFilter;
+
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    equals?: Decimal;
+
+    @Field(() => [GraphQLDecimal], {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    in?: Array<Decimal>;
+
+    @Field(() => [GraphQLDecimal], {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    notIn?: Array<Decimal>;
+
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    lt?: Decimal;
+
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    lte?: Decimal;
+
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    gt?: Decimal;
+
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    gte?: Decimal;
+
+    @Field(() => NestedDecimalFilter, {nullable:true})
+    not?: NestedDecimalFilter;
 }
diff --git a/@generated/prisma/decimal-nullable-filter.input.ts b/@generated/prisma/decimal-nullable-filter.input.ts
index aaeca497..36245ac4 100644
--- a/@generated/prisma/decimal-nullable-filter.input.ts
+++ b/@generated/prisma/decimal-nullable-filter.input.ts
@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -9,41 +9,42 @@ import { NestedDecimalNullableFilter } from './nested-decimal-nullable-filter.in
 
 @InputType()
 export class DecimalNullableFilter {
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  equals?: Decimal;
-
-  @Field(() => [GraphQLDecimal], { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  in?: Array<Decimal>;
-
-  @Field(() => [GraphQLDecimal], { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  notIn?: Array<Decimal>;
-
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  lt?: Decimal;
-
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  lte?: Decimal;
-
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  gt?: Decimal;
-
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  gte?: Decimal;
-
-  @Field(() => NestedDecimalNullableFilter, { nullable: true })
-  not?: NestedDecimalNullableFilter;
+
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    equals?: Decimal;
+
+    @Field(() => [GraphQLDecimal], {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    in?: Array<Decimal>;
+
+    @Field(() => [GraphQLDecimal], {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    notIn?: Array<Decimal>;
+
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    lt?: Decimal;
+
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    lte?: Decimal;
+
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    gt?: Decimal;
+
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    gte?: Decimal;
+
+    @Field(() => NestedDecimalNullableFilter, {nullable:true})
+    not?: NestedDecimalNullableFilter;
 }
diff --git a/@generated/prisma/decimal-nullable-list-filter.input.ts b/@generated/prisma/decimal-nullable-list-filter.input.ts
index e1b85651..877b8b91 100644
--- a/@generated/prisma/decimal-nullable-list-filter.input.ts
+++ b/@generated/prisma/decimal-nullable-list-filter.input.ts
@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -8,26 +8,27 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class DecimalNullableListFilter {
-  @Field(() => [GraphQLDecimal], { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  equals?: Array<Decimal>;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  has?: Decimal;
+    @Field(() => [GraphQLDecimal], {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    equals?: Array<Decimal>;
 
-  @Field(() => [GraphQLDecimal], { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  hasEvery?: Array<Decimal>;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    has?: Decimal;
 
-  @Field(() => [GraphQLDecimal], { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  hasSome?: Array<Decimal>;
+    @Field(() => [GraphQLDecimal], {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    hasEvery?: Array<Decimal>;
 
-  @Field(() => Boolean, { nullable: true })
-  isEmpty?: boolean;
+    @Field(() => [GraphQLDecimal], {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    hasSome?: Array<Decimal>;
+
+    @Field(() => Boolean, {nullable:true})
+    isEmpty?: boolean;
 }
diff --git a/@generated/prisma/decimal-nullable-with-aggregates-filter.input.ts b/@generated/prisma/decimal-nullable-with-aggregates-filter.input.ts
index bca3a655..ff402b41 100644
--- a/@generated/prisma/decimal-nullable-with-aggregates-filter.input.ts
+++ b/@generated/prisma/decimal-nullable-with-aggregates-filter.input.ts
@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -11,56 +11,57 @@ import { NestedDecimalNullableFilter } from './nested-decimal-nullable-filter.in
 
 @InputType()
 export class DecimalNullableWithAggregatesFilter {
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  equals?: Decimal;
 
-  @Field(() => [GraphQLDecimal], { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  in?: Array<Decimal>;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    equals?: Decimal;
 
-  @Field(() => [GraphQLDecimal], { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  notIn?: Array<Decimal>;
+    @Field(() => [GraphQLDecimal], {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    in?: Array<Decimal>;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  lt?: Decimal;
+    @Field(() => [GraphQLDecimal], {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    notIn?: Array<Decimal>;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  lte?: Decimal;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    lt?: Decimal;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  gt?: Decimal;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    lte?: Decimal;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  gte?: Decimal;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    gt?: Decimal;
 
-  @Field(() => NestedDecimalNullableWithAggregatesFilter, { nullable: true })
-  not?: NestedDecimalNullableWithAggregatesFilter;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    gte?: Decimal;
 
-  @Field(() => NestedIntNullableFilter, { nullable: true })
-  _count?: NestedIntNullableFilter;
+    @Field(() => NestedDecimalNullableWithAggregatesFilter, {nullable:true})
+    not?: NestedDecimalNullableWithAggregatesFilter;
 
-  @Field(() => NestedDecimalNullableFilter, { nullable: true })
-  _avg?: NestedDecimalNullableFilter;
+    @Field(() => NestedIntNullableFilter, {nullable:true})
+    _count?: NestedIntNullableFilter;
 
-  @Field(() => NestedDecimalNullableFilter, { nullable: true })
-  _sum?: NestedDecimalNullableFilter;
+    @Field(() => NestedDecimalNullableFilter, {nullable:true})
+    _avg?: NestedDecimalNullableFilter;
 
-  @Field(() => NestedDecimalNullableFilter, { nullable: true })
-  _min?: NestedDecimalNullableFilter;
+    @Field(() => NestedDecimalNullableFilter, {nullable:true})
+    _sum?: NestedDecimalNullableFilter;
 
-  @Field(() => NestedDecimalNullableFilter, { nullable: true })
-  _max?: NestedDecimalNullableFilter;
+    @Field(() => NestedDecimalNullableFilter, {nullable:true})
+    _min?: NestedDecimalNullableFilter;
+
+    @Field(() => NestedDecimalNullableFilter, {nullable:true})
+    _max?: NestedDecimalNullableFilter;
 }
diff --git a/@generated/prisma/decimal-with-aggregates-filter.input.ts b/@generated/prisma/decimal-with-aggregates-filter.input.ts
index 4155d89f..50cc3bb9 100644
--- a/@generated/prisma/decimal-with-aggregates-filter.input.ts
+++ b/@generated/prisma/decimal-with-aggregates-filter.input.ts
@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -11,56 +11,57 @@ import { NestedDecimalFilter } from './nested-decimal-filter.input';
 
 @InputType()
 export class DecimalWithAggregatesFilter {
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  equals?: Decimal;
 
-  @Field(() => [GraphQLDecimal], { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  in?: Array<Decimal>;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    equals?: Decimal;
 
-  @Field(() => [GraphQLDecimal], { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  notIn?: Array<Decimal>;
+    @Field(() => [GraphQLDecimal], {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    in?: Array<Decimal>;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  lt?: Decimal;
+    @Field(() => [GraphQLDecimal], {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    notIn?: Array<Decimal>;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  lte?: Decimal;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    lt?: Decimal;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  gt?: Decimal;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    lte?: Decimal;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  gte?: Decimal;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    gt?: Decimal;
 
-  @Field(() => NestedDecimalWithAggregatesFilter, { nullable: true })
-  not?: NestedDecimalWithAggregatesFilter;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    gte?: Decimal;
 
-  @Field(() => NestedIntFilter, { nullable: true })
-  _count?: NestedIntFilter;
+    @Field(() => NestedDecimalWithAggregatesFilter, {nullable:true})
+    not?: NestedDecimalWithAggregatesFilter;
 
-  @Field(() => NestedDecimalFilter, { nullable: true })
-  _avg?: NestedDecimalFilter;
+    @Field(() => NestedIntFilter, {nullable:true})
+    _count?: NestedIntFilter;
 
-  @Field(() => NestedDecimalFilter, { nullable: true })
-  _sum?: NestedDecimalFilter;
+    @Field(() => NestedDecimalFilter, {nullable:true})
+    _avg?: NestedDecimalFilter;
 
-  @Field(() => NestedDecimalFilter, { nullable: true })
-  _min?: NestedDecimalFilter;
+    @Field(() => NestedDecimalFilter, {nullable:true})
+    _sum?: NestedDecimalFilter;
 
-  @Field(() => NestedDecimalFilter, { nullable: true })
-  _max?: NestedDecimalFilter;
+    @Field(() => NestedDecimalFilter, {nullable:true})
+    _min?: NestedDecimalFilter;
+
+    @Field(() => NestedDecimalFilter, {nullable:true})
+    _max?: NestedDecimalFilter;
 }
diff --git a/@generated/prisma/enum-role-nullable-filter.input.ts b/@generated/prisma/enum-role-nullable-filter.input.ts
index a302cd7a..bff17b98 100644
--- a/@generated/prisma/enum-role-nullable-filter.input.ts
+++ b/@generated/prisma/enum-role-nullable-filter.input.ts
@@ -5,15 +5,16 @@ import { NestedEnumRoleNullableFilter } from './nested-enum-role-nullable-filter
 
 @InputType()
 export class EnumRoleNullableFilter {
-  @Field(() => Role, { nullable: true })
-  equals?: keyof typeof Role;
 
-  @Field(() => [Role], { nullable: true })
-  in?: Array<keyof typeof Role>;
+    @Field(() => Role, {nullable:true})
+    equals?: keyof typeof Role;
 
-  @Field(() => [Role], { nullable: true })
-  notIn?: Array<keyof typeof Role>;
+    @Field(() => [Role], {nullable:true})
+    in?: Array<keyof typeof Role>;
 
-  @Field(() => NestedEnumRoleNullableFilter, { nullable: true })
-  not?: NestedEnumRoleNullableFilter;
+    @Field(() => [Role], {nullable:true})
+    notIn?: Array<keyof typeof Role>;
+
+    @Field(() => NestedEnumRoleNullableFilter, {nullable:true})
+    not?: NestedEnumRoleNullableFilter;
 }
diff --git a/@generated/prisma/enum-role-nullable-with-aggregates-filter.input.ts b/@generated/prisma/enum-role-nullable-with-aggregates-filter.input.ts
index d953f201..1e1db350 100644
--- a/@generated/prisma/enum-role-nullable-with-aggregates-filter.input.ts
+++ b/@generated/prisma/enum-role-nullable-with-aggregates-filter.input.ts
@@ -7,24 +7,25 @@ import { NestedEnumRoleNullableFilter } from './nested-enum-role-nullable-filter
 
 @InputType()
 export class EnumRoleNullableWithAggregatesFilter {
-  @Field(() => Role, { nullable: true })
-  equals?: keyof typeof Role;
 
-  @Field(() => [Role], { nullable: true })
-  in?: Array<keyof typeof Role>;
+    @Field(() => Role, {nullable:true})
+    equals?: keyof typeof Role;
 
-  @Field(() => [Role], { nullable: true })
-  notIn?: Array<keyof typeof Role>;
+    @Field(() => [Role], {nullable:true})
+    in?: Array<keyof typeof Role>;
 
-  @Field(() => NestedEnumRoleNullableWithAggregatesFilter, { nullable: true })
-  not?: NestedEnumRoleNullableWithAggregatesFilter;
+    @Field(() => [Role], {nullable:true})
+    notIn?: Array<keyof typeof Role>;
 
-  @Field(() => NestedIntNullableFilter, { nullable: true })
-  _count?: NestedIntNullableFilter;
+    @Field(() => NestedEnumRoleNullableWithAggregatesFilter, {nullable:true})
+    not?: NestedEnumRoleNullableWithAggregatesFilter;
 
-  @Field(() => NestedEnumRoleNullableFilter, { nullable: true })
-  _min?: NestedEnumRoleNullableFilter;
+    @Field(() => NestedIntNullableFilter, {nullable:true})
+    _count?: NestedIntNullableFilter;
 
-  @Field(() => NestedEnumRoleNullableFilter, { nullable: true })
-  _max?: NestedEnumRoleNullableFilter;
+    @Field(() => NestedEnumRoleNullableFilter, {nullable:true})
+    _min?: NestedEnumRoleNullableFilter;
+
+    @Field(() => NestedEnumRoleNullableFilter, {nullable:true})
+    _max?: NestedEnumRoleNullableFilter;
 }
diff --git a/@generated/prisma/float-nullable-filter.input.ts b/@generated/prisma/float-nullable-filter.input.ts
index 1d343dd1..e415cbbc 100644
--- a/@generated/prisma/float-nullable-filter.input.ts
+++ b/@generated/prisma/float-nullable-filter.input.ts
@@ -5,27 +5,28 @@ import { NestedFloatNullableFilter } from './nested-float-nullable-filter.input'
 
 @InputType()
 export class FloatNullableFilter {
-  @Field(() => Float, { nullable: true })
-  equals?: number;
 
-  @Field(() => [Float], { nullable: true })
-  in?: Array<number>;
+    @Field(() => Float, {nullable:true})
+    equals?: number;
 
-  @Field(() => [Float], { nullable: true })
-  notIn?: Array<number>;
+    @Field(() => [Float], {nullable:true})
+    in?: Array<number>;
 
-  @Field(() => Float, { nullable: true })
-  lt?: number;
+    @Field(() => [Float], {nullable:true})
+    notIn?: Array<number>;
 
-  @Field(() => Float, { nullable: true })
-  lte?: number;
+    @Field(() => Float, {nullable:true})
+    lt?: number;
 
-  @Field(() => Float, { nullable: true })
-  gt?: number;
+    @Field(() => Float, {nullable:true})
+    lte?: number;
 
-  @Field(() => Float, { nullable: true })
-  gte?: number;
+    @Field(() => Float, {nullable:true})
+    gt?: number;
 
-  @Field(() => NestedFloatNullableFilter, { nullable: true })
-  not?: NestedFloatNullableFilter;
+    @Field(() => Float, {nullable:true})
+    gte?: number;
+
+    @Field(() => NestedFloatNullableFilter, {nullable:true})
+    not?: NestedFloatNullableFilter;
 }
diff --git a/@generated/prisma/float-nullable-with-aggregates-filter.input.ts b/@generated/prisma/float-nullable-with-aggregates-filter.input.ts
index 9c6c327d..e2af29e3 100644
--- a/@generated/prisma/float-nullable-with-aggregates-filter.input.ts
+++ b/@generated/prisma/float-nullable-with-aggregates-filter.input.ts
@@ -7,42 +7,43 @@ import { NestedFloatNullableFilter } from './nested-float-nullable-filter.input'
 
 @InputType()
 export class FloatNullableWithAggregatesFilter {
-  @Field(() => Float, { nullable: true })
-  equals?: number;
 
-  @Field(() => [Float], { nullable: true })
-  in?: Array<number>;
+    @Field(() => Float, {nullable:true})
+    equals?: number;
 
-  @Field(() => [Float], { nullable: true })
-  notIn?: Array<number>;
+    @Field(() => [Float], {nullable:true})
+    in?: Array<number>;
 
-  @Field(() => Float, { nullable: true })
-  lt?: number;
+    @Field(() => [Float], {nullable:true})
+    notIn?: Array<number>;
 
-  @Field(() => Float, { nullable: true })
-  lte?: number;
+    @Field(() => Float, {nullable:true})
+    lt?: number;
 
-  @Field(() => Float, { nullable: true })
-  gt?: number;
+    @Field(() => Float, {nullable:true})
+    lte?: number;
 
-  @Field(() => Float, { nullable: true })
-  gte?: number;
+    @Field(() => Float, {nullable:true})
+    gt?: number;
 
-  @Field(() => NestedFloatNullableWithAggregatesFilter, { nullable: true })
-  not?: NestedFloatNullableWithAggregatesFilter;
+    @Field(() => Float, {nullable:true})
+    gte?: number;
 
-  @Field(() => NestedIntNullableFilter, { nullable: true })
-  _count?: NestedIntNullableFilter;
+    @Field(() => NestedFloatNullableWithAggregatesFilter, {nullable:true})
+    not?: NestedFloatNullableWithAggregatesFilter;
 
-  @Field(() => NestedFloatNullableFilter, { nullable: true })
-  _avg?: NestedFloatNullableFilter;
+    @Field(() => NestedIntNullableFilter, {nullable:true})
+    _count?: NestedIntNullableFilter;
 
-  @Field(() => NestedFloatNullableFilter, { nullable: true })
-  _sum?: NestedFloatNullableFilter;
+    @Field(() => NestedFloatNullableFilter, {nullable:true})
+    _avg?: NestedFloatNullableFilter;
 
-  @Field(() => NestedFloatNullableFilter, { nullable: true })
-  _min?: NestedFloatNullableFilter;
+    @Field(() => NestedFloatNullableFilter, {nullable:true})
+    _sum?: NestedFloatNullableFilter;
 
-  @Field(() => NestedFloatNullableFilter, { nullable: true })
-  _max?: NestedFloatNullableFilter;
+    @Field(() => NestedFloatNullableFilter, {nullable:true})
+    _min?: NestedFloatNullableFilter;
+
+    @Field(() => NestedFloatNullableFilter, {nullable:true})
+    _max?: NestedFloatNullableFilter;
 }
diff --git a/@generated/prisma/int-field-update-operations.input.ts b/@generated/prisma/int-field-update-operations.input.ts
index 335ffa09..f4decce3 100644
--- a/@generated/prisma/int-field-update-operations.input.ts
+++ b/@generated/prisma/int-field-update-operations.input.ts
@@ -4,18 +4,19 @@ import { Int } from '@nestjs/graphql';
 
 @InputType()
 export class IntFieldUpdateOperationsInput {
-  @Field(() => Int, { nullable: true })
-  set?: number;
 
-  @Field(() => Int, { nullable: true })
-  increment?: number;
+    @Field(() => Int, {nullable:true})
+    set?: number;
 
-  @Field(() => Int, { nullable: true })
-  decrement?: number;
+    @Field(() => Int, {nullable:true})
+    increment?: number;
 
-  @Field(() => Int, { nullable: true })
-  multiply?: number;
+    @Field(() => Int, {nullable:true})
+    decrement?: number;
 
-  @Field(() => Int, { nullable: true })
-  divide?: number;
+    @Field(() => Int, {nullable:true})
+    multiply?: number;
+
+    @Field(() => Int, {nullable:true})
+    divide?: number;
 }
diff --git a/@generated/prisma/int-filter.input.ts b/@generated/prisma/int-filter.input.ts
index 3ed50be5..31437c29 100644
--- a/@generated/prisma/int-filter.input.ts
+++ b/@generated/prisma/int-filter.input.ts
@@ -5,27 +5,28 @@ import { NestedIntFilter } from './nested-int-filter.input';
 
 @InputType()
 export class IntFilter {
-  @Field(() => Int, { nullable: true })
-  equals?: number;
 
-  @Field(() => [Int], { nullable: true })
-  in?: Array<number>;
+    @Field(() => Int, {nullable:true})
+    equals?: number;
 
-  @Field(() => [Int], { nullable: true })
-  notIn?: Array<number>;
+    @Field(() => [Int], {nullable:true})
+    in?: Array<number>;
 
-  @Field(() => Int, { nullable: true })
-  lt?: number;
+    @Field(() => [Int], {nullable:true})
+    notIn?: Array<number>;
 
-  @Field(() => Int, { nullable: true })
-  lte?: number;
+    @Field(() => Int, {nullable:true})
+    lt?: number;
 
-  @Field(() => Int, { nullable: true })
-  gt?: number;
+    @Field(() => Int, {nullable:true})
+    lte?: number;
 
-  @Field(() => Int, { nullable: true })
-  gte?: number;
+    @Field(() => Int, {nullable:true})
+    gt?: number;
 
-  @Field(() => NestedIntFilter, { nullable: true })
-  not?: NestedIntFilter;
+    @Field(() => Int, {nullable:true})
+    gte?: number;
+
+    @Field(() => NestedIntFilter, {nullable:true})
+    not?: NestedIntFilter;
 }
diff --git a/@generated/prisma/int-nullable-filter.input.ts b/@generated/prisma/int-nullable-filter.input.ts
index 07d6ecaa..cd2e7ab7 100644
--- a/@generated/prisma/int-nullable-filter.input.ts
+++ b/@generated/prisma/int-nullable-filter.input.ts
@@ -5,27 +5,28 @@ import { NestedIntNullableFilter } from './nested-int-nullable-filter.input';
 
 @InputType()
 export class IntNullableFilter {
-  @Field(() => Int, { nullable: true })
-  equals?: number;
 
-  @Field(() => [Int], { nullable: true })
-  in?: Array<number>;
+    @Field(() => Int, {nullable:true})
+    equals?: number;
 
-  @Field(() => [Int], { nullable: true })
-  notIn?: Array<number>;
+    @Field(() => [Int], {nullable:true})
+    in?: Array<number>;
 
-  @Field(() => Int, { nullable: true })
-  lt?: number;
+    @Field(() => [Int], {nullable:true})
+    notIn?: Array<number>;
 
-  @Field(() => Int, { nullable: true })
-  lte?: number;
+    @Field(() => Int, {nullable:true})
+    lt?: number;
 
-  @Field(() => Int, { nullable: true })
-  gt?: number;
+    @Field(() => Int, {nullable:true})
+    lte?: number;
 
-  @Field(() => Int, { nullable: true })
-  gte?: number;
+    @Field(() => Int, {nullable:true})
+    gt?: number;
 
-  @Field(() => NestedIntNullableFilter, { nullable: true })
-  not?: NestedIntNullableFilter;
+    @Field(() => Int, {nullable:true})
+    gte?: number;
+
+    @Field(() => NestedIntNullableFilter, {nullable:true})
+    not?: NestedIntNullableFilter;
 }
diff --git a/@generated/prisma/int-nullable-with-aggregates-filter.input.ts b/@generated/prisma/int-nullable-with-aggregates-filter.input.ts
index 577ec31c..8eb3fa98 100644
--- a/@generated/prisma/int-nullable-with-aggregates-filter.input.ts
+++ b/@generated/prisma/int-nullable-with-aggregates-filter.input.ts
@@ -7,42 +7,43 @@ import { NestedFloatNullableFilter } from './nested-float-nullable-filter.input'
 
 @InputType()
 export class IntNullableWithAggregatesFilter {
-  @Field(() => Int, { nullable: true })
-  equals?: number;
 
-  @Field(() => [Int], { nullable: true })
-  in?: Array<number>;
+    @Field(() => Int, {nullable:true})
+    equals?: number;
 
-  @Field(() => [Int], { nullable: true })
-  notIn?: Array<number>;
+    @Field(() => [Int], {nullable:true})
+    in?: Array<number>;
 
-  @Field(() => Int, { nullable: true })
-  lt?: number;
+    @Field(() => [Int], {nullable:true})
+    notIn?: Array<number>;
 
-  @Field(() => Int, { nullable: true })
-  lte?: number;
+    @Field(() => Int, {nullable:true})
+    lt?: number;
 
-  @Field(() => Int, { nullable: true })
-  gt?: number;
+    @Field(() => Int, {nullable:true})
+    lte?: number;
 
-  @Field(() => Int, { nullable: true })
-  gte?: number;
+    @Field(() => Int, {nullable:true})
+    gt?: number;
 
-  @Field(() => NestedIntNullableWithAggregatesFilter, { nullable: true })
-  not?: NestedIntNullableWithAggregatesFilter;
+    @Field(() => Int, {nullable:true})
+    gte?: number;
 
-  @Field(() => NestedIntNullableFilter, { nullable: true })
-  _count?: NestedIntNullableFilter;
+    @Field(() => NestedIntNullableWithAggregatesFilter, {nullable:true})
+    not?: NestedIntNullableWithAggregatesFilter;
 
-  @Field(() => NestedFloatNullableFilter, { nullable: true })
-  _avg?: NestedFloatNullableFilter;
+    @Field(() => NestedIntNullableFilter, {nullable:true})
+    _count?: NestedIntNullableFilter;
 
-  @Field(() => NestedIntNullableFilter, { nullable: true })
-  _sum?: NestedIntNullableFilter;
+    @Field(() => NestedFloatNullableFilter, {nullable:true})
+    _avg?: NestedFloatNullableFilter;
 
-  @Field(() => NestedIntNullableFilter, { nullable: true })
-  _min?: NestedIntNullableFilter;
+    @Field(() => NestedIntNullableFilter, {nullable:true})
+    _sum?: NestedIntNullableFilter;
 
-  @Field(() => NestedIntNullableFilter, { nullable: true })
-  _max?: NestedIntNullableFilter;
+    @Field(() => NestedIntNullableFilter, {nullable:true})
+    _min?: NestedIntNullableFilter;
+
+    @Field(() => NestedIntNullableFilter, {nullable:true})
+    _max?: NestedIntNullableFilter;
 }
diff --git a/@generated/prisma/int-with-aggregates-filter.input.ts b/@generated/prisma/int-with-aggregates-filter.input.ts
index 38eedc82..b872c127 100644
--- a/@generated/prisma/int-with-aggregates-filter.input.ts
+++ b/@generated/prisma/int-with-aggregates-filter.input.ts
@@ -7,42 +7,43 @@ import { NestedFloatFilter } from './nested-float-filter.input';
 
 @InputType()
 export class IntWithAggregatesFilter {
-  @Field(() => Int, { nullable: true })
-  equals?: number;
 
-  @Field(() => [Int], { nullable: true })
-  in?: Array<number>;
+    @Field(() => Int, {nullable:true})
+    equals?: number;
 
-  @Field(() => [Int], { nullable: true })
-  notIn?: Array<number>;
+    @Field(() => [Int], {nullable:true})
+    in?: Array<number>;
 
-  @Field(() => Int, { nullable: true })
-  lt?: number;
+    @Field(() => [Int], {nullable:true})
+    notIn?: Array<number>;
 
-  @Field(() => Int, { nullable: true })
-  lte?: number;
+    @Field(() => Int, {nullable:true})
+    lt?: number;
 
-  @Field(() => Int, { nullable: true })
-  gt?: number;
+    @Field(() => Int, {nullable:true})
+    lte?: number;
 
-  @Field(() => Int, { nullable: true })
-  gte?: number;
+    @Field(() => Int, {nullable:true})
+    gt?: number;
 
-  @Field(() => NestedIntWithAggregatesFilter, { nullable: true })
-  not?: NestedIntWithAggregatesFilter;
+    @Field(() => Int, {nullable:true})
+    gte?: number;
 
-  @Field(() => NestedIntFilter, { nullable: true })
-  _count?: NestedIntFilter;
+    @Field(() => NestedIntWithAggregatesFilter, {nullable:true})
+    not?: NestedIntWithAggregatesFilter;
 
-  @Field(() => NestedFloatFilter, { nullable: true })
-  _avg?: NestedFloatFilter;
+    @Field(() => NestedIntFilter, {nullable:true})
+    _count?: NestedIntFilter;
 
-  @Field(() => NestedIntFilter, { nullable: true })
-  _sum?: NestedIntFilter;
+    @Field(() => NestedFloatFilter, {nullable:true})
+    _avg?: NestedFloatFilter;
 
-  @Field(() => NestedIntFilter, { nullable: true })
-  _min?: NestedIntFilter;
+    @Field(() => NestedIntFilter, {nullable:true})
+    _sum?: NestedIntFilter;
 
-  @Field(() => NestedIntFilter, { nullable: true })
-  _max?: NestedIntFilter;
+    @Field(() => NestedIntFilter, {nullable:true})
+    _min?: NestedIntFilter;
+
+    @Field(() => NestedIntFilter, {nullable:true})
+    _max?: NestedIntFilter;
 }
diff --git a/@generated/prisma/json-null-value-filter.enum.ts b/@generated/prisma/json-null-value-filter.enum.ts
index eed4c588..8c3b4f96 100644
--- a/@generated/prisma/json-null-value-filter.enum.ts
+++ b/@generated/prisma/json-null-value-filter.enum.ts
@@ -1,12 +1,10 @@
 import { registerEnumType } from '@nestjs/graphql';
 
 export enum JsonNullValueFilter {
-  DbNull = 'DbNull',
-  JsonNull = 'JsonNull',
-  AnyNull = 'AnyNull',
+    DbNull = "DbNull",
+    JsonNull = "JsonNull",
+    AnyNull = "AnyNull"
 }
 
-registerEnumType(JsonNullValueFilter, {
-  name: 'JsonNullValueFilter',
-  description: undefined,
-});
+
+registerEnumType(JsonNullValueFilter, { name: 'JsonNullValueFilter', description: undefined })
diff --git a/@generated/prisma/json-nullable-filter.input.ts b/@generated/prisma/json-nullable-filter.input.ts
index c74e589a..b9295286 100644
--- a/@generated/prisma/json-nullable-filter.input.ts
+++ b/@generated/prisma/json-nullable-filter.input.ts
@@ -4,42 +4,43 @@ import { GraphQLJSON } from 'graphql-type-json';
 
 @InputType()
 export class JsonNullableFilter {
-  @Field(() => GraphQLJSON, { nullable: true })
-  equals?: any;
 
-  @Field(() => [String], { nullable: true })
-  path?: Array<string>;
+    @Field(() => GraphQLJSON, {nullable:true})
+    equals?: any;
 
-  @Field(() => String, { nullable: true })
-  string_contains?: string;
+    @Field(() => [String], {nullable:true})
+    path?: Array<string>;
 
-  @Field(() => String, { nullable: true })
-  string_starts_with?: string;
+    @Field(() => String, {nullable:true})
+    string_contains?: string;
 
-  @Field(() => String, { nullable: true })
-  string_ends_with?: string;
+    @Field(() => String, {nullable:true})
+    string_starts_with?: string;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  array_contains?: any;
+    @Field(() => String, {nullable:true})
+    string_ends_with?: string;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  array_starts_with?: any;
+    @Field(() => GraphQLJSON, {nullable:true})
+    array_contains?: any;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  array_ends_with?: any;
+    @Field(() => GraphQLJSON, {nullable:true})
+    array_starts_with?: any;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  lt?: any;
+    @Field(() => GraphQLJSON, {nullable:true})
+    array_ends_with?: any;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  lte?: any;
+    @Field(() => GraphQLJSON, {nullable:true})
+    lt?: any;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  gt?: any;
+    @Field(() => GraphQLJSON, {nullable:true})
+    lte?: any;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  gte?: any;
+    @Field(() => GraphQLJSON, {nullable:true})
+    gt?: any;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  not?: any;
+    @Field(() => GraphQLJSON, {nullable:true})
+    gte?: any;
+
+    @Field(() => GraphQLJSON, {nullable:true})
+    not?: any;
 }
diff --git a/@generated/prisma/json-nullable-with-aggregates-filter.input.ts b/@generated/prisma/json-nullable-with-aggregates-filter.input.ts
index ee4da34a..e4378bc4 100644
--- a/@generated/prisma/json-nullable-with-aggregates-filter.input.ts
+++ b/@generated/prisma/json-nullable-with-aggregates-filter.input.ts
@@ -6,51 +6,52 @@ import { NestedJsonNullableFilter } from './nested-json-nullable-filter.input';
 
 @InputType()
 export class JsonNullableWithAggregatesFilter {
-  @Field(() => GraphQLJSON, { nullable: true })
-  equals?: any;
 
-  @Field(() => [String], { nullable: true })
-  path?: Array<string>;
+    @Field(() => GraphQLJSON, {nullable:true})
+    equals?: any;
 
-  @Field(() => String, { nullable: true })
-  string_contains?: string;
+    @Field(() => [String], {nullable:true})
+    path?: Array<string>;
 
-  @Field(() => String, { nullable: true })
-  string_starts_with?: string;
+    @Field(() => String, {nullable:true})
+    string_contains?: string;
 
-  @Field(() => String, { nullable: true })
-  string_ends_with?: string;
+    @Field(() => String, {nullable:true})
+    string_starts_with?: string;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  array_contains?: any;
+    @Field(() => String, {nullable:true})
+    string_ends_with?: string;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  array_starts_with?: any;
+    @Field(() => GraphQLJSON, {nullable:true})
+    array_contains?: any;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  array_ends_with?: any;
+    @Field(() => GraphQLJSON, {nullable:true})
+    array_starts_with?: any;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  lt?: any;
+    @Field(() => GraphQLJSON, {nullable:true})
+    array_ends_with?: any;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  lte?: any;
+    @Field(() => GraphQLJSON, {nullable:true})
+    lt?: any;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  gt?: any;
+    @Field(() => GraphQLJSON, {nullable:true})
+    lte?: any;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  gte?: any;
+    @Field(() => GraphQLJSON, {nullable:true})
+    gt?: any;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  not?: any;
+    @Field(() => GraphQLJSON, {nullable:true})
+    gte?: any;
 
-  @Field(() => NestedIntNullableFilter, { nullable: true })
-  _count?: NestedIntNullableFilter;
+    @Field(() => GraphQLJSON, {nullable:true})
+    not?: any;
 
-  @Field(() => NestedJsonNullableFilter, { nullable: true })
-  _min?: NestedJsonNullableFilter;
+    @Field(() => NestedIntNullableFilter, {nullable:true})
+    _count?: NestedIntNullableFilter;
 
-  @Field(() => NestedJsonNullableFilter, { nullable: true })
-  _max?: NestedJsonNullableFilter;
+    @Field(() => NestedJsonNullableFilter, {nullable:true})
+    _min?: NestedJsonNullableFilter;
+
+    @Field(() => NestedJsonNullableFilter, {nullable:true})
+    _max?: NestedJsonNullableFilter;
 }
diff --git a/@generated/prisma/nested-big-int-nullable-filter.input.ts b/@generated/prisma/nested-big-int-nullable-filter.input.ts
index 471e7001..0b58dad3 100644
--- a/@generated/prisma/nested-big-int-nullable-filter.input.ts
+++ b/@generated/prisma/nested-big-int-nullable-filter.input.ts
@@ -3,27 +3,28 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class NestedBigIntNullableFilter {
-  @Field(() => String, { nullable: true })
-  equals?: bigint | number;
 
-  @Field(() => [String], { nullable: true })
-  in?: Array<bigint> | Array<number>;
+    @Field(() => String, {nullable:true})
+    equals?: bigint | number;
 
-  @Field(() => [String], { nullable: true })
-  notIn?: Array<bigint> | Array<number>;
+    @Field(() => [String], {nullable:true})
+    in?: Array<bigint> | Array<number>;
 
-  @Field(() => String, { nullable: true })
-  lt?: bigint | number;
+    @Field(() => [String], {nullable:true})
+    notIn?: Array<bigint> | Array<number>;
 
-  @Field(() => String, { nullable: true })
-  lte?: bigint | number;
+    @Field(() => String, {nullable:true})
+    lt?: bigint | number;
 
-  @Field(() => String, { nullable: true })
-  gt?: bigint | number;
+    @Field(() => String, {nullable:true})
+    lte?: bigint | number;
 
-  @Field(() => String, { nullable: true })
-  gte?: bigint | number;
+    @Field(() => String, {nullable:true})
+    gt?: bigint | number;
 
-  @Field(() => NestedBigIntNullableFilter, { nullable: true })
-  not?: NestedBigIntNullableFilter;
+    @Field(() => String, {nullable:true})
+    gte?: bigint | number;
+
+    @Field(() => NestedBigIntNullableFilter, {nullable:true})
+    not?: NestedBigIntNullableFilter;
 }
diff --git a/@generated/prisma/nested-big-int-nullable-with-aggregates-filter.input.ts b/@generated/prisma/nested-big-int-nullable-with-aggregates-filter.input.ts
index bcc4accf..ad4d44c8 100644
--- a/@generated/prisma/nested-big-int-nullable-with-aggregates-filter.input.ts
+++ b/@generated/prisma/nested-big-int-nullable-with-aggregates-filter.input.ts
@@ -6,42 +6,43 @@ import { NestedBigIntNullableFilter } from './nested-big-int-nullable-filter.inp
 
 @InputType()
 export class NestedBigIntNullableWithAggregatesFilter {
-  @Field(() => String, { nullable: true })
-  equals?: bigint | number;
 
-  @Field(() => [String], { nullable: true })
-  in?: Array<bigint> | Array<number>;
+    @Field(() => String, {nullable:true})
+    equals?: bigint | number;
 
-  @Field(() => [String], { nullable: true })
-  notIn?: Array<bigint> | Array<number>;
+    @Field(() => [String], {nullable:true})
+    in?: Array<bigint> | Array<number>;
 
-  @Field(() => String, { nullable: true })
-  lt?: bigint | number;
+    @Field(() => [String], {nullable:true})
+    notIn?: Array<bigint> | Array<number>;
 
-  @Field(() => String, { nullable: true })
-  lte?: bigint | number;
+    @Field(() => String, {nullable:true})
+    lt?: bigint | number;
 
-  @Field(() => String, { nullable: true })
-  gt?: bigint | number;
+    @Field(() => String, {nullable:true})
+    lte?: bigint | number;
 
-  @Field(() => String, { nullable: true })
-  gte?: bigint | number;
+    @Field(() => String, {nullable:true})
+    gt?: bigint | number;
 
-  @Field(() => NestedBigIntNullableWithAggregatesFilter, { nullable: true })
-  not?: NestedBigIntNullableWithAggregatesFilter;
+    @Field(() => String, {nullable:true})
+    gte?: bigint | number;
 
-  @Field(() => NestedIntNullableFilter, { nullable: true })
-  _count?: NestedIntNullableFilter;
+    @Field(() => NestedBigIntNullableWithAggregatesFilter, {nullable:true})
+    not?: NestedBigIntNullableWithAggregatesFilter;
 
-  @Field(() => NestedFloatNullableFilter, { nullable: true })
-  _avg?: NestedFloatNullableFilter;
+    @Field(() => NestedIntNullableFilter, {nullable:true})
+    _count?: NestedIntNullableFilter;
 
-  @Field(() => NestedBigIntNullableFilter, { nullable: true })
-  _sum?: NestedBigIntNullableFilter;
+    @Field(() => NestedFloatNullableFilter, {nullable:true})
+    _avg?: NestedFloatNullableFilter;
 
-  @Field(() => NestedBigIntNullableFilter, { nullable: true })
-  _min?: NestedBigIntNullableFilter;
+    @Field(() => NestedBigIntNullableFilter, {nullable:true})
+    _sum?: NestedBigIntNullableFilter;
 
-  @Field(() => NestedBigIntNullableFilter, { nullable: true })
-  _max?: NestedBigIntNullableFilter;
+    @Field(() => NestedBigIntNullableFilter, {nullable:true})
+    _min?: NestedBigIntNullableFilter;
+
+    @Field(() => NestedBigIntNullableFilter, {nullable:true})
+    _max?: NestedBigIntNullableFilter;
 }
diff --git a/@generated/prisma/nested-bool-nullable-filter.input.ts b/@generated/prisma/nested-bool-nullable-filter.input.ts
index 0ab500d3..ff513a6e 100644
--- a/@generated/prisma/nested-bool-nullable-filter.input.ts
+++ b/@generated/prisma/nested-bool-nullable-filter.input.ts
@@ -3,9 +3,10 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class NestedBoolNullableFilter {
-  @Field(() => Boolean, { nullable: true })
-  equals?: boolean;
 
-  @Field(() => NestedBoolNullableFilter, { nullable: true })
-  not?: NestedBoolNullableFilter;
+    @Field(() => Boolean, {nullable:true})
+    equals?: boolean;
+
+    @Field(() => NestedBoolNullableFilter, {nullable:true})
+    not?: NestedBoolNullableFilter;
 }
diff --git a/@generated/prisma/nested-bool-nullable-with-aggregates-filter.input.ts b/@generated/prisma/nested-bool-nullable-with-aggregates-filter.input.ts
index 4a5b57fd..78ab22f9 100644
--- a/@generated/prisma/nested-bool-nullable-with-aggregates-filter.input.ts
+++ b/@generated/prisma/nested-bool-nullable-with-aggregates-filter.input.ts
@@ -5,18 +5,19 @@ import { NestedBoolNullableFilter } from './nested-bool-nullable-filter.input';
 
 @InputType()
 export class NestedBoolNullableWithAggregatesFilter {
-  @Field(() => Boolean, { nullable: true })
-  equals?: boolean;
 
-  @Field(() => NestedBoolNullableWithAggregatesFilter, { nullable: true })
-  not?: NestedBoolNullableWithAggregatesFilter;
+    @Field(() => Boolean, {nullable:true})
+    equals?: boolean;
 
-  @Field(() => NestedIntNullableFilter, { nullable: true })
-  _count?: NestedIntNullableFilter;
+    @Field(() => NestedBoolNullableWithAggregatesFilter, {nullable:true})
+    not?: NestedBoolNullableWithAggregatesFilter;
 
-  @Field(() => NestedBoolNullableFilter, { nullable: true })
-  _min?: NestedBoolNullableFilter;
+    @Field(() => NestedIntNullableFilter, {nullable:true})
+    _count?: NestedIntNullableFilter;
 
-  @Field(() => NestedBoolNullableFilter, { nullable: true })
-  _max?: NestedBoolNullableFilter;
+    @Field(() => NestedBoolNullableFilter, {nullable:true})
+    _min?: NestedBoolNullableFilter;
+
+    @Field(() => NestedBoolNullableFilter, {nullable:true})
+    _max?: NestedBoolNullableFilter;
 }
diff --git a/@generated/prisma/nested-bytes-nullable-filter.input.ts b/@generated/prisma/nested-bytes-nullable-filter.input.ts
index 3f1e8ea5..1d7357e5 100644
--- a/@generated/prisma/nested-bytes-nullable-filter.input.ts
+++ b/@generated/prisma/nested-bytes-nullable-filter.input.ts
@@ -3,15 +3,16 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class NestedBytesNullableFilter {
-  @Field(() => String, { nullable: true })
-  equals?: Buffer;
 
-  @Field(() => [String], { nullable: true })
-  in?: Array<Buffer>;
+    @Field(() => String, {nullable:true})
+    equals?: Buffer;
 
-  @Field(() => [String], { nullable: true })
-  notIn?: Array<Buffer>;
+    @Field(() => [String], {nullable:true})
+    in?: Array<Buffer>;
 
-  @Field(() => NestedBytesNullableFilter, { nullable: true })
-  not?: NestedBytesNullableFilter;
+    @Field(() => [String], {nullable:true})
+    notIn?: Array<Buffer>;
+
+    @Field(() => NestedBytesNullableFilter, {nullable:true})
+    not?: NestedBytesNullableFilter;
 }
diff --git a/@generated/prisma/nested-bytes-nullable-with-aggregates-filter.input.ts b/@generated/prisma/nested-bytes-nullable-with-aggregates-filter.input.ts
index 3aa30bdc..689aeef2 100644
--- a/@generated/prisma/nested-bytes-nullable-with-aggregates-filter.input.ts
+++ b/@generated/prisma/nested-bytes-nullable-with-aggregates-filter.input.ts
@@ -5,24 +5,25 @@ import { NestedBytesNullableFilter } from './nested-bytes-nullable-filter.input'
 
 @InputType()
 export class NestedBytesNullableWithAggregatesFilter {
-  @Field(() => String, { nullable: true })
-  equals?: Buffer;
 
-  @Field(() => [String], { nullable: true })
-  in?: Array<Buffer>;
+    @Field(() => String, {nullable:true})
+    equals?: Buffer;
 
-  @Field(() => [String], { nullable: true })
-  notIn?: Array<Buffer>;
+    @Field(() => [String], {nullable:true})
+    in?: Array<Buffer>;
 
-  @Field(() => NestedBytesNullableWithAggregatesFilter, { nullable: true })
-  not?: NestedBytesNullableWithAggregatesFilter;
+    @Field(() => [String], {nullable:true})
+    notIn?: Array<Buffer>;
 
-  @Field(() => NestedIntNullableFilter, { nullable: true })
-  _count?: NestedIntNullableFilter;
+    @Field(() => NestedBytesNullableWithAggregatesFilter, {nullable:true})
+    not?: NestedBytesNullableWithAggregatesFilter;
 
-  @Field(() => NestedBytesNullableFilter, { nullable: true })
-  _min?: NestedBytesNullableFilter;
+    @Field(() => NestedIntNullableFilter, {nullable:true})
+    _count?: NestedIntNullableFilter;
 
-  @Field(() => NestedBytesNullableFilter, { nullable: true })
-  _max?: NestedBytesNullableFilter;
+    @Field(() => NestedBytesNullableFilter, {nullable:true})
+    _min?: NestedBytesNullableFilter;
+
+    @Field(() => NestedBytesNullableFilter, {nullable:true})
+    _max?: NestedBytesNullableFilter;
 }
diff --git a/@generated/prisma/nested-date-time-filter.input.ts b/@generated/prisma/nested-date-time-filter.input.ts
index 5c230f18..36c9137f 100644
--- a/@generated/prisma/nested-date-time-filter.input.ts
+++ b/@generated/prisma/nested-date-time-filter.input.ts
@@ -3,27 +3,28 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class NestedDateTimeFilter {
-  @Field(() => Date, { nullable: true })
-  equals?: Date | string;
 
-  @Field(() => [Date], { nullable: true })
-  in?: Array<Date> | Array<string>;
+    @Field(() => Date, {nullable:true})
+    equals?: Date | string;
 
-  @Field(() => [Date], { nullable: true })
-  notIn?: Array<Date> | Array<string>;
+    @Field(() => [Date], {nullable:true})
+    in?: Array<Date> | Array<string>;
 
-  @Field(() => Date, { nullable: true })
-  lt?: Date | string;
+    @Field(() => [Date], {nullable:true})
+    notIn?: Array<Date> | Array<string>;
 
-  @Field(() => Date, { nullable: true })
-  lte?: Date | string;
+    @Field(() => Date, {nullable:true})
+    lt?: Date | string;
 
-  @Field(() => Date, { nullable: true })
-  gt?: Date | string;
+    @Field(() => Date, {nullable:true})
+    lte?: Date | string;
 
-  @Field(() => Date, { nullable: true })
-  gte?: Date | string;
+    @Field(() => Date, {nullable:true})
+    gt?: Date | string;
 
-  @Field(() => NestedDateTimeFilter, { nullable: true })
-  not?: NestedDateTimeFilter;
+    @Field(() => Date, {nullable:true})
+    gte?: Date | string;
+
+    @Field(() => NestedDateTimeFilter, {nullable:true})
+    not?: NestedDateTimeFilter;
 }
diff --git a/@generated/prisma/nested-date-time-nullable-filter.input.ts b/@generated/prisma/nested-date-time-nullable-filter.input.ts
index a6977757..22c3c8ef 100644
--- a/@generated/prisma/nested-date-time-nullable-filter.input.ts
+++ b/@generated/prisma/nested-date-time-nullable-filter.input.ts
@@ -3,27 +3,28 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class NestedDateTimeNullableFilter {
-  @Field(() => Date, { nullable: true })
-  equals?: Date | string;
 
-  @Field(() => [Date], { nullable: true })
-  in?: Array<Date> | Array<string>;
+    @Field(() => Date, {nullable:true})
+    equals?: Date | string;
 
-  @Field(() => [Date], { nullable: true })
-  notIn?: Array<Date> | Array<string>;
+    @Field(() => [Date], {nullable:true})
+    in?: Array<Date> | Array<string>;
 
-  @Field(() => Date, { nullable: true })
-  lt?: Date | string;
+    @Field(() => [Date], {nullable:true})
+    notIn?: Array<Date> | Array<string>;
 
-  @Field(() => Date, { nullable: true })
-  lte?: Date | string;
+    @Field(() => Date, {nullable:true})
+    lt?: Date | string;
 
-  @Field(() => Date, { nullable: true })
-  gt?: Date | string;
+    @Field(() => Date, {nullable:true})
+    lte?: Date | string;
 
-  @Field(() => Date, { nullable: true })
-  gte?: Date | string;
+    @Field(() => Date, {nullable:true})
+    gt?: Date | string;
 
-  @Field(() => NestedDateTimeNullableFilter, { nullable: true })
-  not?: NestedDateTimeNullableFilter;
+    @Field(() => Date, {nullable:true})
+    gte?: Date | string;
+
+    @Field(() => NestedDateTimeNullableFilter, {nullable:true})
+    not?: NestedDateTimeNullableFilter;
 }
diff --git a/@generated/prisma/nested-date-time-nullable-with-aggregates-filter.input.ts b/@generated/prisma/nested-date-time-nullable-with-aggregates-filter.input.ts
index 2ab5a30a..1d3223f5 100644
--- a/@generated/prisma/nested-date-time-nullable-with-aggregates-filter.input.ts
+++ b/@generated/prisma/nested-date-time-nullable-with-aggregates-filter.input.ts
@@ -5,36 +5,37 @@ import { NestedDateTimeNullableFilter } from './nested-date-time-nullable-filter
 
 @InputType()
 export class NestedDateTimeNullableWithAggregatesFilter {
-  @Field(() => Date, { nullable: true })
-  equals?: Date | string;
 
-  @Field(() => [Date], { nullable: true })
-  in?: Array<Date> | Array<string>;
+    @Field(() => Date, {nullable:true})
+    equals?: Date | string;
 
-  @Field(() => [Date], { nullable: true })
-  notIn?: Array<Date> | Array<string>;
+    @Field(() => [Date], {nullable:true})
+    in?: Array<Date> | Array<string>;
 
-  @Field(() => Date, { nullable: true })
-  lt?: Date | string;
+    @Field(() => [Date], {nullable:true})
+    notIn?: Array<Date> | Array<string>;
 
-  @Field(() => Date, { nullable: true })
-  lte?: Date | string;
+    @Field(() => Date, {nullable:true})
+    lt?: Date | string;
 
-  @Field(() => Date, { nullable: true })
-  gt?: Date | string;
+    @Field(() => Date, {nullable:true})
+    lte?: Date | string;
 
-  @Field(() => Date, { nullable: true })
-  gte?: Date | string;
+    @Field(() => Date, {nullable:true})
+    gt?: Date | string;
 
-  @Field(() => NestedDateTimeNullableWithAggregatesFilter, { nullable: true })
-  not?: NestedDateTimeNullableWithAggregatesFilter;
+    @Field(() => Date, {nullable:true})
+    gte?: Date | string;
 
-  @Field(() => NestedIntNullableFilter, { nullable: true })
-  _count?: NestedIntNullableFilter;
+    @Field(() => NestedDateTimeNullableWithAggregatesFilter, {nullable:true})
+    not?: NestedDateTimeNullableWithAggregatesFilter;
 
-  @Field(() => NestedDateTimeNullableFilter, { nullable: true })
-  _min?: NestedDateTimeNullableFilter;
+    @Field(() => NestedIntNullableFilter, {nullable:true})
+    _count?: NestedIntNullableFilter;
 
-  @Field(() => NestedDateTimeNullableFilter, { nullable: true })
-  _max?: NestedDateTimeNullableFilter;
+    @Field(() => NestedDateTimeNullableFilter, {nullable:true})
+    _min?: NestedDateTimeNullableFilter;
+
+    @Field(() => NestedDateTimeNullableFilter, {nullable:true})
+    _max?: NestedDateTimeNullableFilter;
 }
diff --git a/@generated/prisma/nested-date-time-with-aggregates-filter.input.ts b/@generated/prisma/nested-date-time-with-aggregates-filter.input.ts
index 5c884d81..69263fc3 100644
--- a/@generated/prisma/nested-date-time-with-aggregates-filter.input.ts
+++ b/@generated/prisma/nested-date-time-with-aggregates-filter.input.ts
@@ -5,36 +5,37 @@ import { NestedDateTimeFilter } from './nested-date-time-filter.input';
 
 @InputType()
 export class NestedDateTimeWithAggregatesFilter {
-  @Field(() => Date, { nullable: true })
-  equals?: Date | string;
 
-  @Field(() => [Date], { nullable: true })
-  in?: Array<Date> | Array<string>;
+    @Field(() => Date, {nullable:true})
+    equals?: Date | string;
 
-  @Field(() => [Date], { nullable: true })
-  notIn?: Array<Date> | Array<string>;
+    @Field(() => [Date], {nullable:true})
+    in?: Array<Date> | Array<string>;
 
-  @Field(() => Date, { nullable: true })
-  lt?: Date | string;
+    @Field(() => [Date], {nullable:true})
+    notIn?: Array<Date> | Array<string>;
 
-  @Field(() => Date, { nullable: true })
-  lte?: Date | string;
+    @Field(() => Date, {nullable:true})
+    lt?: Date | string;
 
-  @Field(() => Date, { nullable: true })
-  gt?: Date | string;
+    @Field(() => Date, {nullable:true})
+    lte?: Date | string;
 
-  @Field(() => Date, { nullable: true })
-  gte?: Date | string;
+    @Field(() => Date, {nullable:true})
+    gt?: Date | string;
 
-  @Field(() => NestedDateTimeWithAggregatesFilter, { nullable: true })
-  not?: NestedDateTimeWithAggregatesFilter;
+    @Field(() => Date, {nullable:true})
+    gte?: Date | string;
 
-  @Field(() => NestedIntFilter, { nullable: true })
-  _count?: NestedIntFilter;
+    @Field(() => NestedDateTimeWithAggregatesFilter, {nullable:true})
+    not?: NestedDateTimeWithAggregatesFilter;
 
-  @Field(() => NestedDateTimeFilter, { nullable: true })
-  _min?: NestedDateTimeFilter;
+    @Field(() => NestedIntFilter, {nullable:true})
+    _count?: NestedIntFilter;
 
-  @Field(() => NestedDateTimeFilter, { nullable: true })
-  _max?: NestedDateTimeFilter;
+    @Field(() => NestedDateTimeFilter, {nullable:true})
+    _min?: NestedDateTimeFilter;
+
+    @Field(() => NestedDateTimeFilter, {nullable:true})
+    _max?: NestedDateTimeFilter;
 }
diff --git a/@generated/prisma/nested-decimal-filter.input.ts b/@generated/prisma/nested-decimal-filter.input.ts
index a3985721..b840342f 100644
--- a/@generated/prisma/nested-decimal-filter.input.ts
+++ b/@generated/prisma/nested-decimal-filter.input.ts
@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -8,41 +8,42 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class NestedDecimalFilter {
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  equals?: Decimal;
-
-  @Field(() => [GraphQLDecimal], { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  in?: Array<Decimal>;
-
-  @Field(() => [GraphQLDecimal], { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  notIn?: Array<Decimal>;
-
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  lt?: Decimal;
-
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  lte?: Decimal;
-
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  gt?: Decimal;
-
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  gte?: Decimal;
-
-  @Field(() => NestedDecimalFilter, { nullable: true })
-  not?: NestedDecimalFilter;
+
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    equals?: Decimal;
+
+    @Field(() => [GraphQLDecimal], {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    in?: Array<Decimal>;
+
+    @Field(() => [GraphQLDecimal], {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    notIn?: Array<Decimal>;
+
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    lt?: Decimal;
+
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    lte?: Decimal;
+
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    gt?: Decimal;
+
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    gte?: Decimal;
+
+    @Field(() => NestedDecimalFilter, {nullable:true})
+    not?: NestedDecimalFilter;
 }
diff --git a/@generated/prisma/nested-decimal-nullable-filter.input.ts b/@generated/prisma/nested-decimal-nullable-filter.input.ts
index d0d99689..32ee3252 100644
--- a/@generated/prisma/nested-decimal-nullable-filter.input.ts
+++ b/@generated/prisma/nested-decimal-nullable-filter.input.ts
@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -8,41 +8,42 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class NestedDecimalNullableFilter {
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  equals?: Decimal;
-
-  @Field(() => [GraphQLDecimal], { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  in?: Array<Decimal>;
-
-  @Field(() => [GraphQLDecimal], { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  notIn?: Array<Decimal>;
-
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  lt?: Decimal;
-
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  lte?: Decimal;
-
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  gt?: Decimal;
-
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  gte?: Decimal;
-
-  @Field(() => NestedDecimalNullableFilter, { nullable: true })
-  not?: NestedDecimalNullableFilter;
+
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    equals?: Decimal;
+
+    @Field(() => [GraphQLDecimal], {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    in?: Array<Decimal>;
+
+    @Field(() => [GraphQLDecimal], {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    notIn?: Array<Decimal>;
+
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    lt?: Decimal;
+
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    lte?: Decimal;
+
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    gt?: Decimal;
+
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    gte?: Decimal;
+
+    @Field(() => NestedDecimalNullableFilter, {nullable:true})
+    not?: NestedDecimalNullableFilter;
 }
diff --git a/@generated/prisma/nested-decimal-nullable-with-aggregates-filter.input.ts b/@generated/prisma/nested-decimal-nullable-with-aggregates-filter.input.ts
index f6dab3bb..a1d0fef3 100644
--- a/@generated/prisma/nested-decimal-nullable-with-aggregates-filter.input.ts
+++ b/@generated/prisma/nested-decimal-nullable-with-aggregates-filter.input.ts
@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -10,56 +10,57 @@ import { NestedDecimalNullableFilter } from './nested-decimal-nullable-filter.in
 
 @InputType()
 export class NestedDecimalNullableWithAggregatesFilter {
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  equals?: Decimal;
 
-  @Field(() => [GraphQLDecimal], { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  in?: Array<Decimal>;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    equals?: Decimal;
 
-  @Field(() => [GraphQLDecimal], { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  notIn?: Array<Decimal>;
+    @Field(() => [GraphQLDecimal], {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    in?: Array<Decimal>;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  lt?: Decimal;
+    @Field(() => [GraphQLDecimal], {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    notIn?: Array<Decimal>;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  lte?: Decimal;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    lt?: Decimal;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  gt?: Decimal;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    lte?: Decimal;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  gte?: Decimal;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    gt?: Decimal;
 
-  @Field(() => NestedDecimalNullableWithAggregatesFilter, { nullable: true })
-  not?: NestedDecimalNullableWithAggregatesFilter;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    gte?: Decimal;
 
-  @Field(() => NestedIntNullableFilter, { nullable: true })
-  _count?: NestedIntNullableFilter;
+    @Field(() => NestedDecimalNullableWithAggregatesFilter, {nullable:true})
+    not?: NestedDecimalNullableWithAggregatesFilter;
 
-  @Field(() => NestedDecimalNullableFilter, { nullable: true })
-  _avg?: NestedDecimalNullableFilter;
+    @Field(() => NestedIntNullableFilter, {nullable:true})
+    _count?: NestedIntNullableFilter;
 
-  @Field(() => NestedDecimalNullableFilter, { nullable: true })
-  _sum?: NestedDecimalNullableFilter;
+    @Field(() => NestedDecimalNullableFilter, {nullable:true})
+    _avg?: NestedDecimalNullableFilter;
 
-  @Field(() => NestedDecimalNullableFilter, { nullable: true })
-  _min?: NestedDecimalNullableFilter;
+    @Field(() => NestedDecimalNullableFilter, {nullable:true})
+    _sum?: NestedDecimalNullableFilter;
 
-  @Field(() => NestedDecimalNullableFilter, { nullable: true })
-  _max?: NestedDecimalNullableFilter;
+    @Field(() => NestedDecimalNullableFilter, {nullable:true})
+    _min?: NestedDecimalNullableFilter;
+
+    @Field(() => NestedDecimalNullableFilter, {nullable:true})
+    _max?: NestedDecimalNullableFilter;
 }
diff --git a/@generated/prisma/nested-decimal-with-aggregates-filter.input.ts b/@generated/prisma/nested-decimal-with-aggregates-filter.input.ts
index ab40571b..71aa6037 100644
--- a/@generated/prisma/nested-decimal-with-aggregates-filter.input.ts
+++ b/@generated/prisma/nested-decimal-with-aggregates-filter.input.ts
@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -10,56 +10,57 @@ import { NestedDecimalFilter } from './nested-decimal-filter.input';
 
 @InputType()
 export class NestedDecimalWithAggregatesFilter {
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  equals?: Decimal;
 
-  @Field(() => [GraphQLDecimal], { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  in?: Array<Decimal>;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    equals?: Decimal;
 
-  @Field(() => [GraphQLDecimal], { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  notIn?: Array<Decimal>;
+    @Field(() => [GraphQLDecimal], {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    in?: Array<Decimal>;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  lt?: Decimal;
+    @Field(() => [GraphQLDecimal], {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    notIn?: Array<Decimal>;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  lte?: Decimal;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    lt?: Decimal;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  gt?: Decimal;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    lte?: Decimal;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  gte?: Decimal;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    gt?: Decimal;
 
-  @Field(() => NestedDecimalWithAggregatesFilter, { nullable: true })
-  not?: NestedDecimalWithAggregatesFilter;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    gte?: Decimal;
 
-  @Field(() => NestedIntFilter, { nullable: true })
-  _count?: NestedIntFilter;
+    @Field(() => NestedDecimalWithAggregatesFilter, {nullable:true})
+    not?: NestedDecimalWithAggregatesFilter;
 
-  @Field(() => NestedDecimalFilter, { nullable: true })
-  _avg?: NestedDecimalFilter;
+    @Field(() => NestedIntFilter, {nullable:true})
+    _count?: NestedIntFilter;
 
-  @Field(() => NestedDecimalFilter, { nullable: true })
-  _sum?: NestedDecimalFilter;
+    @Field(() => NestedDecimalFilter, {nullable:true})
+    _avg?: NestedDecimalFilter;
 
-  @Field(() => NestedDecimalFilter, { nullable: true })
-  _min?: NestedDecimalFilter;
+    @Field(() => NestedDecimalFilter, {nullable:true})
+    _sum?: NestedDecimalFilter;
 
-  @Field(() => NestedDecimalFilter, { nullable: true })
-  _max?: NestedDecimalFilter;
+    @Field(() => NestedDecimalFilter, {nullable:true})
+    _min?: NestedDecimalFilter;
+
+    @Field(() => NestedDecimalFilter, {nullable:true})
+    _max?: NestedDecimalFilter;
 }
diff --git a/@generated/prisma/nested-enum-role-nullable-filter.input.ts b/@generated/prisma/nested-enum-role-nullable-filter.input.ts
index 183b9790..0a26ab6b 100644
--- a/@generated/prisma/nested-enum-role-nullable-filter.input.ts
+++ b/@generated/prisma/nested-enum-role-nullable-filter.input.ts
@@ -4,15 +4,16 @@ import { Role } from './role.enum';
 
 @InputType()
 export class NestedEnumRoleNullableFilter {
-  @Field(() => Role, { nullable: true })
-  equals?: keyof typeof Role;
 
-  @Field(() => [Role], { nullable: true })
-  in?: Array<keyof typeof Role>;
+    @Field(() => Role, {nullable:true})
+    equals?: keyof typeof Role;
 
-  @Field(() => [Role], { nullable: true })
-  notIn?: Array<keyof typeof Role>;
+    @Field(() => [Role], {nullable:true})
+    in?: Array<keyof typeof Role>;
 
-  @Field(() => NestedEnumRoleNullableFilter, { nullable: true })
-  not?: NestedEnumRoleNullableFilter;
+    @Field(() => [Role], {nullable:true})
+    notIn?: Array<keyof typeof Role>;
+
+    @Field(() => NestedEnumRoleNullableFilter, {nullable:true})
+    not?: NestedEnumRoleNullableFilter;
 }
diff --git a/@generated/prisma/nested-enum-role-nullable-with-aggregates-filter.input.ts b/@generated/prisma/nested-enum-role-nullable-with-aggregates-filter.input.ts
index fdc95423..d35022bd 100644
--- a/@generated/prisma/nested-enum-role-nullable-with-aggregates-filter.input.ts
+++ b/@generated/prisma/nested-enum-role-nullable-with-aggregates-filter.input.ts
@@ -6,24 +6,25 @@ import { NestedEnumRoleNullableFilter } from './nested-enum-role-nullable-filter
 
 @InputType()
 export class NestedEnumRoleNullableWithAggregatesFilter {
-  @Field(() => Role, { nullable: true })
-  equals?: keyof typeof Role;
 
-  @Field(() => [Role], { nullable: true })
-  in?: Array<keyof typeof Role>;
+    @Field(() => Role, {nullable:true})
+    equals?: keyof typeof Role;
 
-  @Field(() => [Role], { nullable: true })
-  notIn?: Array<keyof typeof Role>;
+    @Field(() => [Role], {nullable:true})
+    in?: Array<keyof typeof Role>;
 
-  @Field(() => NestedEnumRoleNullableWithAggregatesFilter, { nullable: true })
-  not?: NestedEnumRoleNullableWithAggregatesFilter;
+    @Field(() => [Role], {nullable:true})
+    notIn?: Array<keyof typeof Role>;
 
-  @Field(() => NestedIntNullableFilter, { nullable: true })
-  _count?: NestedIntNullableFilter;
+    @Field(() => NestedEnumRoleNullableWithAggregatesFilter, {nullable:true})
+    not?: NestedEnumRoleNullableWithAggregatesFilter;
 
-  @Field(() => NestedEnumRoleNullableFilter, { nullable: true })
-  _min?: NestedEnumRoleNullableFilter;
+    @Field(() => NestedIntNullableFilter, {nullable:true})
+    _count?: NestedIntNullableFilter;
 
-  @Field(() => NestedEnumRoleNullableFilter, { nullable: true })
-  _max?: NestedEnumRoleNullableFilter;
+    @Field(() => NestedEnumRoleNullableFilter, {nullable:true})
+    _min?: NestedEnumRoleNullableFilter;
+
+    @Field(() => NestedEnumRoleNullableFilter, {nullable:true})
+    _max?: NestedEnumRoleNullableFilter;
 }
diff --git a/@generated/prisma/nested-float-filter.input.ts b/@generated/prisma/nested-float-filter.input.ts
index bfd27037..2b85a49d 100644
--- a/@generated/prisma/nested-float-filter.input.ts
+++ b/@generated/prisma/nested-float-filter.input.ts
@@ -4,27 +4,28 @@ import { Float } from '@nestjs/graphql';
 
 @InputType()
 export class NestedFloatFilter {
-  @Field(() => Float, { nullable: true })
-  equals?: number;
 
-  @Field(() => [Float], { nullable: true })
-  in?: Array<number>;
+    @Field(() => Float, {nullable:true})
+    equals?: number;
 
-  @Field(() => [Float], { nullable: true })
-  notIn?: Array<number>;
+    @Field(() => [Float], {nullable:true})
+    in?: Array<number>;
 
-  @Field(() => Float, { nullable: true })
-  lt?: number;
+    @Field(() => [Float], {nullable:true})
+    notIn?: Array<number>;
 
-  @Field(() => Float, { nullable: true })
-  lte?: number;
+    @Field(() => Float, {nullable:true})
+    lt?: number;
 
-  @Field(() => Float, { nullable: true })
-  gt?: number;
+    @Field(() => Float, {nullable:true})
+    lte?: number;
 
-  @Field(() => Float, { nullable: true })
-  gte?: number;
+    @Field(() => Float, {nullable:true})
+    gt?: number;
 
-  @Field(() => NestedFloatFilter, { nullable: true })
-  not?: NestedFloatFilter;
+    @Field(() => Float, {nullable:true})
+    gte?: number;
+
+    @Field(() => NestedFloatFilter, {nullable:true})
+    not?: NestedFloatFilter;
 }
diff --git a/@generated/prisma/nested-float-nullable-filter.input.ts b/@generated/prisma/nested-float-nullable-filter.input.ts
index 4855249d..0faf1abd 100644
--- a/@generated/prisma/nested-float-nullable-filter.input.ts
+++ b/@generated/prisma/nested-float-nullable-filter.input.ts
@@ -4,27 +4,28 @@ import { Float } from '@nestjs/graphql';
 
 @InputType()
 export class NestedFloatNullableFilter {
-  @Field(() => Float, { nullable: true })
-  equals?: number;
 
-  @Field(() => [Float], { nullable: true })
-  in?: Array<number>;
+    @Field(() => Float, {nullable:true})
+    equals?: number;
 
-  @Field(() => [Float], { nullable: true })
-  notIn?: Array<number>;
+    @Field(() => [Float], {nullable:true})
+    in?: Array<number>;
 
-  @Field(() => Float, { nullable: true })
-  lt?: number;
+    @Field(() => [Float], {nullable:true})
+    notIn?: Array<number>;
 
-  @Field(() => Float, { nullable: true })
-  lte?: number;
+    @Field(() => Float, {nullable:true})
+    lt?: number;
 
-  @Field(() => Float, { nullable: true })
-  gt?: number;
+    @Field(() => Float, {nullable:true})
+    lte?: number;
 
-  @Field(() => Float, { nullable: true })
-  gte?: number;
+    @Field(() => Float, {nullable:true})
+    gt?: number;
 
-  @Field(() => NestedFloatNullableFilter, { nullable: true })
-  not?: NestedFloatNullableFilter;
+    @Field(() => Float, {nullable:true})
+    gte?: number;
+
+    @Field(() => NestedFloatNullableFilter, {nullable:true})
+    not?: NestedFloatNullableFilter;
 }
diff --git a/@generated/prisma/nested-float-nullable-with-aggregates-filter.input.ts b/@generated/prisma/nested-float-nullable-with-aggregates-filter.input.ts
index 1477e4b6..72f9df3b 100644
--- a/@generated/prisma/nested-float-nullable-with-aggregates-filter.input.ts
+++ b/@generated/prisma/nested-float-nullable-with-aggregates-filter.input.ts
@@ -6,42 +6,43 @@ import { NestedFloatNullableFilter } from './nested-float-nullable-filter.input'
 
 @InputType()
 export class NestedFloatNullableWithAggregatesFilter {
-  @Field(() => Float, { nullable: true })
-  equals?: number;
 
-  @Field(() => [Float], { nullable: true })
-  in?: Array<number>;
+    @Field(() => Float, {nullable:true})
+    equals?: number;
 
-  @Field(() => [Float], { nullable: true })
-  notIn?: Array<number>;
+    @Field(() => [Float], {nullable:true})
+    in?: Array<number>;
 
-  @Field(() => Float, { nullable: true })
-  lt?: number;
+    @Field(() => [Float], {nullable:true})
+    notIn?: Array<number>;
 
-  @Field(() => Float, { nullable: true })
-  lte?: number;
+    @Field(() => Float, {nullable:true})
+    lt?: number;
 
-  @Field(() => Float, { nullable: true })
-  gt?: number;
+    @Field(() => Float, {nullable:true})
+    lte?: number;
 
-  @Field(() => Float, { nullable: true })
-  gte?: number;
+    @Field(() => Float, {nullable:true})
+    gt?: number;
 
-  @Field(() => NestedFloatNullableWithAggregatesFilter, { nullable: true })
-  not?: NestedFloatNullableWithAggregatesFilter;
+    @Field(() => Float, {nullable:true})
+    gte?: number;
 
-  @Field(() => NestedIntNullableFilter, { nullable: true })
-  _count?: NestedIntNullableFilter;
+    @Field(() => NestedFloatNullableWithAggregatesFilter, {nullable:true})
+    not?: NestedFloatNullableWithAggregatesFilter;
 
-  @Field(() => NestedFloatNullableFilter, { nullable: true })
-  _avg?: NestedFloatNullableFilter;
+    @Field(() => NestedIntNullableFilter, {nullable:true})
+    _count?: NestedIntNullableFilter;
 
-  @Field(() => NestedFloatNullableFilter, { nullable: true })
-  _sum?: NestedFloatNullableFilter;
+    @Field(() => NestedFloatNullableFilter, {nullable:true})
+    _avg?: NestedFloatNullableFilter;
 
-  @Field(() => NestedFloatNullableFilter, { nullable: true })
-  _min?: NestedFloatNullableFilter;
+    @Field(() => NestedFloatNullableFilter, {nullable:true})
+    _sum?: NestedFloatNullableFilter;
 
-  @Field(() => NestedFloatNullableFilter, { nullable: true })
-  _max?: NestedFloatNullableFilter;
+    @Field(() => NestedFloatNullableFilter, {nullable:true})
+    _min?: NestedFloatNullableFilter;
+
+    @Field(() => NestedFloatNullableFilter, {nullable:true})
+    _max?: NestedFloatNullableFilter;
 }
diff --git a/@generated/prisma/nested-int-filter.input.ts b/@generated/prisma/nested-int-filter.input.ts
index f5087245..57aafddf 100644
--- a/@generated/prisma/nested-int-filter.input.ts
+++ b/@generated/prisma/nested-int-filter.input.ts
@@ -4,27 +4,28 @@ import { Int } from '@nestjs/graphql';
 
 @InputType()
 export class NestedIntFilter {
-  @Field(() => Int, { nullable: true })
-  equals?: number;
 
-  @Field(() => [Int], { nullable: true })
-  in?: Array<number>;
+    @Field(() => Int, {nullable:true})
+    equals?: number;
 
-  @Field(() => [Int], { nullable: true })
-  notIn?: Array<number>;
+    @Field(() => [Int], {nullable:true})
+    in?: Array<number>;
 
-  @Field(() => Int, { nullable: true })
-  lt?: number;
+    @Field(() => [Int], {nullable:true})
+    notIn?: Array<number>;
 
-  @Field(() => Int, { nullable: true })
-  lte?: number;
+    @Field(() => Int, {nullable:true})
+    lt?: number;
 
-  @Field(() => Int, { nullable: true })
-  gt?: number;
+    @Field(() => Int, {nullable:true})
+    lte?: number;
 
-  @Field(() => Int, { nullable: true })
-  gte?: number;
+    @Field(() => Int, {nullable:true})
+    gt?: number;
 
-  @Field(() => NestedIntFilter, { nullable: true })
-  not?: NestedIntFilter;
+    @Field(() => Int, {nullable:true})
+    gte?: number;
+
+    @Field(() => NestedIntFilter, {nullable:true})
+    not?: NestedIntFilter;
 }
diff --git a/@generated/prisma/nested-int-nullable-filter.input.ts b/@generated/prisma/nested-int-nullable-filter.input.ts
index 6e443105..a16c881d 100644
--- a/@generated/prisma/nested-int-nullable-filter.input.ts
+++ b/@generated/prisma/nested-int-nullable-filter.input.ts
@@ -4,27 +4,28 @@ import { Int } from '@nestjs/graphql';
 
 @InputType()
 export class NestedIntNullableFilter {
-  @Field(() => Int, { nullable: true })
-  equals?: number;
 
-  @Field(() => [Int], { nullable: true })
-  in?: Array<number>;
+    @Field(() => Int, {nullable:true})
+    equals?: number;
 
-  @Field(() => [Int], { nullable: true })
-  notIn?: Array<number>;
+    @Field(() => [Int], {nullable:true})
+    in?: Array<number>;
 
-  @Field(() => Int, { nullable: true })
-  lt?: number;
+    @Field(() => [Int], {nullable:true})
+    notIn?: Array<number>;
 
-  @Field(() => Int, { nullable: true })
-  lte?: number;
+    @Field(() => Int, {nullable:true})
+    lt?: number;
 
-  @Field(() => Int, { nullable: true })
-  gt?: number;
+    @Field(() => Int, {nullable:true})
+    lte?: number;
 
-  @Field(() => Int, { nullable: true })
-  gte?: number;
+    @Field(() => Int, {nullable:true})
+    gt?: number;
 
-  @Field(() => NestedIntNullableFilter, { nullable: true })
-  not?: NestedIntNullableFilter;
+    @Field(() => Int, {nullable:true})
+    gte?: number;
+
+    @Field(() => NestedIntNullableFilter, {nullable:true})
+    not?: NestedIntNullableFilter;
 }
diff --git a/@generated/prisma/nested-int-nullable-with-aggregates-filter.input.ts b/@generated/prisma/nested-int-nullable-with-aggregates-filter.input.ts
index 78e6297a..fc21aeac 100644
--- a/@generated/prisma/nested-int-nullable-with-aggregates-filter.input.ts
+++ b/@generated/prisma/nested-int-nullable-with-aggregates-filter.input.ts
@@ -6,42 +6,43 @@ import { NestedFloatNullableFilter } from './nested-float-nullable-filter.input'
 
 @InputType()
 export class NestedIntNullableWithAggregatesFilter {
-  @Field(() => Int, { nullable: true })
-  equals?: number;
 
-  @Field(() => [Int], { nullable: true })
-  in?: Array<number>;
+    @Field(() => Int, {nullable:true})
+    equals?: number;
 
-  @Field(() => [Int], { nullable: true })
-  notIn?: Array<number>;
+    @Field(() => [Int], {nullable:true})
+    in?: Array<number>;
 
-  @Field(() => Int, { nullable: true })
-  lt?: number;
+    @Field(() => [Int], {nullable:true})
+    notIn?: Array<number>;
 
-  @Field(() => Int, { nullable: true })
-  lte?: number;
+    @Field(() => Int, {nullable:true})
+    lt?: number;
 
-  @Field(() => Int, { nullable: true })
-  gt?: number;
+    @Field(() => Int, {nullable:true})
+    lte?: number;
 
-  @Field(() => Int, { nullable: true })
-  gte?: number;
+    @Field(() => Int, {nullable:true})
+    gt?: number;
 
-  @Field(() => NestedIntNullableWithAggregatesFilter, { nullable: true })
-  not?: NestedIntNullableWithAggregatesFilter;
+    @Field(() => Int, {nullable:true})
+    gte?: number;
 
-  @Field(() => NestedIntNullableFilter, { nullable: true })
-  _count?: NestedIntNullableFilter;
+    @Field(() => NestedIntNullableWithAggregatesFilter, {nullable:true})
+    not?: NestedIntNullableWithAggregatesFilter;
 
-  @Field(() => NestedFloatNullableFilter, { nullable: true })
-  _avg?: NestedFloatNullableFilter;
+    @Field(() => NestedIntNullableFilter, {nullable:true})
+    _count?: NestedIntNullableFilter;
 
-  @Field(() => NestedIntNullableFilter, { nullable: true })
-  _sum?: NestedIntNullableFilter;
+    @Field(() => NestedFloatNullableFilter, {nullable:true})
+    _avg?: NestedFloatNullableFilter;
 
-  @Field(() => NestedIntNullableFilter, { nullable: true })
-  _min?: NestedIntNullableFilter;
+    @Field(() => NestedIntNullableFilter, {nullable:true})
+    _sum?: NestedIntNullableFilter;
 
-  @Field(() => NestedIntNullableFilter, { nullable: true })
-  _max?: NestedIntNullableFilter;
+    @Field(() => NestedIntNullableFilter, {nullable:true})
+    _min?: NestedIntNullableFilter;
+
+    @Field(() => NestedIntNullableFilter, {nullable:true})
+    _max?: NestedIntNullableFilter;
 }
diff --git a/@generated/prisma/nested-int-with-aggregates-filter.input.ts b/@generated/prisma/nested-int-with-aggregates-filter.input.ts
index 65dbc1ee..29bad369 100644
--- a/@generated/prisma/nested-int-with-aggregates-filter.input.ts
+++ b/@generated/prisma/nested-int-with-aggregates-filter.input.ts
@@ -6,42 +6,43 @@ import { NestedFloatFilter } from './nested-float-filter.input';
 
 @InputType()
 export class NestedIntWithAggregatesFilter {
-  @Field(() => Int, { nullable: true })
-  equals?: number;
 
-  @Field(() => [Int], { nullable: true })
-  in?: Array<number>;
+    @Field(() => Int, {nullable:true})
+    equals?: number;
 
-  @Field(() => [Int], { nullable: true })
-  notIn?: Array<number>;
+    @Field(() => [Int], {nullable:true})
+    in?: Array<number>;
 
-  @Field(() => Int, { nullable: true })
-  lt?: number;
+    @Field(() => [Int], {nullable:true})
+    notIn?: Array<number>;
 
-  @Field(() => Int, { nullable: true })
-  lte?: number;
+    @Field(() => Int, {nullable:true})
+    lt?: number;
 
-  @Field(() => Int, { nullable: true })
-  gt?: number;
+    @Field(() => Int, {nullable:true})
+    lte?: number;
 
-  @Field(() => Int, { nullable: true })
-  gte?: number;
+    @Field(() => Int, {nullable:true})
+    gt?: number;
 
-  @Field(() => NestedIntWithAggregatesFilter, { nullable: true })
-  not?: NestedIntWithAggregatesFilter;
+    @Field(() => Int, {nullable:true})
+    gte?: number;
 
-  @Field(() => NestedIntFilter, { nullable: true })
-  _count?: NestedIntFilter;
+    @Field(() => NestedIntWithAggregatesFilter, {nullable:true})
+    not?: NestedIntWithAggregatesFilter;
 
-  @Field(() => NestedFloatFilter, { nullable: true })
-  _avg?: NestedFloatFilter;
+    @Field(() => NestedIntFilter, {nullable:true})
+    _count?: NestedIntFilter;
 
-  @Field(() => NestedIntFilter, { nullable: true })
-  _sum?: NestedIntFilter;
+    @Field(() => NestedFloatFilter, {nullable:true})
+    _avg?: NestedFloatFilter;
 
-  @Field(() => NestedIntFilter, { nullable: true })
-  _min?: NestedIntFilter;
+    @Field(() => NestedIntFilter, {nullable:true})
+    _sum?: NestedIntFilter;
 
-  @Field(() => NestedIntFilter, { nullable: true })
-  _max?: NestedIntFilter;
+    @Field(() => NestedIntFilter, {nullable:true})
+    _min?: NestedIntFilter;
+
+    @Field(() => NestedIntFilter, {nullable:true})
+    _max?: NestedIntFilter;
 }
diff --git a/@generated/prisma/nested-json-nullable-filter.input.ts b/@generated/prisma/nested-json-nullable-filter.input.ts
index d7ad6e79..f03cc42b 100644
--- a/@generated/prisma/nested-json-nullable-filter.input.ts
+++ b/@generated/prisma/nested-json-nullable-filter.input.ts
@@ -4,42 +4,43 @@ import { GraphQLJSON } from 'graphql-type-json';
 
 @InputType()
 export class NestedJsonNullableFilter {
-  @Field(() => GraphQLJSON, { nullable: true })
-  equals?: any;
 
-  @Field(() => [String], { nullable: true })
-  path?: Array<string>;
+    @Field(() => GraphQLJSON, {nullable:true})
+    equals?: any;
 
-  @Field(() => String, { nullable: true })
-  string_contains?: string;
+    @Field(() => [String], {nullable:true})
+    path?: Array<string>;
 
-  @Field(() => String, { nullable: true })
-  string_starts_with?: string;
+    @Field(() => String, {nullable:true})
+    string_contains?: string;
 
-  @Field(() => String, { nullable: true })
-  string_ends_with?: string;
+    @Field(() => String, {nullable:true})
+    string_starts_with?: string;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  array_contains?: any;
+    @Field(() => String, {nullable:true})
+    string_ends_with?: string;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  array_starts_with?: any;
+    @Field(() => GraphQLJSON, {nullable:true})
+    array_contains?: any;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  array_ends_with?: any;
+    @Field(() => GraphQLJSON, {nullable:true})
+    array_starts_with?: any;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  lt?: any;
+    @Field(() => GraphQLJSON, {nullable:true})
+    array_ends_with?: any;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  lte?: any;
+    @Field(() => GraphQLJSON, {nullable:true})
+    lt?: any;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  gt?: any;
+    @Field(() => GraphQLJSON, {nullable:true})
+    lte?: any;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  gte?: any;
+    @Field(() => GraphQLJSON, {nullable:true})
+    gt?: any;
 
-  @Field(() => GraphQLJSON, { nullable: true })
-  not?: any;
+    @Field(() => GraphQLJSON, {nullable:true})
+    gte?: any;
+
+    @Field(() => GraphQLJSON, {nullable:true})
+    not?: any;
 }
diff --git a/@generated/prisma/nested-string-filter.input.ts b/@generated/prisma/nested-string-filter.input.ts
index 3354bb01..5f87c1d2 100644
--- a/@generated/prisma/nested-string-filter.input.ts
+++ b/@generated/prisma/nested-string-filter.input.ts
@@ -3,39 +3,40 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class NestedStringFilter {
-  @Field(() => String, { nullable: true })
-  equals?: string;
 
-  @Field(() => [String], { nullable: true })
-  in?: Array<string>;
+    @Field(() => String, {nullable:true})
+    equals?: string;
 
-  @Field(() => [String], { nullable: true })
-  notIn?: Array<string>;
+    @Field(() => [String], {nullable:true})
+    in?: Array<string>;
 
-  @Field(() => String, { nullable: true })
-  lt?: string;
+    @Field(() => [String], {nullable:true})
+    notIn?: Array<string>;
 
-  @Field(() => String, { nullable: true })
-  lte?: string;
+    @Field(() => String, {nullable:true})
+    lt?: string;
 
-  @Field(() => String, { nullable: true })
-  gt?: string;
+    @Field(() => String, {nullable:true})
+    lte?: string;
 
-  @Field(() => String, { nullable: true })
-  gte?: string;
+    @Field(() => String, {nullable:true})
+    gt?: string;
 
-  @Field(() => String, { nullable: true })
-  contains?: string;
+    @Field(() => String, {nullable:true})
+    gte?: string;
 
-  @Field(() => String, { nullable: true })
-  startsWith?: string;
+    @Field(() => String, {nullable:true})
+    contains?: string;
 
-  @Field(() => String, { nullable: true })
-  endsWith?: string;
+    @Field(() => String, {nullable:true})
+    startsWith?: string;
 
-  @Field(() => String, { nullable: true })
-  search?: string;
+    @Field(() => String, {nullable:true})
+    endsWith?: string;
 
-  @Field(() => NestedStringFilter, { nullable: true })
-  not?: NestedStringFilter;
+    @Field(() => String, {nullable:true})
+    search?: string;
+
+    @Field(() => NestedStringFilter, {nullable:true})
+    not?: NestedStringFilter;
 }
diff --git a/@generated/prisma/nested-string-nullable-filter.input.ts b/@generated/prisma/nested-string-nullable-filter.input.ts
index 7d0b1e59..6b533159 100644
--- a/@generated/prisma/nested-string-nullable-filter.input.ts
+++ b/@generated/prisma/nested-string-nullable-filter.input.ts
@@ -3,39 +3,40 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class NestedStringNullableFilter {
-  @Field(() => String, { nullable: true })
-  equals?: string;
 
-  @Field(() => [String], { nullable: true })
-  in?: Array<string>;
+    @Field(() => String, {nullable:true})
+    equals?: string;
 
-  @Field(() => [String], { nullable: true })
-  notIn?: Array<string>;
+    @Field(() => [String], {nullable:true})
+    in?: Array<string>;
 
-  @Field(() => String, { nullable: true })
-  lt?: string;
+    @Field(() => [String], {nullable:true})
+    notIn?: Array<string>;
 
-  @Field(() => String, { nullable: true })
-  lte?: string;
+    @Field(() => String, {nullable:true})
+    lt?: string;
 
-  @Field(() => String, { nullable: true })
-  gt?: string;
+    @Field(() => String, {nullable:true})
+    lte?: string;
 
-  @Field(() => String, { nullable: true })
-  gte?: string;
+    @Field(() => String, {nullable:true})
+    gt?: string;
 
-  @Field(() => String, { nullable: true })
-  contains?: string;
+    @Field(() => String, {nullable:true})
+    gte?: string;
 
-  @Field(() => String, { nullable: true })
-  startsWith?: string;
+    @Field(() => String, {nullable:true})
+    contains?: string;
 
-  @Field(() => String, { nullable: true })
-  endsWith?: string;
+    @Field(() => String, {nullable:true})
+    startsWith?: string;
 
-  @Field(() => String, { nullable: true })
-  search?: string;
+    @Field(() => String, {nullable:true})
+    endsWith?: string;
 
-  @Field(() => NestedStringNullableFilter, { nullable: true })
-  not?: NestedStringNullableFilter;
+    @Field(() => String, {nullable:true})
+    search?: string;
+
+    @Field(() => NestedStringNullableFilter, {nullable:true})
+    not?: NestedStringNullableFilter;
 }
diff --git a/@generated/prisma/nested-string-nullable-with-aggregates-filter.input.ts b/@generated/prisma/nested-string-nullable-with-aggregates-filter.input.ts
index f4200aa6..08cd3453 100644
--- a/@generated/prisma/nested-string-nullable-with-aggregates-filter.input.ts
+++ b/@generated/prisma/nested-string-nullable-with-aggregates-filter.input.ts
@@ -5,48 +5,49 @@ import { NestedStringNullableFilter } from './nested-string-nullable-filter.inpu
 
 @InputType()
 export class NestedStringNullableWithAggregatesFilter {
-  @Field(() => String, { nullable: true })
-  equals?: string;
 
-  @Field(() => [String], { nullable: true })
-  in?: Array<string>;
+    @Field(() => String, {nullable:true})
+    equals?: string;
 
-  @Field(() => [String], { nullable: true })
-  notIn?: Array<string>;
+    @Field(() => [String], {nullable:true})
+    in?: Array<string>;
 
-  @Field(() => String, { nullable: true })
-  lt?: string;
+    @Field(() => [String], {nullable:true})
+    notIn?: Array<string>;
 
-  @Field(() => String, { nullable: true })
-  lte?: string;
+    @Field(() => String, {nullable:true})
+    lt?: string;
 
-  @Field(() => String, { nullable: true })
-  gt?: string;
+    @Field(() => String, {nullable:true})
+    lte?: string;
 
-  @Field(() => String, { nullable: true })
-  gte?: string;
+    @Field(() => String, {nullable:true})
+    gt?: string;
 
-  @Field(() => String, { nullable: true })
-  contains?: string;
+    @Field(() => String, {nullable:true})
+    gte?: string;
 
-  @Field(() => String, { nullable: true })
-  startsWith?: string;
+    @Field(() => String, {nullable:true})
+    contains?: string;
 
-  @Field(() => String, { nullable: true })
-  endsWith?: string;
+    @Field(() => String, {nullable:true})
+    startsWith?: string;
 
-  @Field(() => String, { nullable: true })
-  search?: string;
+    @Field(() => String, {nullable:true})
+    endsWith?: string;
 
-  @Field(() => NestedStringNullableWithAggregatesFilter, { nullable: true })
-  not?: NestedStringNullableWithAggregatesFilter;
+    @Field(() => String, {nullable:true})
+    search?: string;
 
-  @Field(() => NestedIntNullableFilter, { nullable: true })
-  _count?: NestedIntNullableFilter;
+    @Field(() => NestedStringNullableWithAggregatesFilter, {nullable:true})
+    not?: NestedStringNullableWithAggregatesFilter;
 
-  @Field(() => NestedStringNullableFilter, { nullable: true })
-  _min?: NestedStringNullableFilter;
+    @Field(() => NestedIntNullableFilter, {nullable:true})
+    _count?: NestedIntNullableFilter;
 
-  @Field(() => NestedStringNullableFilter, { nullable: true })
-  _max?: NestedStringNullableFilter;
+    @Field(() => NestedStringNullableFilter, {nullable:true})
+    _min?: NestedStringNullableFilter;
+
+    @Field(() => NestedStringNullableFilter, {nullable:true})
+    _max?: NestedStringNullableFilter;
 }
diff --git a/@generated/prisma/nested-string-with-aggregates-filter.input.ts b/@generated/prisma/nested-string-with-aggregates-filter.input.ts
index 06d9a17f..b144351d 100644
--- a/@generated/prisma/nested-string-with-aggregates-filter.input.ts
+++ b/@generated/prisma/nested-string-with-aggregates-filter.input.ts
@@ -5,48 +5,49 @@ import { NestedStringFilter } from './nested-string-filter.input';
 
 @InputType()
 export class NestedStringWithAggregatesFilter {
-  @Field(() => String, { nullable: true })
-  equals?: string;
 
-  @Field(() => [String], { nullable: true })
-  in?: Array<string>;
+    @Field(() => String, {nullable:true})
+    equals?: string;
 
-  @Field(() => [String], { nullable: true })
-  notIn?: Array<string>;
+    @Field(() => [String], {nullable:true})
+    in?: Array<string>;
 
-  @Field(() => String, { nullable: true })
-  lt?: string;
+    @Field(() => [String], {nullable:true})
+    notIn?: Array<string>;
 
-  @Field(() => String, { nullable: true })
-  lte?: string;
+    @Field(() => String, {nullable:true})
+    lt?: string;
 
-  @Field(() => String, { nullable: true })
-  gt?: string;
+    @Field(() => String, {nullable:true})
+    lte?: string;
 
-  @Field(() => String, { nullable: true })
-  gte?: string;
+    @Field(() => String, {nullable:true})
+    gt?: string;
 
-  @Field(() => String, { nullable: true })
-  contains?: string;
+    @Field(() => String, {nullable:true})
+    gte?: string;
 
-  @Field(() => String, { nullable: true })
-  startsWith?: string;
+    @Field(() => String, {nullable:true})
+    contains?: string;
 
-  @Field(() => String, { nullable: true })
-  endsWith?: string;
+    @Field(() => String, {nullable:true})
+    startsWith?: string;
 
-  @Field(() => String, { nullable: true })
-  search?: string;
+    @Field(() => String, {nullable:true})
+    endsWith?: string;
 
-  @Field(() => NestedStringWithAggregatesFilter, { nullable: true })
-  not?: NestedStringWithAggregatesFilter;
+    @Field(() => String, {nullable:true})
+    search?: string;
 
-  @Field(() => NestedIntFilter, { nullable: true })
-  _count?: NestedIntFilter;
+    @Field(() => NestedStringWithAggregatesFilter, {nullable:true})
+    not?: NestedStringWithAggregatesFilter;
 
-  @Field(() => NestedStringFilter, { nullable: true })
-  _min?: NestedStringFilter;
+    @Field(() => NestedIntFilter, {nullable:true})
+    _count?: NestedIntFilter;
 
-  @Field(() => NestedStringFilter, { nullable: true })
-  _max?: NestedStringFilter;
+    @Field(() => NestedStringFilter, {nullable:true})
+    _min?: NestedStringFilter;
+
+    @Field(() => NestedStringFilter, {nullable:true})
+    _max?: NestedStringFilter;
 }
diff --git a/@generated/prisma/nullable-big-int-field-update-operations.input.ts b/@generated/prisma/nullable-big-int-field-update-operations.input.ts
index 2877a5b7..481dbafe 100644
--- a/@generated/prisma/nullable-big-int-field-update-operations.input.ts
+++ b/@generated/prisma/nullable-big-int-field-update-operations.input.ts
@@ -3,18 +3,19 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class NullableBigIntFieldUpdateOperationsInput {
-  @Field(() => String, { nullable: true })
-  set?: bigint | number;
 
-  @Field(() => String, { nullable: true })
-  increment?: bigint | number;
+    @Field(() => String, {nullable:true})
+    set?: bigint | number;
 
-  @Field(() => String, { nullable: true })
-  decrement?: bigint | number;
+    @Field(() => String, {nullable:true})
+    increment?: bigint | number;
 
-  @Field(() => String, { nullable: true })
-  multiply?: bigint | number;
+    @Field(() => String, {nullable:true})
+    decrement?: bigint | number;
 
-  @Field(() => String, { nullable: true })
-  divide?: bigint | number;
+    @Field(() => String, {nullable:true})
+    multiply?: bigint | number;
+
+    @Field(() => String, {nullable:true})
+    divide?: bigint | number;
 }
diff --git a/@generated/prisma/nullable-bool-field-update-operations.input.ts b/@generated/prisma/nullable-bool-field-update-operations.input.ts
index f7323244..2768725d 100644
--- a/@generated/prisma/nullable-bool-field-update-operations.input.ts
+++ b/@generated/prisma/nullable-bool-field-update-operations.input.ts
@@ -3,6 +3,7 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class NullableBoolFieldUpdateOperationsInput {
-  @Field(() => Boolean, { nullable: true })
-  set?: boolean;
+
+    @Field(() => Boolean, {nullable:true})
+    set?: boolean;
 }
diff --git a/@generated/prisma/nullable-bytes-field-update-operations.input.ts b/@generated/prisma/nullable-bytes-field-update-operations.input.ts
index a8e49622..8d0ed10e 100644
--- a/@generated/prisma/nullable-bytes-field-update-operations.input.ts
+++ b/@generated/prisma/nullable-bytes-field-update-operations.input.ts
@@ -3,6 +3,7 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class NullableBytesFieldUpdateOperationsInput {
-  @Field(() => String, { nullable: true })
-  set?: Buffer;
+
+    @Field(() => String, {nullable:true})
+    set?: Buffer;
 }
diff --git a/@generated/prisma/nullable-date-time-field-update-operations.input.ts b/@generated/prisma/nullable-date-time-field-update-operations.input.ts
index 1ddc0b00..a3c47a9f 100644
--- a/@generated/prisma/nullable-date-time-field-update-operations.input.ts
+++ b/@generated/prisma/nullable-date-time-field-update-operations.input.ts
@@ -3,6 +3,7 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class NullableDateTimeFieldUpdateOperationsInput {
-  @Field(() => Date, { nullable: true })
-  set?: Date | string;
+
+    @Field(() => Date, {nullable:true})
+    set?: Date | string;
 }
diff --git a/@generated/prisma/nullable-decimal-field-update-operations.input.ts b/@generated/prisma/nullable-decimal-field-update-operations.input.ts
index 46227a9e..98f0919a 100644
--- a/@generated/prisma/nullable-decimal-field-update-operations.input.ts
+++ b/@generated/prisma/nullable-decimal-field-update-operations.input.ts
@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -8,28 +8,29 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class NullableDecimalFieldUpdateOperationsInput {
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  set?: Decimal;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  increment?: Decimal;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    set?: Decimal;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  decrement?: Decimal;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    increment?: Decimal;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  multiply?: Decimal;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    decrement?: Decimal;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  divide?: Decimal;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    multiply?: Decimal;
+
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    divide?: Decimal;
 }
diff --git a/@generated/prisma/nullable-enum-role-field-update-operations.input.ts b/@generated/prisma/nullable-enum-role-field-update-operations.input.ts
index cbde6c52..b1be46e5 100644
--- a/@generated/prisma/nullable-enum-role-field-update-operations.input.ts
+++ b/@generated/prisma/nullable-enum-role-field-update-operations.input.ts
@@ -4,6 +4,7 @@ import { Role } from './role.enum';
 
 @InputType()
 export class NullableEnumRoleFieldUpdateOperationsInput {
-  @Field(() => Role, { nullable: true })
-  set?: keyof typeof Role;
+
+    @Field(() => Role, {nullable:true})
+    set?: keyof typeof Role;
 }
diff --git a/@generated/prisma/nullable-float-field-update-operations.input.ts b/@generated/prisma/nullable-float-field-update-operations.input.ts
index 038a2902..b22f5910 100644
--- a/@generated/prisma/nullable-float-field-update-operations.input.ts
+++ b/@generated/prisma/nullable-float-field-update-operations.input.ts
@@ -4,18 +4,19 @@ import { Float } from '@nestjs/graphql';
 
 @InputType()
 export class NullableFloatFieldUpdateOperationsInput {
-  @Field(() => Float, { nullable: true })
-  set?: number;
 
-  @Field(() => Float, { nullable: true })
-  increment?: number;
+    @Field(() => Float, {nullable:true})
+    set?: number;
 
-  @Field(() => Float, { nullable: true })
-  decrement?: number;
+    @Field(() => Float, {nullable:true})
+    increment?: number;
 
-  @Field(() => Float, { nullable: true })
-  multiply?: number;
+    @Field(() => Float, {nullable:true})
+    decrement?: number;
 
-  @Field(() => Float, { nullable: true })
-  divide?: number;
+    @Field(() => Float, {nullable:true})
+    multiply?: number;
+
+    @Field(() => Float, {nullable:true})
+    divide?: number;
 }
diff --git a/@generated/prisma/nullable-int-field-update-operations.input.ts b/@generated/prisma/nullable-int-field-update-operations.input.ts
index 81e6e472..6f8f3939 100644
--- a/@generated/prisma/nullable-int-field-update-operations.input.ts
+++ b/@generated/prisma/nullable-int-field-update-operations.input.ts
@@ -4,18 +4,19 @@ import { Int } from '@nestjs/graphql';
 
 @InputType()
 export class NullableIntFieldUpdateOperationsInput {
-  @Field(() => Int, { nullable: true })
-  set?: number;
 
-  @Field(() => Int, { nullable: true })
-  increment?: number;
+    @Field(() => Int, {nullable:true})
+    set?: number;
 
-  @Field(() => Int, { nullable: true })
-  decrement?: number;
+    @Field(() => Int, {nullable:true})
+    increment?: number;
 
-  @Field(() => Int, { nullable: true })
-  multiply?: number;
+    @Field(() => Int, {nullable:true})
+    decrement?: number;
 
-  @Field(() => Int, { nullable: true })
-  divide?: number;
+    @Field(() => Int, {nullable:true})
+    multiply?: number;
+
+    @Field(() => Int, {nullable:true})
+    divide?: number;
 }
diff --git a/@generated/prisma/nullable-json-null-value-input.enum.ts b/@generated/prisma/nullable-json-null-value-input.enum.ts
index 5e7fc475..a4144ec5 100644
--- a/@generated/prisma/nullable-json-null-value-input.enum.ts
+++ b/@generated/prisma/nullable-json-null-value-input.enum.ts
@@ -1,11 +1,9 @@
 import { registerEnumType } from '@nestjs/graphql';
 
 export enum NullableJsonNullValueInput {
-  DbNull = 'DbNull',
-  JsonNull = 'JsonNull',
+    DbNull = "DbNull",
+    JsonNull = "JsonNull"
 }
 
-registerEnumType(NullableJsonNullValueInput, {
-  name: 'NullableJsonNullValueInput',
-  description: undefined,
-});
+
+registerEnumType(NullableJsonNullValueInput, { name: 'NullableJsonNullValueInput', description: undefined })
diff --git a/@generated/prisma/nullable-string-field-update-operations.input.ts b/@generated/prisma/nullable-string-field-update-operations.input.ts
index 02bf7208..c956508b 100644
--- a/@generated/prisma/nullable-string-field-update-operations.input.ts
+++ b/@generated/prisma/nullable-string-field-update-operations.input.ts
@@ -3,6 +3,7 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class NullableStringFieldUpdateOperationsInput {
-  @Field(() => String, { nullable: true })
-  set?: string;
+
+    @Field(() => String, {nullable:true})
+    set?: string;
 }
diff --git a/@generated/prisma/nulls-order.enum.ts b/@generated/prisma/nulls-order.enum.ts
index 05898905..ca5e591b 100644
--- a/@generated/prisma/nulls-order.enum.ts
+++ b/@generated/prisma/nulls-order.enum.ts
@@ -1,8 +1,9 @@
 import { registerEnumType } from '@nestjs/graphql';
 
 export enum NullsOrder {
-  first = 'first',
-  last = 'last',
+    first = "first",
+    last = "last"
 }
 
-registerEnumType(NullsOrder, { name: 'NullsOrder', description: undefined });
+
+registerEnumType(NullsOrder, { name: 'NullsOrder', description: undefined })
diff --git a/@generated/prisma/query-mode.enum.ts b/@generated/prisma/query-mode.enum.ts
index 07c08d7b..bf260c80 100644
--- a/@generated/prisma/query-mode.enum.ts
+++ b/@generated/prisma/query-mode.enum.ts
@@ -1,8 +1,9 @@
 import { registerEnumType } from '@nestjs/graphql';
 
 export enum QueryMode {
-  'default' = 'default',
-  insensitive = 'insensitive',
+    'default' = "default",
+    insensitive = "insensitive"
 }
 
-registerEnumType(QueryMode, { name: 'QueryMode', description: undefined });
+
+registerEnumType(QueryMode, { name: 'QueryMode', description: undefined })
diff --git a/@generated/prisma/role.enum.ts b/@generated/prisma/role.enum.ts
index 61292c71..6e94cf71 100644
--- a/@generated/prisma/role.enum.ts
+++ b/@generated/prisma/role.enum.ts
@@ -1,7 +1,8 @@
 import { registerEnumType } from '@nestjs/graphql';
 
 export enum Role {
-  USER = 'USER',
+    USER = "USER"
 }
 
-registerEnumType(Role, { name: 'Role', description: undefined });
+
+registerEnumType(Role, { name: 'Role', description: undefined })
diff --git a/@generated/prisma/sort-order.enum.ts b/@generated/prisma/sort-order.enum.ts
index 6e8160a8..caeff7d9 100644
--- a/@generated/prisma/sort-order.enum.ts
+++ b/@generated/prisma/sort-order.enum.ts
@@ -1,8 +1,9 @@
 import { registerEnumType } from '@nestjs/graphql';
 
 export enum SortOrder {
-  asc = 'asc',
-  desc = 'desc',
+    asc = "asc",
+    desc = "desc"
 }
 
-registerEnumType(SortOrder, { name: 'SortOrder', description: undefined });
+
+registerEnumType(SortOrder, { name: 'SortOrder', description: undefined })
diff --git a/@generated/prisma/sort-order.input.ts b/@generated/prisma/sort-order.input.ts
index e818fd1f..b38671ca 100644
--- a/@generated/prisma/sort-order.input.ts
+++ b/@generated/prisma/sort-order.input.ts
@@ -5,9 +5,10 @@ import { NullsOrder } from './nulls-order.enum';
 
 @InputType()
 export class SortOrderInput {
-  @Field(() => SortOrder, { nullable: false })
-  sort!: keyof typeof SortOrder;
 
-  @Field(() => NullsOrder, { nullable: true })
-  nulls?: keyof typeof NullsOrder;
+    @Field(() => SortOrder, {nullable:false})
+    sort!: keyof typeof SortOrder;
+
+    @Field(() => NullsOrder, {nullable:true})
+    nulls?: keyof typeof NullsOrder;
 }
diff --git a/@generated/prisma/string-field-update-operations.input.ts b/@generated/prisma/string-field-update-operations.input.ts
index 63612bb9..002169f7 100644
--- a/@generated/prisma/string-field-update-operations.input.ts
+++ b/@generated/prisma/string-field-update-operations.input.ts
@@ -3,6 +3,7 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class StringFieldUpdateOperationsInput {
-  @Field(() => String, { nullable: true })
-  set?: string;
+
+    @Field(() => String, {nullable:true})
+    set?: string;
 }
diff --git a/@generated/prisma/string-filter.input.ts b/@generated/prisma/string-filter.input.ts
index 856288b5..241b684f 100644
--- a/@generated/prisma/string-filter.input.ts
+++ b/@generated/prisma/string-filter.input.ts
@@ -5,42 +5,43 @@ import { NestedStringFilter } from './nested-string-filter.input';
 
 @InputType()
 export class StringFilter {
-  @Field(() => String, { nullable: true })
-  equals?: string;
 
-  @Field(() => [String], { nullable: true })
-  in?: Array<string>;
+    @Field(() => String, {nullable:true})
+    equals?: string;
 
-  @Field(() => [String], { nullable: true })
-  notIn?: Array<string>;
+    @Field(() => [String], {nullable:true})
+    in?: Array<string>;
 
-  @Field(() => String, { nullable: true })
-  lt?: string;
+    @Field(() => [String], {nullable:true})
+    notIn?: Array<string>;
 
-  @Field(() => String, { nullable: true })
-  lte?: string;
+    @Field(() => String, {nullable:true})
+    lt?: string;
 
-  @Field(() => String, { nullable: true })
-  gt?: string;
+    @Field(() => String, {nullable:true})
+    lte?: string;
 
-  @Field(() => String, { nullable: true })
-  gte?: string;
+    @Field(() => String, {nullable:true})
+    gt?: string;
 
-  @Field(() => String, { nullable: true })
-  contains?: string;
+    @Field(() => String, {nullable:true})
+    gte?: string;
 
-  @Field(() => String, { nullable: true })
-  startsWith?: string;
+    @Field(() => String, {nullable:true})
+    contains?: string;
 
-  @Field(() => String, { nullable: true })
-  endsWith?: string;
+    @Field(() => String, {nullable:true})
+    startsWith?: string;
 
-  @Field(() => String, { nullable: true })
-  search?: string;
+    @Field(() => String, {nullable:true})
+    endsWith?: string;
 
-  @Field(() => QueryMode, { nullable: true })
-  mode?: keyof typeof QueryMode;
+    @Field(() => String, {nullable:true})
+    search?: string;
 
-  @Field(() => NestedStringFilter, { nullable: true })
-  not?: NestedStringFilter;
+    @Field(() => QueryMode, {nullable:true})
+    mode?: keyof typeof QueryMode;
+
+    @Field(() => NestedStringFilter, {nullable:true})
+    not?: NestedStringFilter;
 }
diff --git a/@generated/prisma/string-nullable-filter.input.ts b/@generated/prisma/string-nullable-filter.input.ts
index eba704ff..2d616e5b 100644
--- a/@generated/prisma/string-nullable-filter.input.ts
+++ b/@generated/prisma/string-nullable-filter.input.ts
@@ -5,42 +5,43 @@ import { NestedStringNullableFilter } from './nested-string-nullable-filter.inpu
 
 @InputType()
 export class StringNullableFilter {
-  @Field(() => String, { nullable: true })
-  equals?: string;
 
-  @Field(() => [String], { nullable: true })
-  in?: Array<string>;
+    @Field(() => String, {nullable:true})
+    equals?: string;
 
-  @Field(() => [String], { nullable: true })
-  notIn?: Array<string>;
+    @Field(() => [String], {nullable:true})
+    in?: Array<string>;
 
-  @Field(() => String, { nullable: true })
-  lt?: string;
+    @Field(() => [String], {nullable:true})
+    notIn?: Array<string>;
 
-  @Field(() => String, { nullable: true })
-  lte?: string;
+    @Field(() => String, {nullable:true})
+    lt?: string;
 
-  @Field(() => String, { nullable: true })
-  gt?: string;
+    @Field(() => String, {nullable:true})
+    lte?: string;
 
-  @Field(() => String, { nullable: true })
-  gte?: string;
+    @Field(() => String, {nullable:true})
+    gt?: string;
 
-  @Field(() => String, { nullable: true })
-  contains?: string;
+    @Field(() => String, {nullable:true})
+    gte?: string;
 
-  @Field(() => String, { nullable: true })
-  startsWith?: string;
+    @Field(() => String, {nullable:true})
+    contains?: string;
 
-  @Field(() => String, { nullable: true })
-  endsWith?: string;
+    @Field(() => String, {nullable:true})
+    startsWith?: string;
 
-  @Field(() => String, { nullable: true })
-  search?: string;
+    @Field(() => String, {nullable:true})
+    endsWith?: string;
 
-  @Field(() => QueryMode, { nullable: true })
-  mode?: keyof typeof QueryMode;
+    @Field(() => String, {nullable:true})
+    search?: string;
 
-  @Field(() => NestedStringNullableFilter, { nullable: true })
-  not?: NestedStringNullableFilter;
+    @Field(() => QueryMode, {nullable:true})
+    mode?: keyof typeof QueryMode;
+
+    @Field(() => NestedStringNullableFilter, {nullable:true})
+    not?: NestedStringNullableFilter;
 }
diff --git a/@generated/prisma/string-nullable-list-filter.input.ts b/@generated/prisma/string-nullable-list-filter.input.ts
index 3e483d4e..b87ee8c0 100644
--- a/@generated/prisma/string-nullable-list-filter.input.ts
+++ b/@generated/prisma/string-nullable-list-filter.input.ts
@@ -3,18 +3,19 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class StringNullableListFilter {
-  @Field(() => [String], { nullable: true })
-  equals?: Array<string>;
 
-  @Field(() => String, { nullable: true })
-  has?: string;
+    @Field(() => [String], {nullable:true})
+    equals?: Array<string>;
 
-  @Field(() => [String], { nullable: true })
-  hasEvery?: Array<string>;
+    @Field(() => String, {nullable:true})
+    has?: string;
 
-  @Field(() => [String], { nullable: true })
-  hasSome?: Array<string>;
+    @Field(() => [String], {nullable:true})
+    hasEvery?: Array<string>;
 
-  @Field(() => Boolean, { nullable: true })
-  isEmpty?: boolean;
+    @Field(() => [String], {nullable:true})
+    hasSome?: Array<string>;
+
+    @Field(() => Boolean, {nullable:true})
+    isEmpty?: boolean;
 }
diff --git a/@generated/prisma/string-nullable-with-aggregates-filter.input.ts b/@generated/prisma/string-nullable-with-aggregates-filter.input.ts
index 5553e9ca..02fff977 100644
--- a/@generated/prisma/string-nullable-with-aggregates-filter.input.ts
+++ b/@generated/prisma/string-nullable-with-aggregates-filter.input.ts
@@ -7,51 +7,52 @@ import { NestedStringNullableFilter } from './nested-string-nullable-filter.inpu
 
 @InputType()
 export class StringNullableWithAggregatesFilter {
-  @Field(() => String, { nullable: true })
-  equals?: string;
 
-  @Field(() => [String], { nullable: true })
-  in?: Array<string>;
+    @Field(() => String, {nullable:true})
+    equals?: string;
 
-  @Field(() => [String], { nullable: true })
-  notIn?: Array<string>;
+    @Field(() => [String], {nullable:true})
+    in?: Array<string>;
 
-  @Field(() => String, { nullable: true })
-  lt?: string;
+    @Field(() => [String], {nullable:true})
+    notIn?: Array<string>;
 
-  @Field(() => String, { nullable: true })
-  lte?: string;
+    @Field(() => String, {nullable:true})
+    lt?: string;
 
-  @Field(() => String, { nullable: true })
-  gt?: string;
+    @Field(() => String, {nullable:true})
+    lte?: string;
 
-  @Field(() => String, { nullable: true })
-  gte?: string;
+    @Field(() => String, {nullable:true})
+    gt?: string;
 
-  @Field(() => String, { nullable: true })
-  contains?: string;
+    @Field(() => String, {nullable:true})
+    gte?: string;
 
-  @Field(() => String, { nullable: true })
-  startsWith?: string;
+    @Field(() => String, {nullable:true})
+    contains?: string;
 
-  @Field(() => String, { nullable: true })
-  endsWith?: string;
+    @Field(() => String, {nullable:true})
+    startsWith?: string;
 
-  @Field(() => String, { nullable: true })
-  search?: string;
+    @Field(() => String, {nullable:true})
+    endsWith?: string;
 
-  @Field(() => QueryMode, { nullable: true })
-  mode?: keyof typeof QueryMode;
+    @Field(() => String, {nullable:true})
+    search?: string;
 
-  @Field(() => NestedStringNullableWithAggregatesFilter, { nullable: true })
-  not?: NestedStringNullableWithAggregatesFilter;
+    @Field(() => QueryMode, {nullable:true})
+    mode?: keyof typeof QueryMode;
 
-  @Field(() => NestedIntNullableFilter, { nullable: true })
-  _count?: NestedIntNullableFilter;
+    @Field(() => NestedStringNullableWithAggregatesFilter, {nullable:true})
+    not?: NestedStringNullableWithAggregatesFilter;
 
-  @Field(() => NestedStringNullableFilter, { nullable: true })
-  _min?: NestedStringNullableFilter;
+    @Field(() => NestedIntNullableFilter, {nullable:true})
+    _count?: NestedIntNullableFilter;
 
-  @Field(() => NestedStringNullableFilter, { nullable: true })
-  _max?: NestedStringNullableFilter;
+    @Field(() => NestedStringNullableFilter, {nullable:true})
+    _min?: NestedStringNullableFilter;
+
+    @Field(() => NestedStringNullableFilter, {nullable:true})
+    _max?: NestedStringNullableFilter;
 }
diff --git a/@generated/prisma/string-with-aggregates-filter.input.ts b/@generated/prisma/string-with-aggregates-filter.input.ts
index e5b67a42..2a56a764 100644
--- a/@generated/prisma/string-with-aggregates-filter.input.ts
+++ b/@generated/prisma/string-with-aggregates-filter.input.ts
@@ -7,51 +7,52 @@ import { NestedStringFilter } from './nested-string-filter.input';
 
 @InputType()
 export class StringWithAggregatesFilter {
-  @Field(() => String, { nullable: true })
-  equals?: string;
 
-  @Field(() => [String], { nullable: true })
-  in?: Array<string>;
+    @Field(() => String, {nullable:true})
+    equals?: string;
 
-  @Field(() => [String], { nullable: true })
-  notIn?: Array<string>;
+    @Field(() => [String], {nullable:true})
+    in?: Array<string>;
 
-  @Field(() => String, { nullable: true })
-  lt?: string;
+    @Field(() => [String], {nullable:true})
+    notIn?: Array<string>;
 
-  @Field(() => String, { nullable: true })
-  lte?: string;
+    @Field(() => String, {nullable:true})
+    lt?: string;
 
-  @Field(() => String, { nullable: true })
-  gt?: string;
+    @Field(() => String, {nullable:true})
+    lte?: string;
 
-  @Field(() => String, { nullable: true })
-  gte?: string;
+    @Field(() => String, {nullable:true})
+    gt?: string;
 
-  @Field(() => String, { nullable: true })
-  contains?: string;
+    @Field(() => String, {nullable:true})
+    gte?: string;
 
-  @Field(() => String, { nullable: true })
-  startsWith?: string;
+    @Field(() => String, {nullable:true})
+    contains?: string;
 
-  @Field(() => String, { nullable: true })
-  endsWith?: string;
+    @Field(() => String, {nullable:true})
+    startsWith?: string;
 
-  @Field(() => String, { nullable: true })
-  search?: string;
+    @Field(() => String, {nullable:true})
+    endsWith?: string;
 
-  @Field(() => QueryMode, { nullable: true })
-  mode?: keyof typeof QueryMode;
+    @Field(() => String, {nullable:true})
+    search?: string;
 
-  @Field(() => NestedStringWithAggregatesFilter, { nullable: true })
-  not?: NestedStringWithAggregatesFilter;
+    @Field(() => QueryMode, {nullable:true})
+    mode?: keyof typeof QueryMode;
 
-  @Field(() => NestedIntFilter, { nullable: true })
-  _count?: NestedIntFilter;
+    @Field(() => NestedStringWithAggregatesFilter, {nullable:true})
+    not?: NestedStringWithAggregatesFilter;
 
-  @Field(() => NestedStringFilter, { nullable: true })
-  _min?: NestedStringFilter;
+    @Field(() => NestedIntFilter, {nullable:true})
+    _count?: NestedIntFilter;
 
-  @Field(() => NestedStringFilter, { nullable: true })
-  _max?: NestedStringFilter;
+    @Field(() => NestedStringFilter, {nullable:true})
+    _min?: NestedStringFilter;
+
+    @Field(() => NestedStringFilter, {nullable:true})
+    _max?: NestedStringFilter;
 }
diff --git a/@generated/prisma/transaction-isolation-level.enum.ts b/@generated/prisma/transaction-isolation-level.enum.ts
index 481d17be..f9e39c22 100644
--- a/@generated/prisma/transaction-isolation-level.enum.ts
+++ b/@generated/prisma/transaction-isolation-level.enum.ts
@@ -1,13 +1,11 @@
 import { registerEnumType } from '@nestjs/graphql';
 
 export enum TransactionIsolationLevel {
-  ReadUncommitted = 'ReadUncommitted',
-  ReadCommitted = 'ReadCommitted',
-  RepeatableRead = 'RepeatableRead',
-  Serializable = 'Serializable',
+    ReadUncommitted = "ReadUncommitted",
+    ReadCommitted = "ReadCommitted",
+    RepeatableRead = "RepeatableRead",
+    Serializable = "Serializable"
 }
 
-registerEnumType(TransactionIsolationLevel, {
-  name: 'TransactionIsolationLevel',
-  description: undefined,
-});
+
+registerEnumType(TransactionIsolationLevel, { name: 'TransactionIsolationLevel', description: undefined })
diff --git a/@generated/profile/aggregate-profile.output.ts b/@generated/profile/aggregate-profile.output.ts
index 02059bca..dbb4efc8 100644
--- a/@generated/profile/aggregate-profile.output.ts
+++ b/@generated/profile/aggregate-profile.output.ts
@@ -8,18 +8,19 @@ import { ProfileMaxAggregate } from './profile-max-aggregate.output';
 
 @ObjectType()
 export class AggregateProfile {
-  @Field(() => ProfileCountAggregate, { nullable: true })
-  _count?: ProfileCountAggregate;
 
-  @Field(() => ProfileAvgAggregate, { nullable: true })
-  _avg?: ProfileAvgAggregate;
+    @Field(() => ProfileCountAggregate, {nullable:true})
+    _count?: ProfileCountAggregate;
 
-  @Field(() => ProfileSumAggregate, { nullable: true })
-  _sum?: ProfileSumAggregate;
+    @Field(() => ProfileAvgAggregate, {nullable:true})
+    _avg?: ProfileAvgAggregate;
 
-  @Field(() => ProfileMinAggregate, { nullable: true })
-  _min?: ProfileMinAggregate;
+    @Field(() => ProfileSumAggregate, {nullable:true})
+    _sum?: ProfileSumAggregate;
 
-  @Field(() => ProfileMaxAggregate, { nullable: true })
-  _max?: ProfileMaxAggregate;
+    @Field(() => ProfileMinAggregate, {nullable:true})
+    _min?: ProfileMinAggregate;
+
+    @Field(() => ProfileMaxAggregate, {nullable:true})
+    _max?: ProfileMaxAggregate;
 }
diff --git a/@generated/profile/create-many-profile.args.ts b/@generated/profile/create-many-profile.args.ts
index a6433861..2d264e7a 100644
--- a/@generated/profile/create-many-profile.args.ts
+++ b/@generated/profile/create-many-profile.args.ts
@@ -5,10 +5,11 @@ import { Type } from 'class-transformer';
 
 @ArgsType()
 export class CreateManyProfileArgs {
-  @Field(() => [ProfileCreateManyInput], { nullable: false })
-  @Type(() => ProfileCreateManyInput)
-  data!: Array<ProfileCreateManyInput>;
 
-  @Field(() => Boolean, { nullable: true })
-  skipDuplicates?: boolean;
+    @Field(() => [ProfileCreateManyInput], {nullable:false})
+    @Type(() => ProfileCreateManyInput)
+    data!: Array<ProfileCreateManyInput>;
+
+    @Field(() => Boolean, {nullable:true})
+    skipDuplicates?: boolean;
 }
diff --git a/@generated/profile/create-one-profile.args.ts b/@generated/profile/create-one-profile.args.ts
index e7c0c967..8b23121f 100644
--- a/@generated/profile/create-one-profile.args.ts
+++ b/@generated/profile/create-one-profile.args.ts
@@ -5,7 +5,8 @@ import { Type } from 'class-transformer';
 
 @ArgsType()
 export class CreateOneProfileArgs {
-  @Field(() => ProfileCreateInput, { nullable: false })
-  @Type(() => ProfileCreateInput)
-  data!: ProfileCreateInput;
+
+    @Field(() => ProfileCreateInput, {nullable:false})
+    @Type(() => ProfileCreateInput)
+    data!: ProfileCreateInput;
 }
diff --git a/@generated/profile/delete-many-profile.args.ts b/@generated/profile/delete-many-profile.args.ts
index e9de7e44..869c04f7 100644
--- a/@generated/profile/delete-many-profile.args.ts
+++ b/@generated/profile/delete-many-profile.args.ts
@@ -5,7 +5,8 @@ import { Type } from 'class-transformer';
 
 @ArgsType()
 export class DeleteManyProfileArgs {
-  @Field(() => ProfileWhereInput, { nullable: true })
-  @Type(() => ProfileWhereInput)
-  where?: ProfileWhereInput;
+
+    @Field(() => ProfileWhereInput, {nullable:true})
+    @Type(() => ProfileWhereInput)
+    where?: ProfileWhereInput;
 }
diff --git a/@generated/profile/delete-one-profile.args.ts b/@generated/profile/delete-one-profile.args.ts
index df967411..d122e9c7 100644
--- a/@generated/profile/delete-one-profile.args.ts
+++ b/@generated/profile/delete-one-profile.args.ts
@@ -1,12 +1,13 @@
 import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ProfileWhereUniqueInput } from './profile-where-unique.input';
 import { Type } from 'class-transformer';
 
 @ArgsType()
 export class DeleteOneProfileArgs {
-  @Field(() => ProfileWhereUniqueInput, { nullable: false })
-  @Type(() => ProfileWhereUniqueInput)
-  where!: Prisma.AtLeast<ProfileWhereUniqueInput, 'id' | 'userId'>;
+
+    @Field(() => ProfileWhereUniqueInput, {nullable:false})
+    @Type(() => ProfileWhereUniqueInput)
+    where!: Prisma.AtLeast<ProfileWhereUniqueInput, 'id' | 'userId'>;
 }
diff --git a/@generated/profile/find-first-profile-or-throw.args.ts b/@generated/profile/find-first-profile-or-throw.args.ts
index 5da9a526..c74cd647 100644
--- a/@generated/profile/find-first-profile-or-throw.args.ts
+++ b/@generated/profile/find-first-profile-or-throw.args.ts
@@ -3,29 +3,30 @@ import { ArgsType } from '@nestjs/graphql';
 import { ProfileWhereInput } from './profile-where.input';
 import { Type } from 'class-transformer';
 import { ProfileOrderByWithRelationAndSearchRelevanceInput } from './profile-order-by-with-relation-and-search-relevance.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ProfileWhereUniqueInput } from './profile-where-unique.input';
 import { Int } from '@nestjs/graphql';
 import { ProfileScalarFieldEnum } from './profile-scalar-field.enum';
 
 @ArgsType()
 export class FindFirstProfileOrThrowArgs {
-  @Field(() => ProfileWhereInput, { nullable: true })
-  @Type(() => ProfileWhereInput)
-  where?: ProfileWhereInput;
 
-  @Field(() => [ProfileOrderByWithRelationAndSearchRelevanceInput], { nullable: true })
-  orderBy?: Array<ProfileOrderByWithRelationAndSearchRelevanceInput>;
+    @Field(() => ProfileWhereInput, {nullable:true})
+    @Type(() => ProfileWhereInput)
+    where?: ProfileWhereInput;
 
-  @Field(() => ProfileWhereUniqueInput, { nullable: true })
-  cursor?: Prisma.AtLeast<ProfileWhereUniqueInput, 'id' | 'userId'>;
+    @Field(() => [ProfileOrderByWithRelationAndSearchRelevanceInput], {nullable:true})
+    orderBy?: Array<ProfileOrderByWithRelationAndSearchRelevanceInput>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => ProfileWhereUniqueInput, {nullable:true})
+    cursor?: Prisma.AtLeast<ProfileWhereUniqueInput, 'id' | 'userId'>;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => [ProfileScalarFieldEnum], { nullable: true })
-  distinct?: Array<keyof typeof ProfileScalarFieldEnum>;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
+
+    @Field(() => [ProfileScalarFieldEnum], {nullable:true})
+    distinct?: Array<keyof typeof ProfileScalarFieldEnum>;
 }
diff --git a/@generated/profile/find-first-profile.args.ts b/@generated/profile/find-first-profile.args.ts
index 1adceebc..a8417f66 100644
--- a/@generated/profile/find-first-profile.args.ts
+++ b/@generated/profile/find-first-profile.args.ts
@@ -3,29 +3,30 @@ import { ArgsType } from '@nestjs/graphql';
 import { ProfileWhereInput } from './profile-where.input';
 import { Type } from 'class-transformer';
 import { ProfileOrderByWithRelationAndSearchRelevanceInput } from './profile-order-by-with-relation-and-search-relevance.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ProfileWhereUniqueInput } from './profile-where-unique.input';
 import { Int } from '@nestjs/graphql';
 import { ProfileScalarFieldEnum } from './profile-scalar-field.enum';
 
 @ArgsType()
 export class FindFirstProfileArgs {
-  @Field(() => ProfileWhereInput, { nullable: true })
-  @Type(() => ProfileWhereInput)
-  where?: ProfileWhereInput;
 
-  @Field(() => [ProfileOrderByWithRelationAndSearchRelevanceInput], { nullable: true })
-  orderBy?: Array<ProfileOrderByWithRelationAndSearchRelevanceInput>;
+    @Field(() => ProfileWhereInput, {nullable:true})
+    @Type(() => ProfileWhereInput)
+    where?: ProfileWhereInput;
 
-  @Field(() => ProfileWhereUniqueInput, { nullable: true })
-  cursor?: Prisma.AtLeast<ProfileWhereUniqueInput, 'id' | 'userId'>;
+    @Field(() => [ProfileOrderByWithRelationAndSearchRelevanceInput], {nullable:true})
+    orderBy?: Array<ProfileOrderByWithRelationAndSearchRelevanceInput>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => ProfileWhereUniqueInput, {nullable:true})
+    cursor?: Prisma.AtLeast<ProfileWhereUniqueInput, 'id' | 'userId'>;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => [ProfileScalarFieldEnum], { nullable: true })
-  distinct?: Array<keyof typeof ProfileScalarFieldEnum>;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
+
+    @Field(() => [ProfileScalarFieldEnum], {nullable:true})
+    distinct?: Array<keyof typeof ProfileScalarFieldEnum>;
 }
diff --git a/@generated/profile/find-many-profile.args.ts b/@generated/profile/find-many-profile.args.ts
index 4bd05125..7b07eb4c 100644
--- a/@generated/profile/find-many-profile.args.ts
+++ b/@generated/profile/find-many-profile.args.ts
@@ -3,29 +3,30 @@ import { ArgsType } from '@nestjs/graphql';
 import { ProfileWhereInput } from './profile-where.input';
 import { Type } from 'class-transformer';
 import { ProfileOrderByWithRelationAndSearchRelevanceInput } from './profile-order-by-with-relation-and-search-relevance.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ProfileWhereUniqueInput } from './profile-where-unique.input';
 import { Int } from '@nestjs/graphql';
 import { ProfileScalarFieldEnum } from './profile-scalar-field.enum';
 
 @ArgsType()
 export class FindManyProfileArgs {
-  @Field(() => ProfileWhereInput, { nullable: true })
-  @Type(() => ProfileWhereInput)
-  where?: ProfileWhereInput;
 
-  @Field(() => [ProfileOrderByWithRelationAndSearchRelevanceInput], { nullable: true })
-  orderBy?: Array<ProfileOrderByWithRelationAndSearchRelevanceInput>;
+    @Field(() => ProfileWhereInput, {nullable:true})
+    @Type(() => ProfileWhereInput)
+    where?: ProfileWhereInput;
 
-  @Field(() => ProfileWhereUniqueInput, { nullable: true })
-  cursor?: Prisma.AtLeast<ProfileWhereUniqueInput, 'id' | 'userId'>;
+    @Field(() => [ProfileOrderByWithRelationAndSearchRelevanceInput], {nullable:true})
+    orderBy?: Array<ProfileOrderByWithRelationAndSearchRelevanceInput>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => ProfileWhereUniqueInput, {nullable:true})
+    cursor?: Prisma.AtLeast<ProfileWhereUniqueInput, 'id' | 'userId'>;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => [ProfileScalarFieldEnum], { nullable: true })
-  distinct?: Array<keyof typeof ProfileScalarFieldEnum>;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
+
+    @Field(() => [ProfileScalarFieldEnum], {nullable:true})
+    distinct?: Array<keyof typeof ProfileScalarFieldEnum>;
 }
diff --git a/@generated/profile/find-unique-profile-or-throw.args.ts b/@generated/profile/find-unique-profile-or-throw.args.ts
index 110ddd2e..e43f717e 100644
--- a/@generated/profile/find-unique-profile-or-throw.args.ts
+++ b/@generated/profile/find-unique-profile-or-throw.args.ts
@@ -1,12 +1,13 @@
 import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ProfileWhereUniqueInput } from './profile-where-unique.input';
 import { Type } from 'class-transformer';
 
 @ArgsType()
 export class FindUniqueProfileOrThrowArgs {
-  @Field(() => ProfileWhereUniqueInput, { nullable: false })
-  @Type(() => ProfileWhereUniqueInput)
-  where!: Prisma.AtLeast<ProfileWhereUniqueInput, 'id' | 'userId'>;
+
+    @Field(() => ProfileWhereUniqueInput, {nullable:false})
+    @Type(() => ProfileWhereUniqueInput)
+    where!: Prisma.AtLeast<ProfileWhereUniqueInput, 'id' | 'userId'>;
 }
diff --git a/@generated/profile/find-unique-profile.args.ts b/@generated/profile/find-unique-profile.args.ts
index 40c0d034..aac64a69 100644
--- a/@generated/profile/find-unique-profile.args.ts
+++ b/@generated/profile/find-unique-profile.args.ts
@@ -1,12 +1,13 @@
 import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ProfileWhereUniqueInput } from './profile-where-unique.input';
 import { Type } from 'class-transformer';
 
 @ArgsType()
 export class FindUniqueProfileArgs {
-  @Field(() => ProfileWhereUniqueInput, { nullable: false })
-  @Type(() => ProfileWhereUniqueInput)
-  where!: Prisma.AtLeast<ProfileWhereUniqueInput, 'id' | 'userId'>;
+
+    @Field(() => ProfileWhereUniqueInput, {nullable:false})
+    @Type(() => ProfileWhereUniqueInput)
+    where!: Prisma.AtLeast<ProfileWhereUniqueInput, 'id' | 'userId'>;
 }
diff --git a/@generated/profile/profile-aggregate.args.ts b/@generated/profile/profile-aggregate.args.ts
index 959d5219..d38fae65 100644
--- a/@generated/profile/profile-aggregate.args.ts
+++ b/@generated/profile/profile-aggregate.args.ts
@@ -3,7 +3,7 @@ import { ArgsType } from '@nestjs/graphql';
 import { ProfileWhereInput } from './profile-where.input';
 import { Type } from 'class-transformer';
 import { ProfileOrderByWithRelationAndSearchRelevanceInput } from './profile-order-by-with-relation-and-search-relevance.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ProfileWhereUniqueInput } from './profile-where-unique.input';
 import { Int } from '@nestjs/graphql';
 import { ProfileCountAggregateInput } from './profile-count-aggregate.input';
@@ -14,34 +14,35 @@ import { ProfileMaxAggregateInput } from './profile-max-aggregate.input';
 
 @ArgsType()
 export class ProfileAggregateArgs {
-  @Field(() => ProfileWhereInput, { nullable: true })
-  @Type(() => ProfileWhereInput)
-  where?: ProfileWhereInput;
 
-  @Field(() => [ProfileOrderByWithRelationAndSearchRelevanceInput], { nullable: true })
-  orderBy?: Array<ProfileOrderByWithRelationAndSearchRelevanceInput>;
+    @Field(() => ProfileWhereInput, {nullable:true})
+    @Type(() => ProfileWhereInput)
+    where?: ProfileWhereInput;
 
-  @Field(() => ProfileWhereUniqueInput, { nullable: true })
-  cursor?: Prisma.AtLeast<ProfileWhereUniqueInput, 'id' | 'userId'>;
+    @Field(() => [ProfileOrderByWithRelationAndSearchRelevanceInput], {nullable:true})
+    orderBy?: Array<ProfileOrderByWithRelationAndSearchRelevanceInput>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => ProfileWhereUniqueInput, {nullable:true})
+    cursor?: Prisma.AtLeast<ProfileWhereUniqueInput, 'id' | 'userId'>;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => ProfileCountAggregateInput, { nullable: true })
-  _count?: ProfileCountAggregateInput;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
 
-  @Field(() => ProfileAvgAggregateInput, { nullable: true })
-  _avg?: ProfileAvgAggregateInput;
+    @Field(() => ProfileCountAggregateInput, {nullable:true})
+    _count?: ProfileCountAggregateInput;
 
-  @Field(() => ProfileSumAggregateInput, { nullable: true })
-  _sum?: ProfileSumAggregateInput;
+    @Field(() => ProfileAvgAggregateInput, {nullable:true})
+    _avg?: ProfileAvgAggregateInput;
 
-  @Field(() => ProfileMinAggregateInput, { nullable: true })
-  _min?: ProfileMinAggregateInput;
+    @Field(() => ProfileSumAggregateInput, {nullable:true})
+    _sum?: ProfileSumAggregateInput;
 
-  @Field(() => ProfileMaxAggregateInput, { nullable: true })
-  _max?: ProfileMaxAggregateInput;
+    @Field(() => ProfileMinAggregateInput, {nullable:true})
+    _min?: ProfileMinAggregateInput;
+
+    @Field(() => ProfileMaxAggregateInput, {nullable:true})
+    _max?: ProfileMaxAggregateInput;
 }
diff --git a/@generated/profile/profile-avg-aggregate.input.ts b/@generated/profile/profile-avg-aggregate.input.ts
index 7092d800..01aade10 100644
--- a/@generated/profile/profile-avg-aggregate.input.ts
+++ b/@generated/profile/profile-avg-aggregate.input.ts
@@ -3,6 +3,7 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class ProfileAvgAggregateInput {
-  @Field(() => Boolean, { nullable: true })
-  id?: true;
+
+    @Field(() => Boolean, {nullable:true})
+    id?: true;
 }
diff --git a/@generated/profile/profile-avg-aggregate.output.ts b/@generated/profile/profile-avg-aggregate.output.ts
index f8e48487..83bfddf4 100644
--- a/@generated/profile/profile-avg-aggregate.output.ts
+++ b/@generated/profile/profile-avg-aggregate.output.ts
@@ -4,6 +4,7 @@ import { Float } from '@nestjs/graphql';
 
 @ObjectType()
 export class ProfileAvgAggregate {
-  @Field(() => Float, { nullable: true })
-  id?: number;
+
+    @Field(() => Float, {nullable:true})
+    id?: number;
 }
diff --git a/@generated/profile/profile-avg-order-by-aggregate.input.ts b/@generated/profile/profile-avg-order-by-aggregate.input.ts
index e56f759e..3fef29bd 100644
--- a/@generated/profile/profile-avg-order-by-aggregate.input.ts
+++ b/@generated/profile/profile-avg-order-by-aggregate.input.ts
@@ -4,6 +4,7 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class ProfileAvgOrderByAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
 }
diff --git a/@generated/profile/profile-count-aggregate.input.ts b/@generated/profile/profile-count-aggregate.input.ts
index 29646d48..c6b13904 100644
--- a/@generated/profile/profile-count-aggregate.input.ts
+++ b/@generated/profile/profile-count-aggregate.input.ts
@@ -3,15 +3,16 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class ProfileCountAggregateInput {
-  @Field(() => Boolean, { nullable: true })
-  id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  userId?: true;
+    @Field(() => Boolean, {nullable:true})
+    id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  dummy?: true;
+    @Field(() => Boolean, {nullable:true})
+    userId?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  _all?: true;
+    @Field(() => Boolean, {nullable:true})
+    dummy?: true;
+
+    @Field(() => Boolean, {nullable:true})
+    _all?: true;
 }
diff --git a/@generated/profile/profile-count-aggregate.output.ts b/@generated/profile/profile-count-aggregate.output.ts
index 48786dc6..bb87a474 100644
--- a/@generated/profile/profile-count-aggregate.output.ts
+++ b/@generated/profile/profile-count-aggregate.output.ts
@@ -4,15 +4,16 @@ import { Int } from '@nestjs/graphql';
 
 @ObjectType()
 export class ProfileCountAggregate {
-  @Field(() => Int, { nullable: false })
-  id!: number;
 
-  @Field(() => Int, { nullable: false })
-  userId!: number;
+    @Field(() => Int, {nullable:false})
+    id!: number;
 
-  @Field(() => Int, { nullable: false })
-  dummy!: number;
+    @Field(() => Int, {nullable:false})
+    userId!: number;
 
-  @Field(() => Int, { nullable: false })
-  _all!: number;
+    @Field(() => Int, {nullable:false})
+    dummy!: number;
+
+    @Field(() => Int, {nullable:false})
+    _all!: number;
 }
diff --git a/@generated/profile/profile-count-order-by-aggregate.input.ts b/@generated/profile/profile-count-order-by-aggregate.input.ts
index acd1c5db..e6b5fcb0 100644
--- a/@generated/profile/profile-count-order-by-aggregate.input.ts
+++ b/@generated/profile/profile-count-order-by-aggregate.input.ts
@@ -4,12 +4,13 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class ProfileCountOrderByAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  userId?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  dummy?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    userId?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    dummy?: keyof typeof SortOrder;
 }
diff --git a/@generated/profile/profile-create-many.input.ts b/@generated/profile/profile-create-many.input.ts
index 6efac1d5..351a59e5 100644
--- a/@generated/profile/profile-create-many.input.ts
+++ b/@generated/profile/profile-create-many.input.ts
@@ -4,12 +4,13 @@ import { Int } from '@nestjs/graphql';
 
 @InputType()
 export class ProfileCreateManyInput {
-  @Field(() => Int, { nullable: true })
-  id?: number;
 
-  @Field(() => String, { nullable: false })
-  userId!: string;
+    @Field(() => Int, {nullable:true})
+    id?: number;
 
-  @Field(() => String, { nullable: true })
-  dummy?: string;
+    @Field(() => String, {nullable:false})
+    userId!: string;
+
+    @Field(() => String, {nullable:true})
+    dummy?: string;
 }
diff --git a/@generated/profile/profile-create-nested-one-without-user.input.ts b/@generated/profile/profile-create-nested-one-without-user.input.ts
index b2e00de2..3fa90371 100644
--- a/@generated/profile/profile-create-nested-one-without-user.input.ts
+++ b/@generated/profile/profile-create-nested-one-without-user.input.ts
@@ -3,20 +3,21 @@ import { InputType } from '@nestjs/graphql';
 import { ProfileCreateWithoutUserInput } from './profile-create-without-user.input';
 import { Type } from 'class-transformer';
 import { ProfileCreateOrConnectWithoutUserInput } from './profile-create-or-connect-without-user.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ProfileWhereUniqueInput } from './profile-where-unique.input';
 
 @InputType()
 export class ProfileCreateNestedOneWithoutUserInput {
-  @Field(() => ProfileCreateWithoutUserInput, { nullable: true })
-  @Type(() => ProfileCreateWithoutUserInput)
-  create?: ProfileCreateWithoutUserInput;
 
-  @Field(() => ProfileCreateOrConnectWithoutUserInput, { nullable: true })
-  @Type(() => ProfileCreateOrConnectWithoutUserInput)
-  connectOrCreate?: ProfileCreateOrConnectWithoutUserInput;
+    @Field(() => ProfileCreateWithoutUserInput, {nullable:true})
+    @Type(() => ProfileCreateWithoutUserInput)
+    create?: ProfileCreateWithoutUserInput;
 
-  @Field(() => ProfileWhereUniqueInput, { nullable: true })
-  @Type(() => ProfileWhereUniqueInput)
-  connect?: Prisma.AtLeast<ProfileWhereUniqueInput, 'id' | 'userId'>;
+    @Field(() => ProfileCreateOrConnectWithoutUserInput, {nullable:true})
+    @Type(() => ProfileCreateOrConnectWithoutUserInput)
+    connectOrCreate?: ProfileCreateOrConnectWithoutUserInput;
+
+    @Field(() => ProfileWhereUniqueInput, {nullable:true})
+    @Type(() => ProfileWhereUniqueInput)
+    connect?: Prisma.AtLeast<ProfileWhereUniqueInput, 'id' | 'userId'>;
 }
diff --git a/@generated/profile/profile-create-or-connect-without-user.input.ts b/@generated/profile/profile-create-or-connect-without-user.input.ts
index da4952bf..abdbf1f3 100644
--- a/@generated/profile/profile-create-or-connect-without-user.input.ts
+++ b/@generated/profile/profile-create-or-connect-without-user.input.ts
@@ -1,17 +1,18 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ProfileWhereUniqueInput } from './profile-where-unique.input';
 import { Type } from 'class-transformer';
 import { ProfileCreateWithoutUserInput } from './profile-create-without-user.input';
 
 @InputType()
 export class ProfileCreateOrConnectWithoutUserInput {
-  @Field(() => ProfileWhereUniqueInput, { nullable: false })
-  @Type(() => ProfileWhereUniqueInput)
-  where!: Prisma.AtLeast<ProfileWhereUniqueInput, 'id' | 'userId'>;
 
-  @Field(() => ProfileCreateWithoutUserInput, { nullable: false })
-  @Type(() => ProfileCreateWithoutUserInput)
-  create!: ProfileCreateWithoutUserInput;
+    @Field(() => ProfileWhereUniqueInput, {nullable:false})
+    @Type(() => ProfileWhereUniqueInput)
+    where!: Prisma.AtLeast<ProfileWhereUniqueInput, 'id' | 'userId'>;
+
+    @Field(() => ProfileCreateWithoutUserInput, {nullable:false})
+    @Type(() => ProfileCreateWithoutUserInput)
+    create!: ProfileCreateWithoutUserInput;
 }
diff --git a/@generated/profile/profile-create-without-user.input.ts b/@generated/profile/profile-create-without-user.input.ts
index dffa437c..856e5d82 100644
--- a/@generated/profile/profile-create-without-user.input.ts
+++ b/@generated/profile/profile-create-without-user.input.ts
@@ -3,6 +3,7 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class ProfileCreateWithoutUserInput {
-  @Field(() => String, { nullable: true })
-  dummy?: string;
+
+    @Field(() => String, {nullable:true})
+    dummy?: string;
 }
diff --git a/@generated/profile/profile-create.input.ts b/@generated/profile/profile-create.input.ts
index 088f0e60..a8434515 100644
--- a/@generated/profile/profile-create.input.ts
+++ b/@generated/profile/profile-create.input.ts
@@ -5,10 +5,11 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class ProfileCreateInput {
-  @Field(() => String, { nullable: true })
-  dummy?: string;
 
-  @Field(() => UserCreateNestedOneWithoutProfileInput, { nullable: false })
-  @Type(() => UserCreateNestedOneWithoutProfileInput)
-  user!: UserCreateNestedOneWithoutProfileInput;
+    @Field(() => String, {nullable:true})
+    dummy?: string;
+
+    @Field(() => UserCreateNestedOneWithoutProfileInput, {nullable:false})
+    @Type(() => UserCreateNestedOneWithoutProfileInput)
+    user!: UserCreateNestedOneWithoutProfileInput;
 }
diff --git a/@generated/profile/profile-group-by.args.ts b/@generated/profile/profile-group-by.args.ts
index 153405e6..59f61ada 100644
--- a/@generated/profile/profile-group-by.args.ts
+++ b/@generated/profile/profile-group-by.args.ts
@@ -14,37 +14,38 @@ import { ProfileMaxAggregateInput } from './profile-max-aggregate.input';
 
 @ArgsType()
 export class ProfileGroupByArgs {
-  @Field(() => ProfileWhereInput, { nullable: true })
-  @Type(() => ProfileWhereInput)
-  where?: ProfileWhereInput;
 
-  @Field(() => [ProfileOrderByWithAggregationInput], { nullable: true })
-  orderBy?: Array<ProfileOrderByWithAggregationInput>;
+    @Field(() => ProfileWhereInput, {nullable:true})
+    @Type(() => ProfileWhereInput)
+    where?: ProfileWhereInput;
 
-  @Field(() => [ProfileScalarFieldEnum], { nullable: false })
-  by!: Array<keyof typeof ProfileScalarFieldEnum>;
+    @Field(() => [ProfileOrderByWithAggregationInput], {nullable:true})
+    orderBy?: Array<ProfileOrderByWithAggregationInput>;
 
-  @Field(() => ProfileScalarWhereWithAggregatesInput, { nullable: true })
-  having?: ProfileScalarWhereWithAggregatesInput;
+    @Field(() => [ProfileScalarFieldEnum], {nullable:false})
+    by!: Array<keyof typeof ProfileScalarFieldEnum>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => ProfileScalarWhereWithAggregatesInput, {nullable:true})
+    having?: ProfileScalarWhereWithAggregatesInput;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => ProfileCountAggregateInput, { nullable: true })
-  _count?: ProfileCountAggregateInput;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
 
-  @Field(() => ProfileAvgAggregateInput, { nullable: true })
-  _avg?: ProfileAvgAggregateInput;
+    @Field(() => ProfileCountAggregateInput, {nullable:true})
+    _count?: ProfileCountAggregateInput;
 
-  @Field(() => ProfileSumAggregateInput, { nullable: true })
-  _sum?: ProfileSumAggregateInput;
+    @Field(() => ProfileAvgAggregateInput, {nullable:true})
+    _avg?: ProfileAvgAggregateInput;
 
-  @Field(() => ProfileMinAggregateInput, { nullable: true })
-  _min?: ProfileMinAggregateInput;
+    @Field(() => ProfileSumAggregateInput, {nullable:true})
+    _sum?: ProfileSumAggregateInput;
 
-  @Field(() => ProfileMaxAggregateInput, { nullable: true })
-  _max?: ProfileMaxAggregateInput;
+    @Field(() => ProfileMinAggregateInput, {nullable:true})
+    _min?: ProfileMinAggregateInput;
+
+    @Field(() => ProfileMaxAggregateInput, {nullable:true})
+    _max?: ProfileMaxAggregateInput;
 }
diff --git a/@generated/profile/profile-group-by.output.ts b/@generated/profile/profile-group-by.output.ts
index f2ee433a..4ec0e1e5 100644
--- a/@generated/profile/profile-group-by.output.ts
+++ b/@generated/profile/profile-group-by.output.ts
@@ -9,27 +9,28 @@ import { ProfileMaxAggregate } from './profile-max-aggregate.output';
 
 @ObjectType()
 export class ProfileGroupBy {
-  @Field(() => Int, { nullable: false })
-  id!: number;
 
-  @Field(() => String, { nullable: false })
-  userId!: string;
+    @Field(() => Int, {nullable:false})
+    id!: number;
 
-  @Field(() => String, { nullable: true })
-  dummy?: string;
+    @Field(() => String, {nullable:false})
+    userId!: string;
 
-  @Field(() => ProfileCountAggregate, { nullable: true })
-  _count?: ProfileCountAggregate;
+    @Field(() => String, {nullable:true})
+    dummy?: string;
 
-  @Field(() => ProfileAvgAggregate, { nullable: true })
-  _avg?: ProfileAvgAggregate;
+    @Field(() => ProfileCountAggregate, {nullable:true})
+    _count?: ProfileCountAggregate;
 
-  @Field(() => ProfileSumAggregate, { nullable: true })
-  _sum?: ProfileSumAggregate;
+    @Field(() => ProfileAvgAggregate, {nullable:true})
+    _avg?: ProfileAvgAggregate;
 
-  @Field(() => ProfileMinAggregate, { nullable: true })
-  _min?: ProfileMinAggregate;
+    @Field(() => ProfileSumAggregate, {nullable:true})
+    _sum?: ProfileSumAggregate;
 
-  @Field(() => ProfileMaxAggregate, { nullable: true })
-  _max?: ProfileMaxAggregate;
+    @Field(() => ProfileMinAggregate, {nullable:true})
+    _min?: ProfileMinAggregate;
+
+    @Field(() => ProfileMaxAggregate, {nullable:true})
+    _max?: ProfileMaxAggregate;
 }
diff --git a/@generated/profile/profile-max-aggregate.input.ts b/@generated/profile/profile-max-aggregate.input.ts
index 06069f7a..a4c61214 100644
--- a/@generated/profile/profile-max-aggregate.input.ts
+++ b/@generated/profile/profile-max-aggregate.input.ts
@@ -3,12 +3,13 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class ProfileMaxAggregateInput {
-  @Field(() => Boolean, { nullable: true })
-  id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  userId?: true;
+    @Field(() => Boolean, {nullable:true})
+    id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  dummy?: true;
+    @Field(() => Boolean, {nullable:true})
+    userId?: true;
+
+    @Field(() => Boolean, {nullable:true})
+    dummy?: true;
 }
diff --git a/@generated/profile/profile-max-aggregate.output.ts b/@generated/profile/profile-max-aggregate.output.ts
index 53cca991..97439f4b 100644
--- a/@generated/profile/profile-max-aggregate.output.ts
+++ b/@generated/profile/profile-max-aggregate.output.ts
@@ -4,12 +4,13 @@ import { Int } from '@nestjs/graphql';
 
 @ObjectType()
 export class ProfileMaxAggregate {
-  @Field(() => Int, { nullable: true })
-  id?: number;
 
-  @Field(() => String, { nullable: true })
-  userId?: string;
+    @Field(() => Int, {nullable:true})
+    id?: number;
 
-  @Field(() => String, { nullable: true })
-  dummy?: string;
+    @Field(() => String, {nullable:true})
+    userId?: string;
+
+    @Field(() => String, {nullable:true})
+    dummy?: string;
 }
diff --git a/@generated/profile/profile-max-order-by-aggregate.input.ts b/@generated/profile/profile-max-order-by-aggregate.input.ts
index c666fc6f..cde61ddd 100644
--- a/@generated/profile/profile-max-order-by-aggregate.input.ts
+++ b/@generated/profile/profile-max-order-by-aggregate.input.ts
@@ -4,12 +4,13 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class ProfileMaxOrderByAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  userId?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  dummy?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    userId?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    dummy?: keyof typeof SortOrder;
 }
diff --git a/@generated/profile/profile-min-aggregate.input.ts b/@generated/profile/profile-min-aggregate.input.ts
index 0cb69e0b..03e05268 100644
--- a/@generated/profile/profile-min-aggregate.input.ts
+++ b/@generated/profile/profile-min-aggregate.input.ts
@@ -3,12 +3,13 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class ProfileMinAggregateInput {
-  @Field(() => Boolean, { nullable: true })
-  id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  userId?: true;
+    @Field(() => Boolean, {nullable:true})
+    id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  dummy?: true;
+    @Field(() => Boolean, {nullable:true})
+    userId?: true;
+
+    @Field(() => Boolean, {nullable:true})
+    dummy?: true;
 }
diff --git a/@generated/profile/profile-min-aggregate.output.ts b/@generated/profile/profile-min-aggregate.output.ts
index e7cb8307..9a55676b 100644
--- a/@generated/profile/profile-min-aggregate.output.ts
+++ b/@generated/profile/profile-min-aggregate.output.ts
@@ -4,12 +4,13 @@ import { Int } from '@nestjs/graphql';
 
 @ObjectType()
 export class ProfileMinAggregate {
-  @Field(() => Int, { nullable: true })
-  id?: number;
 
-  @Field(() => String, { nullable: true })
-  userId?: string;
+    @Field(() => Int, {nullable:true})
+    id?: number;
 
-  @Field(() => String, { nullable: true })
-  dummy?: string;
+    @Field(() => String, {nullable:true})
+    userId?: string;
+
+    @Field(() => String, {nullable:true})
+    dummy?: string;
 }
diff --git a/@generated/profile/profile-min-order-by-aggregate.input.ts b/@generated/profile/profile-min-order-by-aggregate.input.ts
index fd1185b7..7bb43779 100644
--- a/@generated/profile/profile-min-order-by-aggregate.input.ts
+++ b/@generated/profile/profile-min-order-by-aggregate.input.ts
@@ -4,12 +4,13 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class ProfileMinOrderByAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  userId?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  dummy?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    userId?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    dummy?: keyof typeof SortOrder;
 }
diff --git a/@generated/profile/profile-nullable-relation-filter.input.ts b/@generated/profile/profile-nullable-relation-filter.input.ts
index e3ec64f1..66656b1a 100644
--- a/@generated/profile/profile-nullable-relation-filter.input.ts
+++ b/@generated/profile/profile-nullable-relation-filter.input.ts
@@ -4,9 +4,10 @@ import { ProfileWhereInput } from './profile-where.input';
 
 @InputType()
 export class ProfileNullableRelationFilter {
-  @Field(() => ProfileWhereInput, { nullable: true })
-  is?: ProfileWhereInput;
 
-  @Field(() => ProfileWhereInput, { nullable: true })
-  isNot?: ProfileWhereInput;
+    @Field(() => ProfileWhereInput, {nullable:true})
+    is?: ProfileWhereInput;
+
+    @Field(() => ProfileWhereInput, {nullable:true})
+    isNot?: ProfileWhereInput;
 }
diff --git a/@generated/profile/profile-order-by-relevance-field.enum.ts b/@generated/profile/profile-order-by-relevance-field.enum.ts
index 605c11f2..d6f03112 100644
--- a/@generated/profile/profile-order-by-relevance-field.enum.ts
+++ b/@generated/profile/profile-order-by-relevance-field.enum.ts
@@ -1,11 +1,9 @@
 import { registerEnumType } from '@nestjs/graphql';
 
 export enum ProfileOrderByRelevanceFieldEnum {
-  userId = 'userId',
-  dummy = 'dummy',
+    userId = "userId",
+    dummy = "dummy"
 }
 
-registerEnumType(ProfileOrderByRelevanceFieldEnum, {
-  name: 'ProfileOrderByRelevanceFieldEnum',
-  description: undefined,
-});
+
+registerEnumType(ProfileOrderByRelevanceFieldEnum, { name: 'ProfileOrderByRelevanceFieldEnum', description: undefined })
diff --git a/@generated/profile/profile-order-by-relevance.input.ts b/@generated/profile/profile-order-by-relevance.input.ts
index d5d971d6..34cfdf3d 100644
--- a/@generated/profile/profile-order-by-relevance.input.ts
+++ b/@generated/profile/profile-order-by-relevance.input.ts
@@ -5,12 +5,13 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class ProfileOrderByRelevanceInput {
-  @Field(() => [ProfileOrderByRelevanceFieldEnum], { nullable: false })
-  fields!: Array<keyof typeof ProfileOrderByRelevanceFieldEnum>;
 
-  @Field(() => SortOrder, { nullable: false })
-  sort!: keyof typeof SortOrder;
+    @Field(() => [ProfileOrderByRelevanceFieldEnum], {nullable:false})
+    fields!: Array<keyof typeof ProfileOrderByRelevanceFieldEnum>;
 
-  @Field(() => String, { nullable: false })
-  search!: string;
+    @Field(() => SortOrder, {nullable:false})
+    sort!: keyof typeof SortOrder;
+
+    @Field(() => String, {nullable:false})
+    search!: string;
 }
diff --git a/@generated/profile/profile-order-by-with-aggregation.input.ts b/@generated/profile/profile-order-by-with-aggregation.input.ts
index cb3cc99d..4ef0ae62 100644
--- a/@generated/profile/profile-order-by-with-aggregation.input.ts
+++ b/@generated/profile/profile-order-by-with-aggregation.input.ts
@@ -10,27 +10,28 @@ import { ProfileSumOrderByAggregateInput } from './profile-sum-order-by-aggregat
 
 @InputType()
 export class ProfileOrderByWithAggregationInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  userId?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  dummy?: SortOrderInput;
+    @Field(() => SortOrder, {nullable:true})
+    userId?: keyof typeof SortOrder;
 
-  @Field(() => ProfileCountOrderByAggregateInput, { nullable: true })
-  _count?: ProfileCountOrderByAggregateInput;
+    @Field(() => SortOrderInput, {nullable:true})
+    dummy?: SortOrderInput;
 
-  @Field(() => ProfileAvgOrderByAggregateInput, { nullable: true })
-  _avg?: ProfileAvgOrderByAggregateInput;
+    @Field(() => ProfileCountOrderByAggregateInput, {nullable:true})
+    _count?: ProfileCountOrderByAggregateInput;
 
-  @Field(() => ProfileMaxOrderByAggregateInput, { nullable: true })
-  _max?: ProfileMaxOrderByAggregateInput;
+    @Field(() => ProfileAvgOrderByAggregateInput, {nullable:true})
+    _avg?: ProfileAvgOrderByAggregateInput;
 
-  @Field(() => ProfileMinOrderByAggregateInput, { nullable: true })
-  _min?: ProfileMinOrderByAggregateInput;
+    @Field(() => ProfileMaxOrderByAggregateInput, {nullable:true})
+    _max?: ProfileMaxOrderByAggregateInput;
 
-  @Field(() => ProfileSumOrderByAggregateInput, { nullable: true })
-  _sum?: ProfileSumOrderByAggregateInput;
+    @Field(() => ProfileMinOrderByAggregateInput, {nullable:true})
+    _min?: ProfileMinOrderByAggregateInput;
+
+    @Field(() => ProfileSumOrderByAggregateInput, {nullable:true})
+    _sum?: ProfileSumOrderByAggregateInput;
 }
diff --git a/@generated/profile/profile-order-by-with-relation-and-search-relevance.input.ts b/@generated/profile/profile-order-by-with-relation-and-search-relevance.input.ts
index a6b4b7bb..1b2f7440 100644
--- a/@generated/profile/profile-order-by-with-relation-and-search-relevance.input.ts
+++ b/@generated/profile/profile-order-by-with-relation-and-search-relevance.input.ts
@@ -8,19 +8,20 @@ import { ProfileOrderByRelevanceInput } from './profile-order-by-relevance.input
 
 @InputType()
 export class ProfileOrderByWithRelationAndSearchRelevanceInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  userId?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  dummy?: SortOrderInput;
+    @Field(() => SortOrder, {nullable:true})
+    userId?: keyof typeof SortOrder;
 
-  @Field(() => UserOrderByWithRelationAndSearchRelevanceInput, { nullable: true })
-  @Type(() => UserOrderByWithRelationAndSearchRelevanceInput)
-  user?: UserOrderByWithRelationAndSearchRelevanceInput;
+    @Field(() => SortOrderInput, {nullable:true})
+    dummy?: SortOrderInput;
 
-  @Field(() => ProfileOrderByRelevanceInput, { nullable: true })
-  _relevance?: ProfileOrderByRelevanceInput;
+    @Field(() => UserOrderByWithRelationAndSearchRelevanceInput, {nullable:true})
+    @Type(() => UserOrderByWithRelationAndSearchRelevanceInput)
+    user?: UserOrderByWithRelationAndSearchRelevanceInput;
+
+    @Field(() => ProfileOrderByRelevanceInput, {nullable:true})
+    _relevance?: ProfileOrderByRelevanceInput;
 }
diff --git a/@generated/profile/profile-scalar-field.enum.ts b/@generated/profile/profile-scalar-field.enum.ts
index eb067c47..46ee3065 100644
--- a/@generated/profile/profile-scalar-field.enum.ts
+++ b/@generated/profile/profile-scalar-field.enum.ts
@@ -1,12 +1,10 @@
 import { registerEnumType } from '@nestjs/graphql';
 
 export enum ProfileScalarFieldEnum {
-  id = 'id',
-  userId = 'userId',
-  dummy = 'dummy',
+    id = "id",
+    userId = "userId",
+    dummy = "dummy"
 }
 
-registerEnumType(ProfileScalarFieldEnum, {
-  name: 'ProfileScalarFieldEnum',
-  description: undefined,
-});
+
+registerEnumType(ProfileScalarFieldEnum, { name: 'ProfileScalarFieldEnum', description: undefined })
diff --git a/@generated/profile/profile-scalar-where-with-aggregates.input.ts b/@generated/profile/profile-scalar-where-with-aggregates.input.ts
index 44db1166..b41657a2 100644
--- a/@generated/profile/profile-scalar-where-with-aggregates.input.ts
+++ b/@generated/profile/profile-scalar-where-with-aggregates.input.ts
@@ -6,21 +6,22 @@ import { StringNullableWithAggregatesFilter } from '../prisma/string-nullable-wi
 
 @InputType()
 export class ProfileScalarWhereWithAggregatesInput {
-  @Field(() => [ProfileScalarWhereWithAggregatesInput], { nullable: true })
-  AND?: Array<ProfileScalarWhereWithAggregatesInput>;
 
-  @Field(() => [ProfileScalarWhereWithAggregatesInput], { nullable: true })
-  OR?: Array<ProfileScalarWhereWithAggregatesInput>;
+    @Field(() => [ProfileScalarWhereWithAggregatesInput], {nullable:true})
+    AND?: Array<ProfileScalarWhereWithAggregatesInput>;
 
-  @Field(() => [ProfileScalarWhereWithAggregatesInput], { nullable: true })
-  NOT?: Array<ProfileScalarWhereWithAggregatesInput>;
+    @Field(() => [ProfileScalarWhereWithAggregatesInput], {nullable:true})
+    OR?: Array<ProfileScalarWhereWithAggregatesInput>;
 
-  @Field(() => IntWithAggregatesFilter, { nullable: true })
-  id?: IntWithAggregatesFilter;
+    @Field(() => [ProfileScalarWhereWithAggregatesInput], {nullable:true})
+    NOT?: Array<ProfileScalarWhereWithAggregatesInput>;
 
-  @Field(() => StringWithAggregatesFilter, { nullable: true })
-  userId?: StringWithAggregatesFilter;
+    @Field(() => IntWithAggregatesFilter, {nullable:true})
+    id?: IntWithAggregatesFilter;
 
-  @Field(() => StringNullableWithAggregatesFilter, { nullable: true })
-  dummy?: StringNullableWithAggregatesFilter;
+    @Field(() => StringWithAggregatesFilter, {nullable:true})
+    userId?: StringWithAggregatesFilter;
+
+    @Field(() => StringNullableWithAggregatesFilter, {nullable:true})
+    dummy?: StringNullableWithAggregatesFilter;
 }
diff --git a/@generated/profile/profile-sum-aggregate.input.ts b/@generated/profile/profile-sum-aggregate.input.ts
index 57d97533..bf5393f5 100644
--- a/@generated/profile/profile-sum-aggregate.input.ts
+++ b/@generated/profile/profile-sum-aggregate.input.ts
@@ -3,6 +3,7 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class ProfileSumAggregateInput {
-  @Field(() => Boolean, { nullable: true })
-  id?: true;
+
+    @Field(() => Boolean, {nullable:true})
+    id?: true;
 }
diff --git a/@generated/profile/profile-sum-aggregate.output.ts b/@generated/profile/profile-sum-aggregate.output.ts
index 1ab708e1..3f726551 100644
--- a/@generated/profile/profile-sum-aggregate.output.ts
+++ b/@generated/profile/profile-sum-aggregate.output.ts
@@ -4,6 +4,7 @@ import { Int } from '@nestjs/graphql';
 
 @ObjectType()
 export class ProfileSumAggregate {
-  @Field(() => Int, { nullable: true })
-  id?: number;
+
+    @Field(() => Int, {nullable:true})
+    id?: number;
 }
diff --git a/@generated/profile/profile-sum-order-by-aggregate.input.ts b/@generated/profile/profile-sum-order-by-aggregate.input.ts
index ebd51c53..eed27b5f 100644
--- a/@generated/profile/profile-sum-order-by-aggregate.input.ts
+++ b/@generated/profile/profile-sum-order-by-aggregate.input.ts
@@ -4,6 +4,7 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class ProfileSumOrderByAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
 }
diff --git a/@generated/profile/profile-unchecked-create-nested-one-without-user.input.ts b/@generated/profile/profile-unchecked-create-nested-one-without-user.input.ts
index 5dc46325..72938102 100644
--- a/@generated/profile/profile-unchecked-create-nested-one-without-user.input.ts
+++ b/@generated/profile/profile-unchecked-create-nested-one-without-user.input.ts
@@ -4,18 +4,19 @@ import { ProfileCreateWithoutUserInput } from './profile-create-without-user.inp
 import { Type } from 'class-transformer';
 import { ProfileCreateOrConnectWithoutUserInput } from './profile-create-or-connect-without-user.input';
 import { HideField } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ProfileWhereUniqueInput } from './profile-where-unique.input';
 
 @InputType()
 export class ProfileUncheckedCreateNestedOneWithoutUserInput {
-  @Field(() => ProfileCreateWithoutUserInput, { nullable: true })
-  @Type(() => ProfileCreateWithoutUserInput)
-  create?: ProfileCreateWithoutUserInput;
 
-  @HideField()
-  connectOrCreate?: ProfileCreateOrConnectWithoutUserInput;
+    @Field(() => ProfileCreateWithoutUserInput, {nullable:true})
+    @Type(() => ProfileCreateWithoutUserInput)
+    create?: ProfileCreateWithoutUserInput;
 
-  @HideField()
-  connect?: Prisma.AtLeast<ProfileWhereUniqueInput, 'id' | 'userId'>;
+    @HideField()
+    connectOrCreate?: ProfileCreateOrConnectWithoutUserInput;
+
+    @HideField()
+    connect?: Prisma.AtLeast<ProfileWhereUniqueInput, 'id' | 'userId'>;
 }
diff --git a/@generated/profile/profile-unchecked-create-without-user.input.ts b/@generated/profile/profile-unchecked-create-without-user.input.ts
index 0452e6dd..7e2b9994 100644
--- a/@generated/profile/profile-unchecked-create-without-user.input.ts
+++ b/@generated/profile/profile-unchecked-create-without-user.input.ts
@@ -4,9 +4,10 @@ import { Int } from '@nestjs/graphql';
 
 @InputType()
 export class ProfileUncheckedCreateWithoutUserInput {
-  @Field(() => Int, { nullable: true })
-  id?: number;
 
-  @Field(() => String, { nullable: true })
-  dummy?: string;
+    @Field(() => Int, {nullable:true})
+    id?: number;
+
+    @Field(() => String, {nullable:true})
+    dummy?: string;
 }
diff --git a/@generated/profile/profile-unchecked-create.input.ts b/@generated/profile/profile-unchecked-create.input.ts
index 2555bb6f..3ada82ff 100644
--- a/@generated/profile/profile-unchecked-create.input.ts
+++ b/@generated/profile/profile-unchecked-create.input.ts
@@ -4,12 +4,13 @@ import { Int } from '@nestjs/graphql';
 
 @InputType()
 export class ProfileUncheckedCreateInput {
-  @Field(() => Int, { nullable: true })
-  id?: number;
 
-  @Field(() => String, { nullable: false })
-  userId!: string;
+    @Field(() => Int, {nullable:true})
+    id?: number;
 
-  @Field(() => String, { nullable: true })
-  dummy?: string;
+    @Field(() => String, {nullable:false})
+    userId!: string;
+
+    @Field(() => String, {nullable:true})
+    dummy?: string;
 }
diff --git a/@generated/profile/profile-unchecked-update-many.input.ts b/@generated/profile/profile-unchecked-update-many.input.ts
index 218d46a7..3b4808b2 100644
--- a/@generated/profile/profile-unchecked-update-many.input.ts
+++ b/@generated/profile/profile-unchecked-update-many.input.ts
@@ -6,12 +6,13 @@ import { NullableStringFieldUpdateOperationsInput } from '../prisma/nullable-str
 
 @InputType()
 export class ProfileUncheckedUpdateManyInput {
-  @Field(() => IntFieldUpdateOperationsInput, { nullable: true })
-  id?: IntFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  userId?: StringFieldUpdateOperationsInput;
+    @Field(() => IntFieldUpdateOperationsInput, {nullable:true})
+    id?: IntFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  dummy?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    userId?: StringFieldUpdateOperationsInput;
+
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    dummy?: NullableStringFieldUpdateOperationsInput;
 }
diff --git a/@generated/profile/profile-unchecked-update-one-without-user-nested.input.ts b/@generated/profile/profile-unchecked-update-one-without-user-nested.input.ts
index 4afd504a..d1d16ba5 100644
--- a/@generated/profile/profile-unchecked-update-one-without-user-nested.input.ts
+++ b/@generated/profile/profile-unchecked-update-one-without-user-nested.input.ts
@@ -5,37 +5,38 @@ import { Type } from 'class-transformer';
 import { ProfileCreateOrConnectWithoutUserInput } from './profile-create-or-connect-without-user.input';
 import { ProfileUpsertWithoutUserInput } from './profile-upsert-without-user.input';
 import { ProfileWhereInput } from './profile-where.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ProfileWhereUniqueInput } from './profile-where-unique.input';
 import { ProfileUpdateToOneWithWhereWithoutUserInput } from './profile-update-to-one-with-where-without-user.input';
 
 @InputType()
 export class ProfileUncheckedUpdateOneWithoutUserNestedInput {
-  @Field(() => ProfileCreateWithoutUserInput, { nullable: true })
-  @Type(() => ProfileCreateWithoutUserInput)
-  create?: ProfileCreateWithoutUserInput;
 
-  @Field(() => ProfileCreateOrConnectWithoutUserInput, { nullable: true })
-  @Type(() => ProfileCreateOrConnectWithoutUserInput)
-  connectOrCreate?: ProfileCreateOrConnectWithoutUserInput;
+    @Field(() => ProfileCreateWithoutUserInput, {nullable:true})
+    @Type(() => ProfileCreateWithoutUserInput)
+    create?: ProfileCreateWithoutUserInput;
 
-  @Field(() => ProfileUpsertWithoutUserInput, { nullable: true })
-  @Type(() => ProfileUpsertWithoutUserInput)
-  upsert?: ProfileUpsertWithoutUserInput;
+    @Field(() => ProfileCreateOrConnectWithoutUserInput, {nullable:true})
+    @Type(() => ProfileCreateOrConnectWithoutUserInput)
+    connectOrCreate?: ProfileCreateOrConnectWithoutUserInput;
 
-  @Field(() => ProfileWhereInput, { nullable: true })
-  @Type(() => ProfileWhereInput)
-  disconnect?: ProfileWhereInput;
+    @Field(() => ProfileUpsertWithoutUserInput, {nullable:true})
+    @Type(() => ProfileUpsertWithoutUserInput)
+    upsert?: ProfileUpsertWithoutUserInput;
 
-  @Field(() => ProfileWhereInput, { nullable: true })
-  @Type(() => ProfileWhereInput)
-  delete?: ProfileWhereInput;
+    @Field(() => ProfileWhereInput, {nullable:true})
+    @Type(() => ProfileWhereInput)
+    disconnect?: ProfileWhereInput;
 
-  @Field(() => ProfileWhereUniqueInput, { nullable: true })
-  @Type(() => ProfileWhereUniqueInput)
-  connect?: Prisma.AtLeast<ProfileWhereUniqueInput, 'id' | 'userId'>;
+    @Field(() => ProfileWhereInput, {nullable:true})
+    @Type(() => ProfileWhereInput)
+    delete?: ProfileWhereInput;
 
-  @Field(() => ProfileUpdateToOneWithWhereWithoutUserInput, { nullable: true })
-  @Type(() => ProfileUpdateToOneWithWhereWithoutUserInput)
-  update?: ProfileUpdateToOneWithWhereWithoutUserInput;
+    @Field(() => ProfileWhereUniqueInput, {nullable:true})
+    @Type(() => ProfileWhereUniqueInput)
+    connect?: Prisma.AtLeast<ProfileWhereUniqueInput, 'id' | 'userId'>;
+
+    @Field(() => ProfileUpdateToOneWithWhereWithoutUserInput, {nullable:true})
+    @Type(() => ProfileUpdateToOneWithWhereWithoutUserInput)
+    update?: ProfileUpdateToOneWithWhereWithoutUserInput;
 }
diff --git a/@generated/profile/profile-unchecked-update-without-user.input.ts b/@generated/profile/profile-unchecked-update-without-user.input.ts
index a30554ad..f2a71cbe 100644
--- a/@generated/profile/profile-unchecked-update-without-user.input.ts
+++ b/@generated/profile/profile-unchecked-update-without-user.input.ts
@@ -5,9 +5,10 @@ import { NullableStringFieldUpdateOperationsInput } from '../prisma/nullable-str
 
 @InputType()
 export class ProfileUncheckedUpdateWithoutUserInput {
-  @Field(() => IntFieldUpdateOperationsInput, { nullable: true })
-  id?: IntFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  dummy?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => IntFieldUpdateOperationsInput, {nullable:true})
+    id?: IntFieldUpdateOperationsInput;
+
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    dummy?: NullableStringFieldUpdateOperationsInput;
 }
diff --git a/@generated/profile/profile-unchecked-update.input.ts b/@generated/profile/profile-unchecked-update.input.ts
index 5f3319d4..72bd0c26 100644
--- a/@generated/profile/profile-unchecked-update.input.ts
+++ b/@generated/profile/profile-unchecked-update.input.ts
@@ -6,12 +6,13 @@ import { NullableStringFieldUpdateOperationsInput } from '../prisma/nullable-str
 
 @InputType()
 export class ProfileUncheckedUpdateInput {
-  @Field(() => IntFieldUpdateOperationsInput, { nullable: true })
-  id?: IntFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  userId?: StringFieldUpdateOperationsInput;
+    @Field(() => IntFieldUpdateOperationsInput, {nullable:true})
+    id?: IntFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  dummy?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    userId?: StringFieldUpdateOperationsInput;
+
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    dummy?: NullableStringFieldUpdateOperationsInput;
 }
diff --git a/@generated/profile/profile-update-many-mutation.input.ts b/@generated/profile/profile-update-many-mutation.input.ts
index 9cfcb125..5b7c7ffc 100644
--- a/@generated/profile/profile-update-many-mutation.input.ts
+++ b/@generated/profile/profile-update-many-mutation.input.ts
@@ -4,6 +4,7 @@ import { NullableStringFieldUpdateOperationsInput } from '../prisma/nullable-str
 
 @InputType()
 export class ProfileUpdateManyMutationInput {
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  dummy?: NullableStringFieldUpdateOperationsInput;
+
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    dummy?: NullableStringFieldUpdateOperationsInput;
 }
diff --git a/@generated/profile/profile-update-one-without-user-nested.input.ts b/@generated/profile/profile-update-one-without-user-nested.input.ts
index a6ca6bf9..7472b268 100644
--- a/@generated/profile/profile-update-one-without-user-nested.input.ts
+++ b/@generated/profile/profile-update-one-without-user-nested.input.ts
@@ -5,37 +5,38 @@ import { Type } from 'class-transformer';
 import { ProfileCreateOrConnectWithoutUserInput } from './profile-create-or-connect-without-user.input';
 import { ProfileUpsertWithoutUserInput } from './profile-upsert-without-user.input';
 import { ProfileWhereInput } from './profile-where.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ProfileWhereUniqueInput } from './profile-where-unique.input';
 import { ProfileUpdateToOneWithWhereWithoutUserInput } from './profile-update-to-one-with-where-without-user.input';
 
 @InputType()
 export class ProfileUpdateOneWithoutUserNestedInput {
-  @Field(() => ProfileCreateWithoutUserInput, { nullable: true })
-  @Type(() => ProfileCreateWithoutUserInput)
-  create?: ProfileCreateWithoutUserInput;
 
-  @Field(() => ProfileCreateOrConnectWithoutUserInput, { nullable: true })
-  @Type(() => ProfileCreateOrConnectWithoutUserInput)
-  connectOrCreate?: ProfileCreateOrConnectWithoutUserInput;
+    @Field(() => ProfileCreateWithoutUserInput, {nullable:true})
+    @Type(() => ProfileCreateWithoutUserInput)
+    create?: ProfileCreateWithoutUserInput;
 
-  @Field(() => ProfileUpsertWithoutUserInput, { nullable: true })
-  @Type(() => ProfileUpsertWithoutUserInput)
-  upsert?: ProfileUpsertWithoutUserInput;
+    @Field(() => ProfileCreateOrConnectWithoutUserInput, {nullable:true})
+    @Type(() => ProfileCreateOrConnectWithoutUserInput)
+    connectOrCreate?: ProfileCreateOrConnectWithoutUserInput;
 
-  @Field(() => ProfileWhereInput, { nullable: true })
-  @Type(() => ProfileWhereInput)
-  disconnect?: ProfileWhereInput;
+    @Field(() => ProfileUpsertWithoutUserInput, {nullable:true})
+    @Type(() => ProfileUpsertWithoutUserInput)
+    upsert?: ProfileUpsertWithoutUserInput;
 
-  @Field(() => ProfileWhereInput, { nullable: true })
-  @Type(() => ProfileWhereInput)
-  delete?: ProfileWhereInput;
+    @Field(() => ProfileWhereInput, {nullable:true})
+    @Type(() => ProfileWhereInput)
+    disconnect?: ProfileWhereInput;
 
-  @Field(() => ProfileWhereUniqueInput, { nullable: true })
-  @Type(() => ProfileWhereUniqueInput)
-  connect?: Prisma.AtLeast<ProfileWhereUniqueInput, 'id' | 'userId'>;
+    @Field(() => ProfileWhereInput, {nullable:true})
+    @Type(() => ProfileWhereInput)
+    delete?: ProfileWhereInput;
 
-  @Field(() => ProfileUpdateToOneWithWhereWithoutUserInput, { nullable: true })
-  @Type(() => ProfileUpdateToOneWithWhereWithoutUserInput)
-  update?: ProfileUpdateToOneWithWhereWithoutUserInput;
+    @Field(() => ProfileWhereUniqueInput, {nullable:true})
+    @Type(() => ProfileWhereUniqueInput)
+    connect?: Prisma.AtLeast<ProfileWhereUniqueInput, 'id' | 'userId'>;
+
+    @Field(() => ProfileUpdateToOneWithWhereWithoutUserInput, {nullable:true})
+    @Type(() => ProfileUpdateToOneWithWhereWithoutUserInput)
+    update?: ProfileUpdateToOneWithWhereWithoutUserInput;
 }
diff --git a/@generated/profile/profile-update-to-one-with-where-without-user.input.ts b/@generated/profile/profile-update-to-one-with-where-without-user.input.ts
index 51004b43..0db569d5 100644
--- a/@generated/profile/profile-update-to-one-with-where-without-user.input.ts
+++ b/@generated/profile/profile-update-to-one-with-where-without-user.input.ts
@@ -6,11 +6,12 @@ import { ProfileUpdateWithoutUserInput } from './profile-update-without-user.inp
 
 @InputType()
 export class ProfileUpdateToOneWithWhereWithoutUserInput {
-  @Field(() => ProfileWhereInput, { nullable: true })
-  @Type(() => ProfileWhereInput)
-  where?: ProfileWhereInput;
 
-  @Field(() => ProfileUpdateWithoutUserInput, { nullable: false })
-  @Type(() => ProfileUpdateWithoutUserInput)
-  data!: ProfileUpdateWithoutUserInput;
+    @Field(() => ProfileWhereInput, {nullable:true})
+    @Type(() => ProfileWhereInput)
+    where?: ProfileWhereInput;
+
+    @Field(() => ProfileUpdateWithoutUserInput, {nullable:false})
+    @Type(() => ProfileUpdateWithoutUserInput)
+    data!: ProfileUpdateWithoutUserInput;
 }
diff --git a/@generated/profile/profile-update-without-user.input.ts b/@generated/profile/profile-update-without-user.input.ts
index 1449585e..8e04da04 100644
--- a/@generated/profile/profile-update-without-user.input.ts
+++ b/@generated/profile/profile-update-without-user.input.ts
@@ -4,6 +4,7 @@ import { NullableStringFieldUpdateOperationsInput } from '../prisma/nullable-str
 
 @InputType()
 export class ProfileUpdateWithoutUserInput {
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  dummy?: NullableStringFieldUpdateOperationsInput;
+
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    dummy?: NullableStringFieldUpdateOperationsInput;
 }
diff --git a/@generated/profile/profile-update.input.ts b/@generated/profile/profile-update.input.ts
index 122d38c8..01c36ded 100644
--- a/@generated/profile/profile-update.input.ts
+++ b/@generated/profile/profile-update.input.ts
@@ -6,10 +6,11 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class ProfileUpdateInput {
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  dummy?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => UserUpdateOneRequiredWithoutProfileNestedInput, { nullable: true })
-  @Type(() => UserUpdateOneRequiredWithoutProfileNestedInput)
-  user?: UserUpdateOneRequiredWithoutProfileNestedInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    dummy?: NullableStringFieldUpdateOperationsInput;
+
+    @Field(() => UserUpdateOneRequiredWithoutProfileNestedInput, {nullable:true})
+    @Type(() => UserUpdateOneRequiredWithoutProfileNestedInput)
+    user?: UserUpdateOneRequiredWithoutProfileNestedInput;
 }
diff --git a/@generated/profile/profile-upsert-without-user.input.ts b/@generated/profile/profile-upsert-without-user.input.ts
index 92e8e124..217f3e4c 100644
--- a/@generated/profile/profile-upsert-without-user.input.ts
+++ b/@generated/profile/profile-upsert-without-user.input.ts
@@ -7,15 +7,16 @@ import { ProfileWhereInput } from './profile-where.input';
 
 @InputType()
 export class ProfileUpsertWithoutUserInput {
-  @Field(() => ProfileUpdateWithoutUserInput, { nullable: false })
-  @Type(() => ProfileUpdateWithoutUserInput)
-  update!: ProfileUpdateWithoutUserInput;
 
-  @Field(() => ProfileCreateWithoutUserInput, { nullable: false })
-  @Type(() => ProfileCreateWithoutUserInput)
-  create!: ProfileCreateWithoutUserInput;
+    @Field(() => ProfileUpdateWithoutUserInput, {nullable:false})
+    @Type(() => ProfileUpdateWithoutUserInput)
+    update!: ProfileUpdateWithoutUserInput;
 
-  @Field(() => ProfileWhereInput, { nullable: true })
-  @Type(() => ProfileWhereInput)
-  where?: ProfileWhereInput;
+    @Field(() => ProfileCreateWithoutUserInput, {nullable:false})
+    @Type(() => ProfileCreateWithoutUserInput)
+    create!: ProfileCreateWithoutUserInput;
+
+    @Field(() => ProfileWhereInput, {nullable:true})
+    @Type(() => ProfileWhereInput)
+    where?: ProfileWhereInput;
 }
diff --git a/@generated/profile/profile-where-unique.input.ts b/@generated/profile/profile-where-unique.input.ts
index 975a9e9b..6ca0c77a 100644
--- a/@generated/profile/profile-where-unique.input.ts
+++ b/@generated/profile/profile-where-unique.input.ts
@@ -8,25 +8,26 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class ProfileWhereUniqueInput {
-  @Field(() => Int, { nullable: true })
-  id?: number;
 
-  @Field(() => String, { nullable: true })
-  userId?: string;
+    @Field(() => Int, {nullable:true})
+    id?: number;
 
-  @Field(() => [ProfileWhereInput], { nullable: true })
-  AND?: Array<ProfileWhereInput>;
+    @Field(() => String, {nullable:true})
+    userId?: string;
 
-  @Field(() => [ProfileWhereInput], { nullable: true })
-  OR?: Array<ProfileWhereInput>;
+    @Field(() => [ProfileWhereInput], {nullable:true})
+    AND?: Array<ProfileWhereInput>;
 
-  @Field(() => [ProfileWhereInput], { nullable: true })
-  NOT?: Array<ProfileWhereInput>;
+    @Field(() => [ProfileWhereInput], {nullable:true})
+    OR?: Array<ProfileWhereInput>;
 
-  @Field(() => StringNullableFilter, { nullable: true })
-  dummy?: StringNullableFilter;
+    @Field(() => [ProfileWhereInput], {nullable:true})
+    NOT?: Array<ProfileWhereInput>;
 
-  @Field(() => UserRelationFilter, { nullable: true })
-  @Type(() => UserRelationFilter)
-  user?: UserRelationFilter;
+    @Field(() => StringNullableFilter, {nullable:true})
+    dummy?: StringNullableFilter;
+
+    @Field(() => UserRelationFilter, {nullable:true})
+    @Type(() => UserRelationFilter)
+    user?: UserRelationFilter;
 }
diff --git a/@generated/profile/profile-where.input.ts b/@generated/profile/profile-where.input.ts
index c8a98a36..213be2b3 100644
--- a/@generated/profile/profile-where.input.ts
+++ b/@generated/profile/profile-where.input.ts
@@ -8,25 +8,26 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class ProfileWhereInput {
-  @Field(() => [ProfileWhereInput], { nullable: true })
-  AND?: Array<ProfileWhereInput>;
 
-  @Field(() => [ProfileWhereInput], { nullable: true })
-  OR?: Array<ProfileWhereInput>;
+    @Field(() => [ProfileWhereInput], {nullable:true})
+    AND?: Array<ProfileWhereInput>;
 
-  @Field(() => [ProfileWhereInput], { nullable: true })
-  NOT?: Array<ProfileWhereInput>;
+    @Field(() => [ProfileWhereInput], {nullable:true})
+    OR?: Array<ProfileWhereInput>;
 
-  @Field(() => IntFilter, { nullable: true })
-  id?: IntFilter;
+    @Field(() => [ProfileWhereInput], {nullable:true})
+    NOT?: Array<ProfileWhereInput>;
 
-  @Field(() => StringFilter, { nullable: true })
-  userId?: StringFilter;
+    @Field(() => IntFilter, {nullable:true})
+    id?: IntFilter;
 
-  @Field(() => StringNullableFilter, { nullable: true })
-  dummy?: StringNullableFilter;
+    @Field(() => StringFilter, {nullable:true})
+    userId?: StringFilter;
 
-  @Field(() => UserWhereInput, { nullable: true })
-  @Type(() => UserWhereInput)
-  user?: UserWhereInput;
+    @Field(() => StringNullableFilter, {nullable:true})
+    dummy?: StringNullableFilter;
+
+    @Field(() => UserWhereInput, {nullable:true})
+    @Type(() => UserWhereInput)
+    user?: UserWhereInput;
 }
diff --git a/@generated/profile/profile.model.ts b/@generated/profile/profile.model.ts
index 1e5b9d25..cc0e98ef 100644
--- a/@generated/profile/profile.model.ts
+++ b/@generated/profile/profile.model.ts
@@ -5,15 +5,16 @@ import { User } from '../user/user.model';
 
 @ObjectType()
 export class Profile {
-  @Field(() => ID, { nullable: false })
-  id!: number;
 
-  @Field(() => String, { nullable: false })
-  userId!: string;
+    @Field(() => ID, {nullable:false})
+    id!: number;
 
-  @Field(() => String, { nullable: true })
-  dummy!: string | null;
+    @Field(() => String, {nullable:false})
+    userId!: string;
 
-  @Field(() => User, { nullable: false })
-  user?: User;
+    @Field(() => String, {nullable:true})
+    dummy!: string | null;
+
+    @Field(() => User, {nullable:false})
+    user?: User;
 }
diff --git a/@generated/profile/update-many-profile.args.ts b/@generated/profile/update-many-profile.args.ts
index 3b64185f..85121438 100644
--- a/@generated/profile/update-many-profile.args.ts
+++ b/@generated/profile/update-many-profile.args.ts
@@ -6,11 +6,12 @@ import { ProfileWhereInput } from './profile-where.input';
 
 @ArgsType()
 export class UpdateManyProfileArgs {
-  @Field(() => ProfileUpdateManyMutationInput, { nullable: false })
-  @Type(() => ProfileUpdateManyMutationInput)
-  data!: ProfileUpdateManyMutationInput;
 
-  @Field(() => ProfileWhereInput, { nullable: true })
-  @Type(() => ProfileWhereInput)
-  where?: ProfileWhereInput;
+    @Field(() => ProfileUpdateManyMutationInput, {nullable:false})
+    @Type(() => ProfileUpdateManyMutationInput)
+    data!: ProfileUpdateManyMutationInput;
+
+    @Field(() => ProfileWhereInput, {nullable:true})
+    @Type(() => ProfileWhereInput)
+    where?: ProfileWhereInput;
 }
diff --git a/@generated/profile/update-one-profile.args.ts b/@generated/profile/update-one-profile.args.ts
index d75d5f0d..a17c3816 100644
--- a/@generated/profile/update-one-profile.args.ts
+++ b/@generated/profile/update-one-profile.args.ts
@@ -2,16 +2,17 @@ import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
 import { ProfileUpdateInput } from './profile-update.input';
 import { Type } from 'class-transformer';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ProfileWhereUniqueInput } from './profile-where-unique.input';
 
 @ArgsType()
 export class UpdateOneProfileArgs {
-  @Field(() => ProfileUpdateInput, { nullable: false })
-  @Type(() => ProfileUpdateInput)
-  data!: ProfileUpdateInput;
 
-  @Field(() => ProfileWhereUniqueInput, { nullable: false })
-  @Type(() => ProfileWhereUniqueInput)
-  where!: Prisma.AtLeast<ProfileWhereUniqueInput, 'id' | 'userId'>;
+    @Field(() => ProfileUpdateInput, {nullable:false})
+    @Type(() => ProfileUpdateInput)
+    data!: ProfileUpdateInput;
+
+    @Field(() => ProfileWhereUniqueInput, {nullable:false})
+    @Type(() => ProfileWhereUniqueInput)
+    where!: Prisma.AtLeast<ProfileWhereUniqueInput, 'id' | 'userId'>;
 }
diff --git a/@generated/profile/upsert-one-profile.args.ts b/@generated/profile/upsert-one-profile.args.ts
index 8614bbee..d6bae78d 100644
--- a/@generated/profile/upsert-one-profile.args.ts
+++ b/@generated/profile/upsert-one-profile.args.ts
@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { ProfileWhereUniqueInput } from './profile-where-unique.input';
 import { Type } from 'class-transformer';
 import { ProfileCreateInput } from './profile-create.input';
@@ -8,15 +8,16 @@ import { ProfileUpdateInput } from './profile-update.input';
 
 @ArgsType()
 export class UpsertOneProfileArgs {
-  @Field(() => ProfileWhereUniqueInput, { nullable: false })
-  @Type(() => ProfileWhereUniqueInput)
-  where!: Prisma.AtLeast<ProfileWhereUniqueInput, 'id' | 'userId'>;
 
-  @Field(() => ProfileCreateInput, { nullable: false })
-  @Type(() => ProfileCreateInput)
-  create!: ProfileCreateInput;
+    @Field(() => ProfileWhereUniqueInput, {nullable:false})
+    @Type(() => ProfileWhereUniqueInput)
+    where!: Prisma.AtLeast<ProfileWhereUniqueInput, 'id' | 'userId'>;
 
-  @Field(() => ProfileUpdateInput, { nullable: false })
-  @Type(() => ProfileUpdateInput)
-  update!: ProfileUpdateInput;
+    @Field(() => ProfileCreateInput, {nullable:false})
+    @Type(() => ProfileCreateInput)
+    create!: ProfileCreateInput;
+
+    @Field(() => ProfileUpdateInput, {nullable:false})
+    @Type(() => ProfileUpdateInput)
+    update!: ProfileUpdateInput;
 }
diff --git a/@generated/tag/aggregate-tag.output.ts b/@generated/tag/aggregate-tag.output.ts
index fd38ff81..0901d624 100644
--- a/@generated/tag/aggregate-tag.output.ts
+++ b/@generated/tag/aggregate-tag.output.ts
@@ -6,12 +6,13 @@ import { TagMaxAggregate } from './tag-max-aggregate.output';
 
 @ObjectType()
 export class AggregateTag {
-  @Field(() => TagCountAggregate, { nullable: true })
-  _count?: TagCountAggregate;
 
-  @Field(() => TagMinAggregate, { nullable: true })
-  _min?: TagMinAggregate;
+    @Field(() => TagCountAggregate, {nullable:true})
+    _count?: TagCountAggregate;
 
-  @Field(() => TagMaxAggregate, { nullable: true })
-  _max?: TagMaxAggregate;
+    @Field(() => TagMinAggregate, {nullable:true})
+    _min?: TagMinAggregate;
+
+    @Field(() => TagMaxAggregate, {nullable:true})
+    _max?: TagMaxAggregate;
 }
diff --git a/@generated/tag/create-many-tag.args.ts b/@generated/tag/create-many-tag.args.ts
index a2504683..b04a3c6d 100644
--- a/@generated/tag/create-many-tag.args.ts
+++ b/@generated/tag/create-many-tag.args.ts
@@ -5,10 +5,11 @@ import { Type } from 'class-transformer';
 
 @ArgsType()
 export class CreateManyTagArgs {
-  @Field(() => [TagCreateManyInput], { nullable: false })
-  @Type(() => TagCreateManyInput)
-  data!: Array<TagCreateManyInput>;
 
-  @Field(() => Boolean, { nullable: true })
-  skipDuplicates?: boolean;
+    @Field(() => [TagCreateManyInput], {nullable:false})
+    @Type(() => TagCreateManyInput)
+    data!: Array<TagCreateManyInput>;
+
+    @Field(() => Boolean, {nullable:true})
+    skipDuplicates?: boolean;
 }
diff --git a/@generated/tag/create-one-tag.args.ts b/@generated/tag/create-one-tag.args.ts
index afad1c48..ea178f1e 100644
--- a/@generated/tag/create-one-tag.args.ts
+++ b/@generated/tag/create-one-tag.args.ts
@@ -5,7 +5,8 @@ import { Type } from 'class-transformer';
 
 @ArgsType()
 export class CreateOneTagArgs {
-  @Field(() => TagCreateInput, { nullable: false })
-  @Type(() => TagCreateInput)
-  data!: TagCreateInput;
+
+    @Field(() => TagCreateInput, {nullable:false})
+    @Type(() => TagCreateInput)
+    data!: TagCreateInput;
 }
diff --git a/@generated/tag/delete-many-tag.args.ts b/@generated/tag/delete-many-tag.args.ts
index 946041c4..709d9011 100644
--- a/@generated/tag/delete-many-tag.args.ts
+++ b/@generated/tag/delete-many-tag.args.ts
@@ -5,7 +5,8 @@ import { Type } from 'class-transformer';
 
 @ArgsType()
 export class DeleteManyTagArgs {
-  @Field(() => TagWhereInput, { nullable: true })
-  @Type(() => TagWhereInput)
-  where?: TagWhereInput;
+
+    @Field(() => TagWhereInput, {nullable:true})
+    @Type(() => TagWhereInput)
+    where?: TagWhereInput;
 }
diff --git a/@generated/tag/delete-one-tag.args.ts b/@generated/tag/delete-one-tag.args.ts
index 7db795ff..d0fe03f7 100644
--- a/@generated/tag/delete-one-tag.args.ts
+++ b/@generated/tag/delete-one-tag.args.ts
@@ -1,12 +1,13 @@
 import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { TagWhereUniqueInput } from './tag-where-unique.input';
 import { Type } from 'class-transformer';
 
 @ArgsType()
 export class DeleteOneTagArgs {
-  @Field(() => TagWhereUniqueInput, { nullable: false })
-  @Type(() => TagWhereUniqueInput)
-  where!: Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>;
+
+    @Field(() => TagWhereUniqueInput, {nullable:false})
+    @Type(() => TagWhereUniqueInput)
+    where!: Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>;
 }
diff --git a/@generated/tag/find-first-tag-or-throw.args.ts b/@generated/tag/find-first-tag-or-throw.args.ts
index 235ddeba..7dda3545 100644
--- a/@generated/tag/find-first-tag-or-throw.args.ts
+++ b/@generated/tag/find-first-tag-or-throw.args.ts
@@ -3,29 +3,30 @@ import { ArgsType } from '@nestjs/graphql';
 import { TagWhereInput } from './tag-where.input';
 import { Type } from 'class-transformer';
 import { TagOrderByWithRelationAndSearchRelevanceInput } from './tag-order-by-with-relation-and-search-relevance.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { TagWhereUniqueInput } from './tag-where-unique.input';
 import { Int } from '@nestjs/graphql';
 import { TagScalarFieldEnum } from './tag-scalar-field.enum';
 
 @ArgsType()
 export class FindFirstTagOrThrowArgs {
-  @Field(() => TagWhereInput, { nullable: true })
-  @Type(() => TagWhereInput)
-  where?: TagWhereInput;
 
-  @Field(() => [TagOrderByWithRelationAndSearchRelevanceInput], { nullable: true })
-  orderBy?: Array<TagOrderByWithRelationAndSearchRelevanceInput>;
+    @Field(() => TagWhereInput, {nullable:true})
+    @Type(() => TagWhereInput)
+    where?: TagWhereInput;
 
-  @Field(() => TagWhereUniqueInput, { nullable: true })
-  cursor?: Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>;
+    @Field(() => [TagOrderByWithRelationAndSearchRelevanceInput], {nullable:true})
+    orderBy?: Array<TagOrderByWithRelationAndSearchRelevanceInput>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => TagWhereUniqueInput, {nullable:true})
+    cursor?: Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => [TagScalarFieldEnum], { nullable: true })
-  distinct?: Array<keyof typeof TagScalarFieldEnum>;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
+
+    @Field(() => [TagScalarFieldEnum], {nullable:true})
+    distinct?: Array<keyof typeof TagScalarFieldEnum>;
 }
diff --git a/@generated/tag/find-first-tag.args.ts b/@generated/tag/find-first-tag.args.ts
index 959b14a6..e201c3ee 100644
--- a/@generated/tag/find-first-tag.args.ts
+++ b/@generated/tag/find-first-tag.args.ts
@@ -3,29 +3,30 @@ import { ArgsType } from '@nestjs/graphql';
 import { TagWhereInput } from './tag-where.input';
 import { Type } from 'class-transformer';
 import { TagOrderByWithRelationAndSearchRelevanceInput } from './tag-order-by-with-relation-and-search-relevance.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { TagWhereUniqueInput } from './tag-where-unique.input';
 import { Int } from '@nestjs/graphql';
 import { TagScalarFieldEnum } from './tag-scalar-field.enum';
 
 @ArgsType()
 export class FindFirstTagArgs {
-  @Field(() => TagWhereInput, { nullable: true })
-  @Type(() => TagWhereInput)
-  where?: TagWhereInput;
 
-  @Field(() => [TagOrderByWithRelationAndSearchRelevanceInput], { nullable: true })
-  orderBy?: Array<TagOrderByWithRelationAndSearchRelevanceInput>;
+    @Field(() => TagWhereInput, {nullable:true})
+    @Type(() => TagWhereInput)
+    where?: TagWhereInput;
 
-  @Field(() => TagWhereUniqueInput, { nullable: true })
-  cursor?: Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>;
+    @Field(() => [TagOrderByWithRelationAndSearchRelevanceInput], {nullable:true})
+    orderBy?: Array<TagOrderByWithRelationAndSearchRelevanceInput>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => TagWhereUniqueInput, {nullable:true})
+    cursor?: Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => [TagScalarFieldEnum], { nullable: true })
-  distinct?: Array<keyof typeof TagScalarFieldEnum>;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
+
+    @Field(() => [TagScalarFieldEnum], {nullable:true})
+    distinct?: Array<keyof typeof TagScalarFieldEnum>;
 }
diff --git a/@generated/tag/find-many-tag.args.ts b/@generated/tag/find-many-tag.args.ts
index c0d73875..bb289f1d 100644
--- a/@generated/tag/find-many-tag.args.ts
+++ b/@generated/tag/find-many-tag.args.ts
@@ -3,29 +3,30 @@ import { ArgsType } from '@nestjs/graphql';
 import { TagWhereInput } from './tag-where.input';
 import { Type } from 'class-transformer';
 import { TagOrderByWithRelationAndSearchRelevanceInput } from './tag-order-by-with-relation-and-search-relevance.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { TagWhereUniqueInput } from './tag-where-unique.input';
 import { Int } from '@nestjs/graphql';
 import { TagScalarFieldEnum } from './tag-scalar-field.enum';
 
 @ArgsType()
 export class FindManyTagArgs {
-  @Field(() => TagWhereInput, { nullable: true })
-  @Type(() => TagWhereInput)
-  where?: TagWhereInput;
 
-  @Field(() => [TagOrderByWithRelationAndSearchRelevanceInput], { nullable: true })
-  orderBy?: Array<TagOrderByWithRelationAndSearchRelevanceInput>;
+    @Field(() => TagWhereInput, {nullable:true})
+    @Type(() => TagWhereInput)
+    where?: TagWhereInput;
 
-  @Field(() => TagWhereUniqueInput, { nullable: true })
-  cursor?: Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>;
+    @Field(() => [TagOrderByWithRelationAndSearchRelevanceInput], {nullable:true})
+    orderBy?: Array<TagOrderByWithRelationAndSearchRelevanceInput>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => TagWhereUniqueInput, {nullable:true})
+    cursor?: Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => [TagScalarFieldEnum], { nullable: true })
-  distinct?: Array<keyof typeof TagScalarFieldEnum>;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
+
+    @Field(() => [TagScalarFieldEnum], {nullable:true})
+    distinct?: Array<keyof typeof TagScalarFieldEnum>;
 }
diff --git a/@generated/tag/find-unique-tag-or-throw.args.ts b/@generated/tag/find-unique-tag-or-throw.args.ts
index 6c0b2c5a..047eefd5 100644
--- a/@generated/tag/find-unique-tag-or-throw.args.ts
+++ b/@generated/tag/find-unique-tag-or-throw.args.ts
@@ -1,12 +1,13 @@
 import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { TagWhereUniqueInput } from './tag-where-unique.input';
 import { Type } from 'class-transformer';
 
 @ArgsType()
 export class FindUniqueTagOrThrowArgs {
-  @Field(() => TagWhereUniqueInput, { nullable: false })
-  @Type(() => TagWhereUniqueInput)
-  where!: Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>;
+
+    @Field(() => TagWhereUniqueInput, {nullable:false})
+    @Type(() => TagWhereUniqueInput)
+    where!: Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>;
 }
diff --git a/@generated/tag/find-unique-tag.args.ts b/@generated/tag/find-unique-tag.args.ts
index 9dd5c45c..8bbbb7b4 100644
--- a/@generated/tag/find-unique-tag.args.ts
+++ b/@generated/tag/find-unique-tag.args.ts
@@ -1,12 +1,13 @@
 import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { TagWhereUniqueInput } from './tag-where-unique.input';
 import { Type } from 'class-transformer';
 
 @ArgsType()
 export class FindUniqueTagArgs {
-  @Field(() => TagWhereUniqueInput, { nullable: false })
-  @Type(() => TagWhereUniqueInput)
-  where!: Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>;
+
+    @Field(() => TagWhereUniqueInput, {nullable:false})
+    @Type(() => TagWhereUniqueInput)
+    where!: Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>;
 }
diff --git a/@generated/tag/tag-aggregate.args.ts b/@generated/tag/tag-aggregate.args.ts
index 6670eb16..1a647725 100644
--- a/@generated/tag/tag-aggregate.args.ts
+++ b/@generated/tag/tag-aggregate.args.ts
@@ -3,7 +3,7 @@ import { ArgsType } from '@nestjs/graphql';
 import { TagWhereInput } from './tag-where.input';
 import { Type } from 'class-transformer';
 import { TagOrderByWithRelationAndSearchRelevanceInput } from './tag-order-by-with-relation-and-search-relevance.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { TagWhereUniqueInput } from './tag-where-unique.input';
 import { Int } from '@nestjs/graphql';
 import { TagCountAggregateInput } from './tag-count-aggregate.input';
@@ -12,28 +12,29 @@ import { TagMaxAggregateInput } from './tag-max-aggregate.input';
 
 @ArgsType()
 export class TagAggregateArgs {
-  @Field(() => TagWhereInput, { nullable: true })
-  @Type(() => TagWhereInput)
-  where?: TagWhereInput;
 
-  @Field(() => [TagOrderByWithRelationAndSearchRelevanceInput], { nullable: true })
-  orderBy?: Array<TagOrderByWithRelationAndSearchRelevanceInput>;
+    @Field(() => TagWhereInput, {nullable:true})
+    @Type(() => TagWhereInput)
+    where?: TagWhereInput;
 
-  @Field(() => TagWhereUniqueInput, { nullable: true })
-  cursor?: Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>;
+    @Field(() => [TagOrderByWithRelationAndSearchRelevanceInput], {nullable:true})
+    orderBy?: Array<TagOrderByWithRelationAndSearchRelevanceInput>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => TagWhereUniqueInput, {nullable:true})
+    cursor?: Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => TagCountAggregateInput, { nullable: true })
-  _count?: TagCountAggregateInput;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
 
-  @Field(() => TagMinAggregateInput, { nullable: true })
-  _min?: TagMinAggregateInput;
+    @Field(() => TagCountAggregateInput, {nullable:true})
+    _count?: TagCountAggregateInput;
 
-  @Field(() => TagMaxAggregateInput, { nullable: true })
-  _max?: TagMaxAggregateInput;
+    @Field(() => TagMinAggregateInput, {nullable:true})
+    _min?: TagMinAggregateInput;
+
+    @Field(() => TagMaxAggregateInput, {nullable:true})
+    _max?: TagMaxAggregateInput;
 }
diff --git a/@generated/tag/tag-count-aggregate.input.ts b/@generated/tag/tag-count-aggregate.input.ts
index fde9183d..9f84f8a9 100644
--- a/@generated/tag/tag-count-aggregate.input.ts
+++ b/@generated/tag/tag-count-aggregate.input.ts
@@ -3,12 +3,13 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class TagCountAggregateInput {
-  @Field(() => Boolean, { nullable: true })
-  id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  name?: true;
+    @Field(() => Boolean, {nullable:true})
+    id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  _all?: true;
+    @Field(() => Boolean, {nullable:true})
+    name?: true;
+
+    @Field(() => Boolean, {nullable:true})
+    _all?: true;
 }
diff --git a/@generated/tag/tag-count-aggregate.output.ts b/@generated/tag/tag-count-aggregate.output.ts
index fb5c7371..ea71e365 100644
--- a/@generated/tag/tag-count-aggregate.output.ts
+++ b/@generated/tag/tag-count-aggregate.output.ts
@@ -4,12 +4,13 @@ import { Int } from '@nestjs/graphql';
 
 @ObjectType()
 export class TagCountAggregate {
-  @Field(() => Int, { nullable: false })
-  id!: number;
 
-  @Field(() => Int, { nullable: false })
-  name!: number;
+    @Field(() => Int, {nullable:false})
+    id!: number;
 
-  @Field(() => Int, { nullable: false })
-  _all!: number;
+    @Field(() => Int, {nullable:false})
+    name!: number;
+
+    @Field(() => Int, {nullable:false})
+    _all!: number;
 }
diff --git a/@generated/tag/tag-count-order-by-aggregate.input.ts b/@generated/tag/tag-count-order-by-aggregate.input.ts
index da954e5e..33c22d28 100644
--- a/@generated/tag/tag-count-order-by-aggregate.input.ts
+++ b/@generated/tag/tag-count-order-by-aggregate.input.ts
@@ -4,9 +4,10 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class TagCountOrderByAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  name?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    name?: keyof typeof SortOrder;
 }
diff --git a/@generated/tag/tag-count.output.ts b/@generated/tag/tag-count.output.ts
index ac89ff91..26bf367b 100644
--- a/@generated/tag/tag-count.output.ts
+++ b/@generated/tag/tag-count.output.ts
@@ -4,6 +4,7 @@ import { Int } from '@nestjs/graphql';
 
 @ObjectType()
 export class TagCount {
-  @Field(() => Int, { nullable: false })
-  articles?: number;
+
+    @Field(() => Int, {nullable:false})
+    articles?: number;
 }
diff --git a/@generated/tag/tag-create-many.input.ts b/@generated/tag/tag-create-many.input.ts
index a38f5fed..0a389add 100644
--- a/@generated/tag/tag-create-many.input.ts
+++ b/@generated/tag/tag-create-many.input.ts
@@ -3,9 +3,10 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class TagCreateManyInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => String, { nullable: false })
-  name!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
+
+    @Field(() => String, {nullable:false})
+    name!: string;
 }
diff --git a/@generated/tag/tag-create-nested-many-without-articles.input.ts b/@generated/tag/tag-create-nested-many-without-articles.input.ts
index 36f0752f..ee3d9414 100644
--- a/@generated/tag/tag-create-nested-many-without-articles.input.ts
+++ b/@generated/tag/tag-create-nested-many-without-articles.input.ts
@@ -3,20 +3,21 @@ import { InputType } from '@nestjs/graphql';
 import { TagCreateWithoutArticlesInput } from './tag-create-without-articles.input';
 import { Type } from 'class-transformer';
 import { TagCreateOrConnectWithoutArticlesInput } from './tag-create-or-connect-without-articles.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { TagWhereUniqueInput } from './tag-where-unique.input';
 
 @InputType()
 export class TagCreateNestedManyWithoutArticlesInput {
-  @Field(() => [TagCreateWithoutArticlesInput], { nullable: true })
-  @Type(() => TagCreateWithoutArticlesInput)
-  create?: Array<TagCreateWithoutArticlesInput>;
 
-  @Field(() => [TagCreateOrConnectWithoutArticlesInput], { nullable: true })
-  @Type(() => TagCreateOrConnectWithoutArticlesInput)
-  connectOrCreate?: Array<TagCreateOrConnectWithoutArticlesInput>;
+    @Field(() => [TagCreateWithoutArticlesInput], {nullable:true})
+    @Type(() => TagCreateWithoutArticlesInput)
+    create?: Array<TagCreateWithoutArticlesInput>;
 
-  @Field(() => [TagWhereUniqueInput], { nullable: true })
-  @Type(() => TagWhereUniqueInput)
-  connect?: Array<Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>>;
+    @Field(() => [TagCreateOrConnectWithoutArticlesInput], {nullable:true})
+    @Type(() => TagCreateOrConnectWithoutArticlesInput)
+    connectOrCreate?: Array<TagCreateOrConnectWithoutArticlesInput>;
+
+    @Field(() => [TagWhereUniqueInput], {nullable:true})
+    @Type(() => TagWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>>;
 }
diff --git a/@generated/tag/tag-create-or-connect-without-articles.input.ts b/@generated/tag/tag-create-or-connect-without-articles.input.ts
index 04ee0849..f5fe4139 100644
--- a/@generated/tag/tag-create-or-connect-without-articles.input.ts
+++ b/@generated/tag/tag-create-or-connect-without-articles.input.ts
@@ -1,17 +1,18 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { TagWhereUniqueInput } from './tag-where-unique.input';
 import { Type } from 'class-transformer';
 import { TagCreateWithoutArticlesInput } from './tag-create-without-articles.input';
 
 @InputType()
 export class TagCreateOrConnectWithoutArticlesInput {
-  @Field(() => TagWhereUniqueInput, { nullable: false })
-  @Type(() => TagWhereUniqueInput)
-  where!: Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>;
 
-  @Field(() => TagCreateWithoutArticlesInput, { nullable: false })
-  @Type(() => TagCreateWithoutArticlesInput)
-  create!: TagCreateWithoutArticlesInput;
+    @Field(() => TagWhereUniqueInput, {nullable:false})
+    @Type(() => TagWhereUniqueInput)
+    where!: Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>;
+
+    @Field(() => TagCreateWithoutArticlesInput, {nullable:false})
+    @Type(() => TagCreateWithoutArticlesInput)
+    create!: TagCreateWithoutArticlesInput;
 }
diff --git a/@generated/tag/tag-create-without-articles.input.ts b/@generated/tag/tag-create-without-articles.input.ts
index b8824ab9..411018c0 100644
--- a/@generated/tag/tag-create-without-articles.input.ts
+++ b/@generated/tag/tag-create-without-articles.input.ts
@@ -3,9 +3,10 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class TagCreateWithoutArticlesInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => String, { nullable: false })
-  name!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
+
+    @Field(() => String, {nullable:false})
+    name!: string;
 }
diff --git a/@generated/tag/tag-create.input.ts b/@generated/tag/tag-create.input.ts
index 681cfc3b..b12e1307 100644
--- a/@generated/tag/tag-create.input.ts
+++ b/@generated/tag/tag-create.input.ts
@@ -5,13 +5,14 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class TagCreateInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => String, { nullable: false })
-  name!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => ArticleCreateNestedManyWithoutTagsInput, { nullable: true })
-  @Type(() => ArticleCreateNestedManyWithoutTagsInput)
-  articles?: ArticleCreateNestedManyWithoutTagsInput;
+    @Field(() => String, {nullable:false})
+    name!: string;
+
+    @Field(() => ArticleCreateNestedManyWithoutTagsInput, {nullable:true})
+    @Type(() => ArticleCreateNestedManyWithoutTagsInput)
+    articles?: ArticleCreateNestedManyWithoutTagsInput;
 }
diff --git a/@generated/tag/tag-group-by.args.ts b/@generated/tag/tag-group-by.args.ts
index 8ae91cba..abc91f9b 100644
--- a/@generated/tag/tag-group-by.args.ts
+++ b/@generated/tag/tag-group-by.args.ts
@@ -12,31 +12,32 @@ import { TagMaxAggregateInput } from './tag-max-aggregate.input';
 
 @ArgsType()
 export class TagGroupByArgs {
-  @Field(() => TagWhereInput, { nullable: true })
-  @Type(() => TagWhereInput)
-  where?: TagWhereInput;
 
-  @Field(() => [TagOrderByWithAggregationInput], { nullable: true })
-  orderBy?: Array<TagOrderByWithAggregationInput>;
+    @Field(() => TagWhereInput, {nullable:true})
+    @Type(() => TagWhereInput)
+    where?: TagWhereInput;
 
-  @Field(() => [TagScalarFieldEnum], { nullable: false })
-  by!: Array<keyof typeof TagScalarFieldEnum>;
+    @Field(() => [TagOrderByWithAggregationInput], {nullable:true})
+    orderBy?: Array<TagOrderByWithAggregationInput>;
 
-  @Field(() => TagScalarWhereWithAggregatesInput, { nullable: true })
-  having?: TagScalarWhereWithAggregatesInput;
+    @Field(() => [TagScalarFieldEnum], {nullable:false})
+    by!: Array<keyof typeof TagScalarFieldEnum>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => TagScalarWhereWithAggregatesInput, {nullable:true})
+    having?: TagScalarWhereWithAggregatesInput;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => TagCountAggregateInput, { nullable: true })
-  _count?: TagCountAggregateInput;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
 
-  @Field(() => TagMinAggregateInput, { nullable: true })
-  _min?: TagMinAggregateInput;
+    @Field(() => TagCountAggregateInput, {nullable:true})
+    _count?: TagCountAggregateInput;
 
-  @Field(() => TagMaxAggregateInput, { nullable: true })
-  _max?: TagMaxAggregateInput;
+    @Field(() => TagMinAggregateInput, {nullable:true})
+    _min?: TagMinAggregateInput;
+
+    @Field(() => TagMaxAggregateInput, {nullable:true})
+    _max?: TagMaxAggregateInput;
 }
diff --git a/@generated/tag/tag-group-by.output.ts b/@generated/tag/tag-group-by.output.ts
index accaaad3..2d2bd121 100644
--- a/@generated/tag/tag-group-by.output.ts
+++ b/@generated/tag/tag-group-by.output.ts
@@ -6,18 +6,19 @@ import { TagMaxAggregate } from './tag-max-aggregate.output';
 
 @ObjectType()
 export class TagGroupBy {
-  @Field(() => String, { nullable: false })
-  id!: string;
 
-  @Field(() => String, { nullable: false })
-  name!: string;
+    @Field(() => String, {nullable:false})
+    id!: string;
 
-  @Field(() => TagCountAggregate, { nullable: true })
-  _count?: TagCountAggregate;
+    @Field(() => String, {nullable:false})
+    name!: string;
 
-  @Field(() => TagMinAggregate, { nullable: true })
-  _min?: TagMinAggregate;
+    @Field(() => TagCountAggregate, {nullable:true})
+    _count?: TagCountAggregate;
 
-  @Field(() => TagMaxAggregate, { nullable: true })
-  _max?: TagMaxAggregate;
+    @Field(() => TagMinAggregate, {nullable:true})
+    _min?: TagMinAggregate;
+
+    @Field(() => TagMaxAggregate, {nullable:true})
+    _max?: TagMaxAggregate;
 }
diff --git a/@generated/tag/tag-list-relation-filter.input.ts b/@generated/tag/tag-list-relation-filter.input.ts
index 1d19d5db..7e0c75f7 100644
--- a/@generated/tag/tag-list-relation-filter.input.ts
+++ b/@generated/tag/tag-list-relation-filter.input.ts
@@ -4,12 +4,13 @@ import { TagWhereInput } from './tag-where.input';
 
 @InputType()
 export class TagListRelationFilter {
-  @Field(() => TagWhereInput, { nullable: true })
-  every?: TagWhereInput;
 
-  @Field(() => TagWhereInput, { nullable: true })
-  some?: TagWhereInput;
+    @Field(() => TagWhereInput, {nullable:true})
+    every?: TagWhereInput;
 
-  @Field(() => TagWhereInput, { nullable: true })
-  none?: TagWhereInput;
+    @Field(() => TagWhereInput, {nullable:true})
+    some?: TagWhereInput;
+
+    @Field(() => TagWhereInput, {nullable:true})
+    none?: TagWhereInput;
 }
diff --git a/@generated/tag/tag-max-aggregate.input.ts b/@generated/tag/tag-max-aggregate.input.ts
index 556641ab..24e136eb 100644
--- a/@generated/tag/tag-max-aggregate.input.ts
+++ b/@generated/tag/tag-max-aggregate.input.ts
@@ -3,9 +3,10 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class TagMaxAggregateInput {
-  @Field(() => Boolean, { nullable: true })
-  id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  name?: true;
+    @Field(() => Boolean, {nullable:true})
+    id?: true;
+
+    @Field(() => Boolean, {nullable:true})
+    name?: true;
 }
diff --git a/@generated/tag/tag-max-aggregate.output.ts b/@generated/tag/tag-max-aggregate.output.ts
index e5d8e8ba..ceb6c998 100644
--- a/@generated/tag/tag-max-aggregate.output.ts
+++ b/@generated/tag/tag-max-aggregate.output.ts
@@ -3,9 +3,10 @@ import { ObjectType } from '@nestjs/graphql';
 
 @ObjectType()
 export class TagMaxAggregate {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => String, { nullable: true })
-  name?: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
+
+    @Field(() => String, {nullable:true})
+    name?: string;
 }
diff --git a/@generated/tag/tag-max-order-by-aggregate.input.ts b/@generated/tag/tag-max-order-by-aggregate.input.ts
index 48bf1460..73c39676 100644
--- a/@generated/tag/tag-max-order-by-aggregate.input.ts
+++ b/@generated/tag/tag-max-order-by-aggregate.input.ts
@@ -4,9 +4,10 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class TagMaxOrderByAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  name?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    name?: keyof typeof SortOrder;
 }
diff --git a/@generated/tag/tag-min-aggregate.input.ts b/@generated/tag/tag-min-aggregate.input.ts
index 250b2d83..7feaf943 100644
--- a/@generated/tag/tag-min-aggregate.input.ts
+++ b/@generated/tag/tag-min-aggregate.input.ts
@@ -3,9 +3,10 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class TagMinAggregateInput {
-  @Field(() => Boolean, { nullable: true })
-  id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  name?: true;
+    @Field(() => Boolean, {nullable:true})
+    id?: true;
+
+    @Field(() => Boolean, {nullable:true})
+    name?: true;
 }
diff --git a/@generated/tag/tag-min-aggregate.output.ts b/@generated/tag/tag-min-aggregate.output.ts
index af609aca..3b4f476d 100644
--- a/@generated/tag/tag-min-aggregate.output.ts
+++ b/@generated/tag/tag-min-aggregate.output.ts
@@ -3,9 +3,10 @@ import { ObjectType } from '@nestjs/graphql';
 
 @ObjectType()
 export class TagMinAggregate {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => String, { nullable: true })
-  name?: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
+
+    @Field(() => String, {nullable:true})
+    name?: string;
 }
diff --git a/@generated/tag/tag-min-order-by-aggregate.input.ts b/@generated/tag/tag-min-order-by-aggregate.input.ts
index d15ea0d5..5d627462 100644
--- a/@generated/tag/tag-min-order-by-aggregate.input.ts
+++ b/@generated/tag/tag-min-order-by-aggregate.input.ts
@@ -4,9 +4,10 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class TagMinOrderByAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  name?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    name?: keyof typeof SortOrder;
 }
diff --git a/@generated/tag/tag-order-by-relation-aggregate.input.ts b/@generated/tag/tag-order-by-relation-aggregate.input.ts
index 576d1f03..3b8c7622 100644
--- a/@generated/tag/tag-order-by-relation-aggregate.input.ts
+++ b/@generated/tag/tag-order-by-relation-aggregate.input.ts
@@ -4,6 +4,7 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class TagOrderByRelationAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  _count?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    _count?: keyof typeof SortOrder;
 }
diff --git a/@generated/tag/tag-order-by-relevance-field.enum.ts b/@generated/tag/tag-order-by-relevance-field.enum.ts
index 2c04c1fe..4f24bea6 100644
--- a/@generated/tag/tag-order-by-relevance-field.enum.ts
+++ b/@generated/tag/tag-order-by-relevance-field.enum.ts
@@ -1,11 +1,9 @@
 import { registerEnumType } from '@nestjs/graphql';
 
 export enum TagOrderByRelevanceFieldEnum {
-  id = 'id',
-  name = 'name',
+    id = "id",
+    name = "name"
 }
 
-registerEnumType(TagOrderByRelevanceFieldEnum, {
-  name: 'TagOrderByRelevanceFieldEnum',
-  description: undefined,
-});
+
+registerEnumType(TagOrderByRelevanceFieldEnum, { name: 'TagOrderByRelevanceFieldEnum', description: undefined })
diff --git a/@generated/tag/tag-order-by-relevance.input.ts b/@generated/tag/tag-order-by-relevance.input.ts
index b5dd3264..d9af57aa 100644
--- a/@generated/tag/tag-order-by-relevance.input.ts
+++ b/@generated/tag/tag-order-by-relevance.input.ts
@@ -5,12 +5,13 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class TagOrderByRelevanceInput {
-  @Field(() => [TagOrderByRelevanceFieldEnum], { nullable: false })
-  fields!: Array<keyof typeof TagOrderByRelevanceFieldEnum>;
 
-  @Field(() => SortOrder, { nullable: false })
-  sort!: keyof typeof SortOrder;
+    @Field(() => [TagOrderByRelevanceFieldEnum], {nullable:false})
+    fields!: Array<keyof typeof TagOrderByRelevanceFieldEnum>;
 
-  @Field(() => String, { nullable: false })
-  search!: string;
+    @Field(() => SortOrder, {nullable:false})
+    sort!: keyof typeof SortOrder;
+
+    @Field(() => String, {nullable:false})
+    search!: string;
 }
diff --git a/@generated/tag/tag-order-by-with-aggregation.input.ts b/@generated/tag/tag-order-by-with-aggregation.input.ts
index 8768040a..3e1c84e9 100644
--- a/@generated/tag/tag-order-by-with-aggregation.input.ts
+++ b/@generated/tag/tag-order-by-with-aggregation.input.ts
@@ -7,18 +7,19 @@ import { TagMinOrderByAggregateInput } from './tag-min-order-by-aggregate.input'
 
 @InputType()
 export class TagOrderByWithAggregationInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  name?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
 
-  @Field(() => TagCountOrderByAggregateInput, { nullable: true })
-  _count?: TagCountOrderByAggregateInput;
+    @Field(() => SortOrder, {nullable:true})
+    name?: keyof typeof SortOrder;
 
-  @Field(() => TagMaxOrderByAggregateInput, { nullable: true })
-  _max?: TagMaxOrderByAggregateInput;
+    @Field(() => TagCountOrderByAggregateInput, {nullable:true})
+    _count?: TagCountOrderByAggregateInput;
 
-  @Field(() => TagMinOrderByAggregateInput, { nullable: true })
-  _min?: TagMinOrderByAggregateInput;
+    @Field(() => TagMaxOrderByAggregateInput, {nullable:true})
+    _max?: TagMaxOrderByAggregateInput;
+
+    @Field(() => TagMinOrderByAggregateInput, {nullable:true})
+    _min?: TagMinOrderByAggregateInput;
 }
diff --git a/@generated/tag/tag-order-by-with-relation-and-search-relevance.input.ts b/@generated/tag/tag-order-by-with-relation-and-search-relevance.input.ts
index 6aad313f..4ad47e59 100644
--- a/@generated/tag/tag-order-by-with-relation-and-search-relevance.input.ts
+++ b/@generated/tag/tag-order-by-with-relation-and-search-relevance.input.ts
@@ -7,16 +7,17 @@ import { TagOrderByRelevanceInput } from './tag-order-by-relevance.input';
 
 @InputType()
 export class TagOrderByWithRelationAndSearchRelevanceInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  name?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
 
-  @Field(() => ArticleOrderByRelationAggregateInput, { nullable: true })
-  @Type(() => ArticleOrderByRelationAggregateInput)
-  articles?: ArticleOrderByRelationAggregateInput;
+    @Field(() => SortOrder, {nullable:true})
+    name?: keyof typeof SortOrder;
 
-  @Field(() => TagOrderByRelevanceInput, { nullable: true })
-  _relevance?: TagOrderByRelevanceInput;
+    @Field(() => ArticleOrderByRelationAggregateInput, {nullable:true})
+    @Type(() => ArticleOrderByRelationAggregateInput)
+    articles?: ArticleOrderByRelationAggregateInput;
+
+    @Field(() => TagOrderByRelevanceInput, {nullable:true})
+    _relevance?: TagOrderByRelevanceInput;
 }
diff --git a/@generated/tag/tag-scalar-field.enum.ts b/@generated/tag/tag-scalar-field.enum.ts
index e49ca050..b7986f3d 100644
--- a/@generated/tag/tag-scalar-field.enum.ts
+++ b/@generated/tag/tag-scalar-field.enum.ts
@@ -1,11 +1,9 @@
 import { registerEnumType } from '@nestjs/graphql';
 
 export enum TagScalarFieldEnum {
-  id = 'id',
-  name = 'name',
+    id = "id",
+    name = "name"
 }
 
-registerEnumType(TagScalarFieldEnum, {
-  name: 'TagScalarFieldEnum',
-  description: undefined,
-});
+
+registerEnumType(TagScalarFieldEnum, { name: 'TagScalarFieldEnum', description: undefined })
diff --git a/@generated/tag/tag-scalar-where-with-aggregates.input.ts b/@generated/tag/tag-scalar-where-with-aggregates.input.ts
index df8e2014..8e932148 100644
--- a/@generated/tag/tag-scalar-where-with-aggregates.input.ts
+++ b/@generated/tag/tag-scalar-where-with-aggregates.input.ts
@@ -4,18 +4,19 @@ import { StringWithAggregatesFilter } from '../prisma/string-with-aggregates-fil
 
 @InputType()
 export class TagScalarWhereWithAggregatesInput {
-  @Field(() => [TagScalarWhereWithAggregatesInput], { nullable: true })
-  AND?: Array<TagScalarWhereWithAggregatesInput>;
 
-  @Field(() => [TagScalarWhereWithAggregatesInput], { nullable: true })
-  OR?: Array<TagScalarWhereWithAggregatesInput>;
+    @Field(() => [TagScalarWhereWithAggregatesInput], {nullable:true})
+    AND?: Array<TagScalarWhereWithAggregatesInput>;
 
-  @Field(() => [TagScalarWhereWithAggregatesInput], { nullable: true })
-  NOT?: Array<TagScalarWhereWithAggregatesInput>;
+    @Field(() => [TagScalarWhereWithAggregatesInput], {nullable:true})
+    OR?: Array<TagScalarWhereWithAggregatesInput>;
 
-  @Field(() => StringWithAggregatesFilter, { nullable: true })
-  id?: StringWithAggregatesFilter;
+    @Field(() => [TagScalarWhereWithAggregatesInput], {nullable:true})
+    NOT?: Array<TagScalarWhereWithAggregatesInput>;
 
-  @Field(() => StringWithAggregatesFilter, { nullable: true })
-  name?: StringWithAggregatesFilter;
+    @Field(() => StringWithAggregatesFilter, {nullable:true})
+    id?: StringWithAggregatesFilter;
+
+    @Field(() => StringWithAggregatesFilter, {nullable:true})
+    name?: StringWithAggregatesFilter;
 }
diff --git a/@generated/tag/tag-scalar-where.input.ts b/@generated/tag/tag-scalar-where.input.ts
index eab7bb2a..d0bcc269 100644
--- a/@generated/tag/tag-scalar-where.input.ts
+++ b/@generated/tag/tag-scalar-where.input.ts
@@ -4,18 +4,19 @@ import { StringFilter } from '../prisma/string-filter.input';
 
 @InputType()
 export class TagScalarWhereInput {
-  @Field(() => [TagScalarWhereInput], { nullable: true })
-  AND?: Array<TagScalarWhereInput>;
 
-  @Field(() => [TagScalarWhereInput], { nullable: true })
-  OR?: Array<TagScalarWhereInput>;
+    @Field(() => [TagScalarWhereInput], {nullable:true})
+    AND?: Array<TagScalarWhereInput>;
 
-  @Field(() => [TagScalarWhereInput], { nullable: true })
-  NOT?: Array<TagScalarWhereInput>;
+    @Field(() => [TagScalarWhereInput], {nullable:true})
+    OR?: Array<TagScalarWhereInput>;
 
-  @Field(() => StringFilter, { nullable: true })
-  id?: StringFilter;
+    @Field(() => [TagScalarWhereInput], {nullable:true})
+    NOT?: Array<TagScalarWhereInput>;
 
-  @Field(() => StringFilter, { nullable: true })
-  name?: StringFilter;
+    @Field(() => StringFilter, {nullable:true})
+    id?: StringFilter;
+
+    @Field(() => StringFilter, {nullable:true})
+    name?: StringFilter;
 }
diff --git a/@generated/tag/tag-unchecked-create-nested-many-without-articles.input.ts b/@generated/tag/tag-unchecked-create-nested-many-without-articles.input.ts
index b18d0b38..3bf9f9a8 100644
--- a/@generated/tag/tag-unchecked-create-nested-many-without-articles.input.ts
+++ b/@generated/tag/tag-unchecked-create-nested-many-without-articles.input.ts
@@ -3,20 +3,21 @@ import { InputType } from '@nestjs/graphql';
 import { TagCreateWithoutArticlesInput } from './tag-create-without-articles.input';
 import { Type } from 'class-transformer';
 import { TagCreateOrConnectWithoutArticlesInput } from './tag-create-or-connect-without-articles.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { TagWhereUniqueInput } from './tag-where-unique.input';
 
 @InputType()
 export class TagUncheckedCreateNestedManyWithoutArticlesInput {
-  @Field(() => [TagCreateWithoutArticlesInput], { nullable: true })
-  @Type(() => TagCreateWithoutArticlesInput)
-  create?: Array<TagCreateWithoutArticlesInput>;
 
-  @Field(() => [TagCreateOrConnectWithoutArticlesInput], { nullable: true })
-  @Type(() => TagCreateOrConnectWithoutArticlesInput)
-  connectOrCreate?: Array<TagCreateOrConnectWithoutArticlesInput>;
+    @Field(() => [TagCreateWithoutArticlesInput], {nullable:true})
+    @Type(() => TagCreateWithoutArticlesInput)
+    create?: Array<TagCreateWithoutArticlesInput>;
 
-  @Field(() => [TagWhereUniqueInput], { nullable: true })
-  @Type(() => TagWhereUniqueInput)
-  connect?: Array<Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>>;
+    @Field(() => [TagCreateOrConnectWithoutArticlesInput], {nullable:true})
+    @Type(() => TagCreateOrConnectWithoutArticlesInput)
+    connectOrCreate?: Array<TagCreateOrConnectWithoutArticlesInput>;
+
+    @Field(() => [TagWhereUniqueInput], {nullable:true})
+    @Type(() => TagWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>>;
 }
diff --git a/@generated/tag/tag-unchecked-create-without-articles.input.ts b/@generated/tag/tag-unchecked-create-without-articles.input.ts
index 31b42f36..2f4d0faf 100644
--- a/@generated/tag/tag-unchecked-create-without-articles.input.ts
+++ b/@generated/tag/tag-unchecked-create-without-articles.input.ts
@@ -3,9 +3,10 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class TagUncheckedCreateWithoutArticlesInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => String, { nullable: false })
-  name!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
+
+    @Field(() => String, {nullable:false})
+    name!: string;
 }
diff --git a/@generated/tag/tag-unchecked-create.input.ts b/@generated/tag/tag-unchecked-create.input.ts
index 1604edf7..fe5d428f 100644
--- a/@generated/tag/tag-unchecked-create.input.ts
+++ b/@generated/tag/tag-unchecked-create.input.ts
@@ -5,13 +5,14 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class TagUncheckedCreateInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => String, { nullable: false })
-  name!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => ArticleUncheckedCreateNestedManyWithoutTagsInput, { nullable: true })
-  @Type(() => ArticleUncheckedCreateNestedManyWithoutTagsInput)
-  articles?: ArticleUncheckedCreateNestedManyWithoutTagsInput;
+    @Field(() => String, {nullable:false})
+    name!: string;
+
+    @Field(() => ArticleUncheckedCreateNestedManyWithoutTagsInput, {nullable:true})
+    @Type(() => ArticleUncheckedCreateNestedManyWithoutTagsInput)
+    articles?: ArticleUncheckedCreateNestedManyWithoutTagsInput;
 }
diff --git a/@generated/tag/tag-unchecked-update-many-without-articles-nested.input.ts b/@generated/tag/tag-unchecked-update-many-without-articles-nested.input.ts
index b537ad62..985bfc19 100644
--- a/@generated/tag/tag-unchecked-update-many-without-articles-nested.input.ts
+++ b/@generated/tag/tag-unchecked-update-many-without-articles-nested.input.ts
@@ -4,7 +4,7 @@ import { TagCreateWithoutArticlesInput } from './tag-create-without-articles.inp
 import { Type } from 'class-transformer';
 import { TagCreateOrConnectWithoutArticlesInput } from './tag-create-or-connect-without-articles.input';
 import { TagUpsertWithWhereUniqueWithoutArticlesInput } from './tag-upsert-with-where-unique-without-articles.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { TagWhereUniqueInput } from './tag-where-unique.input';
 import { TagUpdateWithWhereUniqueWithoutArticlesInput } from './tag-update-with-where-unique-without-articles.input';
 import { TagUpdateManyWithWhereWithoutArticlesInput } from './tag-update-many-with-where-without-articles.input';
@@ -12,43 +12,44 @@ import { TagScalarWhereInput } from './tag-scalar-where.input';
 
 @InputType()
 export class TagUncheckedUpdateManyWithoutArticlesNestedInput {
-  @Field(() => [TagCreateWithoutArticlesInput], { nullable: true })
-  @Type(() => TagCreateWithoutArticlesInput)
-  create?: Array<TagCreateWithoutArticlesInput>;
 
-  @Field(() => [TagCreateOrConnectWithoutArticlesInput], { nullable: true })
-  @Type(() => TagCreateOrConnectWithoutArticlesInput)
-  connectOrCreate?: Array<TagCreateOrConnectWithoutArticlesInput>;
+    @Field(() => [TagCreateWithoutArticlesInput], {nullable:true})
+    @Type(() => TagCreateWithoutArticlesInput)
+    create?: Array<TagCreateWithoutArticlesInput>;
 
-  @Field(() => [TagUpsertWithWhereUniqueWithoutArticlesInput], { nullable: true })
-  @Type(() => TagUpsertWithWhereUniqueWithoutArticlesInput)
-  upsert?: Array<TagUpsertWithWhereUniqueWithoutArticlesInput>;
+    @Field(() => [TagCreateOrConnectWithoutArticlesInput], {nullable:true})
+    @Type(() => TagCreateOrConnectWithoutArticlesInput)
+    connectOrCreate?: Array<TagCreateOrConnectWithoutArticlesInput>;
 
-  @Field(() => [TagWhereUniqueInput], { nullable: true })
-  @Type(() => TagWhereUniqueInput)
-  set?: Array<Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>>;
+    @Field(() => [TagUpsertWithWhereUniqueWithoutArticlesInput], {nullable:true})
+    @Type(() => TagUpsertWithWhereUniqueWithoutArticlesInput)
+    upsert?: Array<TagUpsertWithWhereUniqueWithoutArticlesInput>;
 
-  @Field(() => [TagWhereUniqueInput], { nullable: true })
-  @Type(() => TagWhereUniqueInput)
-  disconnect?: Array<Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>>;
+    @Field(() => [TagWhereUniqueInput], {nullable:true})
+    @Type(() => TagWhereUniqueInput)
+    set?: Array<Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>>;
 
-  @Field(() => [TagWhereUniqueInput], { nullable: true })
-  @Type(() => TagWhereUniqueInput)
-  delete?: Array<Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>>;
+    @Field(() => [TagWhereUniqueInput], {nullable:true})
+    @Type(() => TagWhereUniqueInput)
+    disconnect?: Array<Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>>;
 
-  @Field(() => [TagWhereUniqueInput], { nullable: true })
-  @Type(() => TagWhereUniqueInput)
-  connect?: Array<Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>>;
+    @Field(() => [TagWhereUniqueInput], {nullable:true})
+    @Type(() => TagWhereUniqueInput)
+    delete?: Array<Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>>;
 
-  @Field(() => [TagUpdateWithWhereUniqueWithoutArticlesInput], { nullable: true })
-  @Type(() => TagUpdateWithWhereUniqueWithoutArticlesInput)
-  update?: Array<TagUpdateWithWhereUniqueWithoutArticlesInput>;
+    @Field(() => [TagWhereUniqueInput], {nullable:true})
+    @Type(() => TagWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>>;
 
-  @Field(() => [TagUpdateManyWithWhereWithoutArticlesInput], { nullable: true })
-  @Type(() => TagUpdateManyWithWhereWithoutArticlesInput)
-  updateMany?: Array<TagUpdateManyWithWhereWithoutArticlesInput>;
+    @Field(() => [TagUpdateWithWhereUniqueWithoutArticlesInput], {nullable:true})
+    @Type(() => TagUpdateWithWhereUniqueWithoutArticlesInput)
+    update?: Array<TagUpdateWithWhereUniqueWithoutArticlesInput>;
 
-  @Field(() => [TagScalarWhereInput], { nullable: true })
-  @Type(() => TagScalarWhereInput)
-  deleteMany?: Array<TagScalarWhereInput>;
+    @Field(() => [TagUpdateManyWithWhereWithoutArticlesInput], {nullable:true})
+    @Type(() => TagUpdateManyWithWhereWithoutArticlesInput)
+    updateMany?: Array<TagUpdateManyWithWhereWithoutArticlesInput>;
+
+    @Field(() => [TagScalarWhereInput], {nullable:true})
+    @Type(() => TagScalarWhereInput)
+    deleteMany?: Array<TagScalarWhereInput>;
 }
diff --git a/@generated/tag/tag-unchecked-update-many-without-articles.input.ts b/@generated/tag/tag-unchecked-update-many-without-articles.input.ts
index fc60ad44..eb228873 100644
--- a/@generated/tag/tag-unchecked-update-many-without-articles.input.ts
+++ b/@generated/tag/tag-unchecked-update-many-without-articles.input.ts
@@ -4,9 +4,10 @@ import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-
 
 @InputType()
 export class TagUncheckedUpdateManyWithoutArticlesInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  name?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
+
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    name?: StringFieldUpdateOperationsInput;
 }
diff --git a/@generated/tag/tag-unchecked-update-many.input.ts b/@generated/tag/tag-unchecked-update-many.input.ts
index 92dcbb15..b385ab44 100644
--- a/@generated/tag/tag-unchecked-update-many.input.ts
+++ b/@generated/tag/tag-unchecked-update-many.input.ts
@@ -4,9 +4,10 @@ import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-
 
 @InputType()
 export class TagUncheckedUpdateManyInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  name?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
+
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    name?: StringFieldUpdateOperationsInput;
 }
diff --git a/@generated/tag/tag-unchecked-update-without-articles.input.ts b/@generated/tag/tag-unchecked-update-without-articles.input.ts
index ee1b6a8b..65b11a66 100644
--- a/@generated/tag/tag-unchecked-update-without-articles.input.ts
+++ b/@generated/tag/tag-unchecked-update-without-articles.input.ts
@@ -4,9 +4,10 @@ import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-
 
 @InputType()
 export class TagUncheckedUpdateWithoutArticlesInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  name?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
+
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    name?: StringFieldUpdateOperationsInput;
 }
diff --git a/@generated/tag/tag-unchecked-update.input.ts b/@generated/tag/tag-unchecked-update.input.ts
index 526359a4..6c676a22 100644
--- a/@generated/tag/tag-unchecked-update.input.ts
+++ b/@generated/tag/tag-unchecked-update.input.ts
@@ -6,13 +6,14 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class TagUncheckedUpdateInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  name?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => ArticleUncheckedUpdateManyWithoutTagsNestedInput, { nullable: true })
-  @Type(() => ArticleUncheckedUpdateManyWithoutTagsNestedInput)
-  articles?: ArticleUncheckedUpdateManyWithoutTagsNestedInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    name?: StringFieldUpdateOperationsInput;
+
+    @Field(() => ArticleUncheckedUpdateManyWithoutTagsNestedInput, {nullable:true})
+    @Type(() => ArticleUncheckedUpdateManyWithoutTagsNestedInput)
+    articles?: ArticleUncheckedUpdateManyWithoutTagsNestedInput;
 }
diff --git a/@generated/tag/tag-update-many-mutation.input.ts b/@generated/tag/tag-update-many-mutation.input.ts
index 57a402fa..231184b6 100644
--- a/@generated/tag/tag-update-many-mutation.input.ts
+++ b/@generated/tag/tag-update-many-mutation.input.ts
@@ -4,9 +4,10 @@ import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-
 
 @InputType()
 export class TagUpdateManyMutationInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  name?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
+
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    name?: StringFieldUpdateOperationsInput;
 }
diff --git a/@generated/tag/tag-update-many-with-where-without-articles.input.ts b/@generated/tag/tag-update-many-with-where-without-articles.input.ts
index 484a6923..0d7289e2 100644
--- a/@generated/tag/tag-update-many-with-where-without-articles.input.ts
+++ b/@generated/tag/tag-update-many-with-where-without-articles.input.ts
@@ -6,11 +6,12 @@ import { TagUpdateManyMutationInput } from './tag-update-many-mutation.input';
 
 @InputType()
 export class TagUpdateManyWithWhereWithoutArticlesInput {
-  @Field(() => TagScalarWhereInput, { nullable: false })
-  @Type(() => TagScalarWhereInput)
-  where!: TagScalarWhereInput;
 
-  @Field(() => TagUpdateManyMutationInput, { nullable: false })
-  @Type(() => TagUpdateManyMutationInput)
-  data!: TagUpdateManyMutationInput;
+    @Field(() => TagScalarWhereInput, {nullable:false})
+    @Type(() => TagScalarWhereInput)
+    where!: TagScalarWhereInput;
+
+    @Field(() => TagUpdateManyMutationInput, {nullable:false})
+    @Type(() => TagUpdateManyMutationInput)
+    data!: TagUpdateManyMutationInput;
 }
diff --git a/@generated/tag/tag-update-many-without-articles-nested.input.ts b/@generated/tag/tag-update-many-without-articles-nested.input.ts
index 4419283c..bd0ac65d 100644
--- a/@generated/tag/tag-update-many-without-articles-nested.input.ts
+++ b/@generated/tag/tag-update-many-without-articles-nested.input.ts
@@ -4,7 +4,7 @@ import { TagCreateWithoutArticlesInput } from './tag-create-without-articles.inp
 import { Type } from 'class-transformer';
 import { TagCreateOrConnectWithoutArticlesInput } from './tag-create-or-connect-without-articles.input';
 import { TagUpsertWithWhereUniqueWithoutArticlesInput } from './tag-upsert-with-where-unique-without-articles.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { TagWhereUniqueInput } from './tag-where-unique.input';
 import { TagUpdateWithWhereUniqueWithoutArticlesInput } from './tag-update-with-where-unique-without-articles.input';
 import { TagUpdateManyWithWhereWithoutArticlesInput } from './tag-update-many-with-where-without-articles.input';
@@ -12,43 +12,44 @@ import { TagScalarWhereInput } from './tag-scalar-where.input';
 
 @InputType()
 export class TagUpdateManyWithoutArticlesNestedInput {
-  @Field(() => [TagCreateWithoutArticlesInput], { nullable: true })
-  @Type(() => TagCreateWithoutArticlesInput)
-  create?: Array<TagCreateWithoutArticlesInput>;
 
-  @Field(() => [TagCreateOrConnectWithoutArticlesInput], { nullable: true })
-  @Type(() => TagCreateOrConnectWithoutArticlesInput)
-  connectOrCreate?: Array<TagCreateOrConnectWithoutArticlesInput>;
+    @Field(() => [TagCreateWithoutArticlesInput], {nullable:true})
+    @Type(() => TagCreateWithoutArticlesInput)
+    create?: Array<TagCreateWithoutArticlesInput>;
 
-  @Field(() => [TagUpsertWithWhereUniqueWithoutArticlesInput], { nullable: true })
-  @Type(() => TagUpsertWithWhereUniqueWithoutArticlesInput)
-  upsert?: Array<TagUpsertWithWhereUniqueWithoutArticlesInput>;
+    @Field(() => [TagCreateOrConnectWithoutArticlesInput], {nullable:true})
+    @Type(() => TagCreateOrConnectWithoutArticlesInput)
+    connectOrCreate?: Array<TagCreateOrConnectWithoutArticlesInput>;
 
-  @Field(() => [TagWhereUniqueInput], { nullable: true })
-  @Type(() => TagWhereUniqueInput)
-  set?: Array<Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>>;
+    @Field(() => [TagUpsertWithWhereUniqueWithoutArticlesInput], {nullable:true})
+    @Type(() => TagUpsertWithWhereUniqueWithoutArticlesInput)
+    upsert?: Array<TagUpsertWithWhereUniqueWithoutArticlesInput>;
 
-  @Field(() => [TagWhereUniqueInput], { nullable: true })
-  @Type(() => TagWhereUniqueInput)
-  disconnect?: Array<Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>>;
+    @Field(() => [TagWhereUniqueInput], {nullable:true})
+    @Type(() => TagWhereUniqueInput)
+    set?: Array<Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>>;
 
-  @Field(() => [TagWhereUniqueInput], { nullable: true })
-  @Type(() => TagWhereUniqueInput)
-  delete?: Array<Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>>;
+    @Field(() => [TagWhereUniqueInput], {nullable:true})
+    @Type(() => TagWhereUniqueInput)
+    disconnect?: Array<Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>>;
 
-  @Field(() => [TagWhereUniqueInput], { nullable: true })
-  @Type(() => TagWhereUniqueInput)
-  connect?: Array<Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>>;
+    @Field(() => [TagWhereUniqueInput], {nullable:true})
+    @Type(() => TagWhereUniqueInput)
+    delete?: Array<Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>>;
 
-  @Field(() => [TagUpdateWithWhereUniqueWithoutArticlesInput], { nullable: true })
-  @Type(() => TagUpdateWithWhereUniqueWithoutArticlesInput)
-  update?: Array<TagUpdateWithWhereUniqueWithoutArticlesInput>;
+    @Field(() => [TagWhereUniqueInput], {nullable:true})
+    @Type(() => TagWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>>;
 
-  @Field(() => [TagUpdateManyWithWhereWithoutArticlesInput], { nullable: true })
-  @Type(() => TagUpdateManyWithWhereWithoutArticlesInput)
-  updateMany?: Array<TagUpdateManyWithWhereWithoutArticlesInput>;
+    @Field(() => [TagUpdateWithWhereUniqueWithoutArticlesInput], {nullable:true})
+    @Type(() => TagUpdateWithWhereUniqueWithoutArticlesInput)
+    update?: Array<TagUpdateWithWhereUniqueWithoutArticlesInput>;
 
-  @Field(() => [TagScalarWhereInput], { nullable: true })
-  @Type(() => TagScalarWhereInput)
-  deleteMany?: Array<TagScalarWhereInput>;
+    @Field(() => [TagUpdateManyWithWhereWithoutArticlesInput], {nullable:true})
+    @Type(() => TagUpdateManyWithWhereWithoutArticlesInput)
+    updateMany?: Array<TagUpdateManyWithWhereWithoutArticlesInput>;
+
+    @Field(() => [TagScalarWhereInput], {nullable:true})
+    @Type(() => TagScalarWhereInput)
+    deleteMany?: Array<TagScalarWhereInput>;
 }
diff --git a/@generated/tag/tag-update-with-where-unique-without-articles.input.ts b/@generated/tag/tag-update-with-where-unique-without-articles.input.ts
index 95269789..98c40420 100644
--- a/@generated/tag/tag-update-with-where-unique-without-articles.input.ts
+++ b/@generated/tag/tag-update-with-where-unique-without-articles.input.ts
@@ -1,17 +1,18 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { TagWhereUniqueInput } from './tag-where-unique.input';
 import { Type } from 'class-transformer';
 import { TagUpdateWithoutArticlesInput } from './tag-update-without-articles.input';
 
 @InputType()
 export class TagUpdateWithWhereUniqueWithoutArticlesInput {
-  @Field(() => TagWhereUniqueInput, { nullable: false })
-  @Type(() => TagWhereUniqueInput)
-  where!: Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>;
 
-  @Field(() => TagUpdateWithoutArticlesInput, { nullable: false })
-  @Type(() => TagUpdateWithoutArticlesInput)
-  data!: TagUpdateWithoutArticlesInput;
+    @Field(() => TagWhereUniqueInput, {nullable:false})
+    @Type(() => TagWhereUniqueInput)
+    where!: Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>;
+
+    @Field(() => TagUpdateWithoutArticlesInput, {nullable:false})
+    @Type(() => TagUpdateWithoutArticlesInput)
+    data!: TagUpdateWithoutArticlesInput;
 }
diff --git a/@generated/tag/tag-update-without-articles.input.ts b/@generated/tag/tag-update-without-articles.input.ts
index 66f81a2c..ce5e0eaa 100644
--- a/@generated/tag/tag-update-without-articles.input.ts
+++ b/@generated/tag/tag-update-without-articles.input.ts
@@ -4,9 +4,10 @@ import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-
 
 @InputType()
 export class TagUpdateWithoutArticlesInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  name?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
+
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    name?: StringFieldUpdateOperationsInput;
 }
diff --git a/@generated/tag/tag-update.input.ts b/@generated/tag/tag-update.input.ts
index f8d36472..189a342d 100644
--- a/@generated/tag/tag-update.input.ts
+++ b/@generated/tag/tag-update.input.ts
@@ -6,13 +6,14 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class TagUpdateInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  name?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => ArticleUpdateManyWithoutTagsNestedInput, { nullable: true })
-  @Type(() => ArticleUpdateManyWithoutTagsNestedInput)
-  articles?: ArticleUpdateManyWithoutTagsNestedInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    name?: StringFieldUpdateOperationsInput;
+
+    @Field(() => ArticleUpdateManyWithoutTagsNestedInput, {nullable:true})
+    @Type(() => ArticleUpdateManyWithoutTagsNestedInput)
+    articles?: ArticleUpdateManyWithoutTagsNestedInput;
 }
diff --git a/@generated/tag/tag-upsert-with-where-unique-without-articles.input.ts b/@generated/tag/tag-upsert-with-where-unique-without-articles.input.ts
index 2d3a4b78..44d2dbf3 100644
--- a/@generated/tag/tag-upsert-with-where-unique-without-articles.input.ts
+++ b/@generated/tag/tag-upsert-with-where-unique-without-articles.input.ts
@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { TagWhereUniqueInput } from './tag-where-unique.input';
 import { Type } from 'class-transformer';
 import { TagUpdateWithoutArticlesInput } from './tag-update-without-articles.input';
@@ -8,15 +8,16 @@ import { TagCreateWithoutArticlesInput } from './tag-create-without-articles.inp
 
 @InputType()
 export class TagUpsertWithWhereUniqueWithoutArticlesInput {
-  @Field(() => TagWhereUniqueInput, { nullable: false })
-  @Type(() => TagWhereUniqueInput)
-  where!: Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>;
 
-  @Field(() => TagUpdateWithoutArticlesInput, { nullable: false })
-  @Type(() => TagUpdateWithoutArticlesInput)
-  update!: TagUpdateWithoutArticlesInput;
+    @Field(() => TagWhereUniqueInput, {nullable:false})
+    @Type(() => TagWhereUniqueInput)
+    where!: Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>;
 
-  @Field(() => TagCreateWithoutArticlesInput, { nullable: false })
-  @Type(() => TagCreateWithoutArticlesInput)
-  create!: TagCreateWithoutArticlesInput;
+    @Field(() => TagUpdateWithoutArticlesInput, {nullable:false})
+    @Type(() => TagUpdateWithoutArticlesInput)
+    update!: TagUpdateWithoutArticlesInput;
+
+    @Field(() => TagCreateWithoutArticlesInput, {nullable:false})
+    @Type(() => TagCreateWithoutArticlesInput)
+    create!: TagCreateWithoutArticlesInput;
 }
diff --git a/@generated/tag/tag-where-unique.input.ts b/@generated/tag/tag-where-unique.input.ts
index 7c091b37..0c3faea5 100644
--- a/@generated/tag/tag-where-unique.input.ts
+++ b/@generated/tag/tag-where-unique.input.ts
@@ -6,22 +6,23 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class TagWhereUniqueInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => String, { nullable: true })
-  name?: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => [TagWhereInput], { nullable: true })
-  AND?: Array<TagWhereInput>;
+    @Field(() => String, {nullable:true})
+    name?: string;
 
-  @Field(() => [TagWhereInput], { nullable: true })
-  OR?: Array<TagWhereInput>;
+    @Field(() => [TagWhereInput], {nullable:true})
+    AND?: Array<TagWhereInput>;
 
-  @Field(() => [TagWhereInput], { nullable: true })
-  NOT?: Array<TagWhereInput>;
+    @Field(() => [TagWhereInput], {nullable:true})
+    OR?: Array<TagWhereInput>;
 
-  @Field(() => ArticleListRelationFilter, { nullable: true })
-  @Type(() => ArticleListRelationFilter)
-  articles?: ArticleListRelationFilter;
+    @Field(() => [TagWhereInput], {nullable:true})
+    NOT?: Array<TagWhereInput>;
+
+    @Field(() => ArticleListRelationFilter, {nullable:true})
+    @Type(() => ArticleListRelationFilter)
+    articles?: ArticleListRelationFilter;
 }
diff --git a/@generated/tag/tag-where.input.ts b/@generated/tag/tag-where.input.ts
index 81bb5c06..8b47aca8 100644
--- a/@generated/tag/tag-where.input.ts
+++ b/@generated/tag/tag-where.input.ts
@@ -6,22 +6,23 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class TagWhereInput {
-  @Field(() => [TagWhereInput], { nullable: true })
-  AND?: Array<TagWhereInput>;
 
-  @Field(() => [TagWhereInput], { nullable: true })
-  OR?: Array<TagWhereInput>;
+    @Field(() => [TagWhereInput], {nullable:true})
+    AND?: Array<TagWhereInput>;
 
-  @Field(() => [TagWhereInput], { nullable: true })
-  NOT?: Array<TagWhereInput>;
+    @Field(() => [TagWhereInput], {nullable:true})
+    OR?: Array<TagWhereInput>;
 
-  @Field(() => StringFilter, { nullable: true })
-  id?: StringFilter;
+    @Field(() => [TagWhereInput], {nullable:true})
+    NOT?: Array<TagWhereInput>;
 
-  @Field(() => StringFilter, { nullable: true })
-  name?: StringFilter;
+    @Field(() => StringFilter, {nullable:true})
+    id?: StringFilter;
 
-  @Field(() => ArticleListRelationFilter, { nullable: true })
-  @Type(() => ArticleListRelationFilter)
-  articles?: ArticleListRelationFilter;
+    @Field(() => StringFilter, {nullable:true})
+    name?: StringFilter;
+
+    @Field(() => ArticleListRelationFilter, {nullable:true})
+    @Type(() => ArticleListRelationFilter)
+    articles?: ArticleListRelationFilter;
 }
diff --git a/@generated/tag/tag.model.ts b/@generated/tag/tag.model.ts
index 04baf382..774c8e47 100644
--- a/@generated/tag/tag.model.ts
+++ b/@generated/tag/tag.model.ts
@@ -6,15 +6,16 @@ import { TagCount } from './tag-count.output';
 
 @ObjectType()
 export class Tag {
-  @Field(() => ID, { nullable: false })
-  id!: string;
 
-  @Field(() => String, { nullable: false })
-  name!: string;
+    @Field(() => ID, {nullable:false})
+    id!: string;
 
-  @Field(() => [Article], { nullable: true })
-  articles?: Array<Article>;
+    @Field(() => String, {nullable:false})
+    name!: string;
 
-  @Field(() => TagCount, { nullable: false })
-  _count?: TagCount;
+    @Field(() => [Article], {nullable:true})
+    articles?: Array<Article>;
+
+    @Field(() => TagCount, {nullable:false})
+    _count?: TagCount;
 }
diff --git a/@generated/tag/update-many-tag.args.ts b/@generated/tag/update-many-tag.args.ts
index 0bfef0a0..c99ec83e 100644
--- a/@generated/tag/update-many-tag.args.ts
+++ b/@generated/tag/update-many-tag.args.ts
@@ -6,11 +6,12 @@ import { TagWhereInput } from './tag-where.input';
 
 @ArgsType()
 export class UpdateManyTagArgs {
-  @Field(() => TagUpdateManyMutationInput, { nullable: false })
-  @Type(() => TagUpdateManyMutationInput)
-  data!: TagUpdateManyMutationInput;
 
-  @Field(() => TagWhereInput, { nullable: true })
-  @Type(() => TagWhereInput)
-  where?: TagWhereInput;
+    @Field(() => TagUpdateManyMutationInput, {nullable:false})
+    @Type(() => TagUpdateManyMutationInput)
+    data!: TagUpdateManyMutationInput;
+
+    @Field(() => TagWhereInput, {nullable:true})
+    @Type(() => TagWhereInput)
+    where?: TagWhereInput;
 }
diff --git a/@generated/tag/update-one-tag.args.ts b/@generated/tag/update-one-tag.args.ts
index 0ccba4cc..9338a335 100644
--- a/@generated/tag/update-one-tag.args.ts
+++ b/@generated/tag/update-one-tag.args.ts
@@ -2,16 +2,17 @@ import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
 import { TagUpdateInput } from './tag-update.input';
 import { Type } from 'class-transformer';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { TagWhereUniqueInput } from './tag-where-unique.input';
 
 @ArgsType()
 export class UpdateOneTagArgs {
-  @Field(() => TagUpdateInput, { nullable: false })
-  @Type(() => TagUpdateInput)
-  data!: TagUpdateInput;
 
-  @Field(() => TagWhereUniqueInput, { nullable: false })
-  @Type(() => TagWhereUniqueInput)
-  where!: Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>;
+    @Field(() => TagUpdateInput, {nullable:false})
+    @Type(() => TagUpdateInput)
+    data!: TagUpdateInput;
+
+    @Field(() => TagWhereUniqueInput, {nullable:false})
+    @Type(() => TagWhereUniqueInput)
+    where!: Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>;
 }
diff --git a/@generated/tag/upsert-one-tag.args.ts b/@generated/tag/upsert-one-tag.args.ts
index 5f126b69..b36d814a 100644
--- a/@generated/tag/upsert-one-tag.args.ts
+++ b/@generated/tag/upsert-one-tag.args.ts
@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { TagWhereUniqueInput } from './tag-where-unique.input';
 import { Type } from 'class-transformer';
 import { TagCreateInput } from './tag-create.input';
@@ -8,15 +8,16 @@ import { TagUpdateInput } from './tag-update.input';
 
 @ArgsType()
 export class UpsertOneTagArgs {
-  @Field(() => TagWhereUniqueInput, { nullable: false })
-  @Type(() => TagWhereUniqueInput)
-  where!: Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>;
 
-  @Field(() => TagCreateInput, { nullable: false })
-  @Type(() => TagCreateInput)
-  create!: TagCreateInput;
+    @Field(() => TagWhereUniqueInput, {nullable:false})
+    @Type(() => TagWhereUniqueInput)
+    where!: Prisma.AtLeast<TagWhereUniqueInput, 'id' | 'name'>;
 
-  @Field(() => TagUpdateInput, { nullable: false })
-  @Type(() => TagUpdateInput)
-  update!: TagUpdateInput;
+    @Field(() => TagCreateInput, {nullable:false})
+    @Type(() => TagCreateInput)
+    create!: TagCreateInput;
+
+    @Field(() => TagUpdateInput, {nullable:false})
+    @Type(() => TagUpdateInput)
+    update!: TagUpdateInput;
 }
diff --git a/@generated/user/aggregate-user.output.ts b/@generated/user/aggregate-user.output.ts
index e4980e71..4dd46934 100644
--- a/@generated/user/aggregate-user.output.ts
+++ b/@generated/user/aggregate-user.output.ts
@@ -8,18 +8,19 @@ import { UserMaxAggregate } from './user-max-aggregate.output';
 
 @ObjectType()
 export class AggregateUser {
-  @Field(() => UserCountAggregate, { nullable: true })
-  _count?: UserCountAggregate;
 
-  @Field(() => UserAvgAggregate, { nullable: true })
-  _avg?: UserAvgAggregate;
+    @Field(() => UserCountAggregate, {nullable:true})
+    _count?: UserCountAggregate;
 
-  @Field(() => UserSumAggregate, { nullable: true })
-  _sum?: UserSumAggregate;
+    @Field(() => UserAvgAggregate, {nullable:true})
+    _avg?: UserAvgAggregate;
 
-  @Field(() => UserMinAggregate, { nullable: true })
-  _min?: UserMinAggregate;
+    @Field(() => UserSumAggregate, {nullable:true})
+    _sum?: UserSumAggregate;
 
-  @Field(() => UserMaxAggregate, { nullable: true })
-  _max?: UserMaxAggregate;
+    @Field(() => UserMinAggregate, {nullable:true})
+    _min?: UserMinAggregate;
+
+    @Field(() => UserMaxAggregate, {nullable:true})
+    _max?: UserMaxAggregate;
 }
diff --git a/@generated/user/create-many-user.args.ts b/@generated/user/create-many-user.args.ts
index b013d6bf..c08bf8ae 100644
--- a/@generated/user/create-many-user.args.ts
+++ b/@generated/user/create-many-user.args.ts
@@ -6,12 +6,13 @@ import { ValidateNested } from 'class-validator';
 
 @ArgsType()
 export class CreateManyUserArgs {
-  @Field(() => [UserCreateManyInput], { nullable: false })
-  @Type(() => UserCreateManyInput)
-  @ValidateNested()
-  @Type(() => UserCreateManyInput)
-  data!: Array<UserCreateManyInput>;
 
-  @Field(() => Boolean, { nullable: true })
-  skipDuplicates?: boolean;
+    @Field(() => [UserCreateManyInput], {nullable:false})
+    @Type(() => UserCreateManyInput)
+    @ValidateNested()
+    @Type(() => UserCreateManyInput)
+    data!: Array<UserCreateManyInput>;
+
+    @Field(() => Boolean, {nullable:true})
+    skipDuplicates?: boolean;
 }
diff --git a/@generated/user/create-one-user.args.ts b/@generated/user/create-one-user.args.ts
index 2b4df64c..f8d4609b 100644
--- a/@generated/user/create-one-user.args.ts
+++ b/@generated/user/create-one-user.args.ts
@@ -6,9 +6,10 @@ import { ValidateNested } from 'class-validator';
 
 @ArgsType()
 export class CreateOneUserArgs {
-  @Field(() => UserCreateInput, { nullable: false })
-  @Type(() => UserCreateInput)
-  @ValidateNested()
-  @Type(() => UserCreateInput)
-  data!: UserCreateInput;
+
+    @Field(() => UserCreateInput, {nullable:false})
+    @Type(() => UserCreateInput)
+    @ValidateNested()
+    @Type(() => UserCreateInput)
+    data!: UserCreateInput;
 }
diff --git a/@generated/user/delete-many-user.args.ts b/@generated/user/delete-many-user.args.ts
index 1413038b..ea7bbd01 100644
--- a/@generated/user/delete-many-user.args.ts
+++ b/@generated/user/delete-many-user.args.ts
@@ -5,7 +5,8 @@ import { Type } from 'class-transformer';
 
 @ArgsType()
 export class DeleteManyUserArgs {
-  @Field(() => UserWhereInput, { nullable: true })
-  @Type(() => UserWhereInput)
-  where?: UserWhereInput;
+
+    @Field(() => UserWhereInput, {nullable:true})
+    @Type(() => UserWhereInput)
+    where?: UserWhereInput;
 }
diff --git a/@generated/user/delete-one-user.args.ts b/@generated/user/delete-one-user.args.ts
index 314d5c78..018ea4bd 100644
--- a/@generated/user/delete-one-user.args.ts
+++ b/@generated/user/delete-one-user.args.ts
@@ -1,12 +1,13 @@
 import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 import { Type } from 'class-transformer';
 
 @ArgsType()
 export class DeleteOneUserArgs {
-  @Field(() => UserWhereUniqueInput, { nullable: false })
-  @Type(() => UserWhereUniqueInput)
-  where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
+
+    @Field(() => UserWhereUniqueInput, {nullable:false})
+    @Type(() => UserWhereUniqueInput)
+    where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
 }
diff --git a/@generated/user/find-first-user-or-throw.args.ts b/@generated/user/find-first-user-or-throw.args.ts
index f67d65a2..ab7223f9 100644
--- a/@generated/user/find-first-user-or-throw.args.ts
+++ b/@generated/user/find-first-user-or-throw.args.ts
@@ -3,31 +3,32 @@ import { ArgsType } from '@nestjs/graphql';
 import { UserWhereInput } from './user-where.input';
 import { Type } from 'class-transformer';
 import { UserOrderByWithRelationAndSearchRelevanceInput } from './user-order-by-with-relation-and-search-relevance.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 import { Int } from '@nestjs/graphql';
 import { UserScalarFieldEnum } from './user-scalar-field.enum';
 
 @ArgsType()
 export class FindFirstUserOrThrowArgs {
-  @Field(() => UserWhereInput, { nullable: true })
-  @Type(() => UserWhereInput)
-  where?: UserWhereInput;
 
-  @Field(() => [UserOrderByWithRelationAndSearchRelevanceInput], { nullable: true })
-  @Type(() => UserOrderByWithRelationAndSearchRelevanceInput)
-  orderBy?: Array<UserOrderByWithRelationAndSearchRelevanceInput>;
+    @Field(() => UserWhereInput, {nullable:true})
+    @Type(() => UserWhereInput)
+    where?: UserWhereInput;
 
-  @Field(() => UserWhereUniqueInput, { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  cursor?: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
+    @Field(() => [UserOrderByWithRelationAndSearchRelevanceInput], {nullable:true})
+    @Type(() => UserOrderByWithRelationAndSearchRelevanceInput)
+    orderBy?: Array<UserOrderByWithRelationAndSearchRelevanceInput>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => UserWhereUniqueInput, {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    cursor?: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => [UserScalarFieldEnum], { nullable: true })
-  distinct?: Array<keyof typeof UserScalarFieldEnum>;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
+
+    @Field(() => [UserScalarFieldEnum], {nullable:true})
+    distinct?: Array<keyof typeof UserScalarFieldEnum>;
 }
diff --git a/@generated/user/find-first-user.args.ts b/@generated/user/find-first-user.args.ts
index caa6014a..320ce6b9 100644
--- a/@generated/user/find-first-user.args.ts
+++ b/@generated/user/find-first-user.args.ts
@@ -3,31 +3,32 @@ import { ArgsType } from '@nestjs/graphql';
 import { UserWhereInput } from './user-where.input';
 import { Type } from 'class-transformer';
 import { UserOrderByWithRelationAndSearchRelevanceInput } from './user-order-by-with-relation-and-search-relevance.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 import { Int } from '@nestjs/graphql';
 import { UserScalarFieldEnum } from './user-scalar-field.enum';
 
 @ArgsType()
 export class FindFirstUserArgs {
-  @Field(() => UserWhereInput, { nullable: true })
-  @Type(() => UserWhereInput)
-  where?: UserWhereInput;
 
-  @Field(() => [UserOrderByWithRelationAndSearchRelevanceInput], { nullable: true })
-  @Type(() => UserOrderByWithRelationAndSearchRelevanceInput)
-  orderBy?: Array<UserOrderByWithRelationAndSearchRelevanceInput>;
+    @Field(() => UserWhereInput, {nullable:true})
+    @Type(() => UserWhereInput)
+    where?: UserWhereInput;
 
-  @Field(() => UserWhereUniqueInput, { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  cursor?: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
+    @Field(() => [UserOrderByWithRelationAndSearchRelevanceInput], {nullable:true})
+    @Type(() => UserOrderByWithRelationAndSearchRelevanceInput)
+    orderBy?: Array<UserOrderByWithRelationAndSearchRelevanceInput>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => UserWhereUniqueInput, {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    cursor?: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => [UserScalarFieldEnum], { nullable: true })
-  distinct?: Array<keyof typeof UserScalarFieldEnum>;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
+
+    @Field(() => [UserScalarFieldEnum], {nullable:true})
+    distinct?: Array<keyof typeof UserScalarFieldEnum>;
 }
diff --git a/@generated/user/find-many-user.args.ts b/@generated/user/find-many-user.args.ts
index a8173f95..951b3cfa 100644
--- a/@generated/user/find-many-user.args.ts
+++ b/@generated/user/find-many-user.args.ts
@@ -3,31 +3,32 @@ import { ArgsType } from '@nestjs/graphql';
 import { UserWhereInput } from './user-where.input';
 import { Type } from 'class-transformer';
 import { UserOrderByWithRelationAndSearchRelevanceInput } from './user-order-by-with-relation-and-search-relevance.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 import { Int } from '@nestjs/graphql';
 import { UserScalarFieldEnum } from './user-scalar-field.enum';
 
 @ArgsType()
 export class FindManyUserArgs {
-  @Field(() => UserWhereInput, { nullable: true })
-  @Type(() => UserWhereInput)
-  where?: UserWhereInput;
 
-  @Field(() => [UserOrderByWithRelationAndSearchRelevanceInput], { nullable: true })
-  @Type(() => UserOrderByWithRelationAndSearchRelevanceInput)
-  orderBy?: Array<UserOrderByWithRelationAndSearchRelevanceInput>;
+    @Field(() => UserWhereInput, {nullable:true})
+    @Type(() => UserWhereInput)
+    where?: UserWhereInput;
 
-  @Field(() => UserWhereUniqueInput, { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  cursor?: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
+    @Field(() => [UserOrderByWithRelationAndSearchRelevanceInput], {nullable:true})
+    @Type(() => UserOrderByWithRelationAndSearchRelevanceInput)
+    orderBy?: Array<UserOrderByWithRelationAndSearchRelevanceInput>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => UserWhereUniqueInput, {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    cursor?: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => [UserScalarFieldEnum], { nullable: true })
-  distinct?: Array<keyof typeof UserScalarFieldEnum>;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
+
+    @Field(() => [UserScalarFieldEnum], {nullable:true})
+    distinct?: Array<keyof typeof UserScalarFieldEnum>;
 }
diff --git a/@generated/user/find-unique-user-or-throw.args.ts b/@generated/user/find-unique-user-or-throw.args.ts
index 63a4e7a0..b9b031c7 100644
--- a/@generated/user/find-unique-user-or-throw.args.ts
+++ b/@generated/user/find-unique-user-or-throw.args.ts
@@ -1,12 +1,13 @@
 import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 import { Type } from 'class-transformer';
 
 @ArgsType()
 export class FindUniqueUserOrThrowArgs {
-  @Field(() => UserWhereUniqueInput, { nullable: false })
-  @Type(() => UserWhereUniqueInput)
-  where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
+
+    @Field(() => UserWhereUniqueInput, {nullable:false})
+    @Type(() => UserWhereUniqueInput)
+    where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
 }
diff --git a/@generated/user/find-unique-user.args.ts b/@generated/user/find-unique-user.args.ts
index 8e1dda70..631121c2 100644
--- a/@generated/user/find-unique-user.args.ts
+++ b/@generated/user/find-unique-user.args.ts
@@ -1,12 +1,13 @@
 import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 import { Type } from 'class-transformer';
 
 @ArgsType()
 export class FindUniqueUserArgs {
-  @Field(() => UserWhereUniqueInput, { nullable: false })
-  @Type(() => UserWhereUniqueInput)
-  where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
+
+    @Field(() => UserWhereUniqueInput, {nullable:false})
+    @Type(() => UserWhereUniqueInput)
+    where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
 }
diff --git a/@generated/user/update-many-user.args.ts b/@generated/user/update-many-user.args.ts
index c16cbbe6..2e827486 100644
--- a/@generated/user/update-many-user.args.ts
+++ b/@generated/user/update-many-user.args.ts
@@ -6,11 +6,12 @@ import { UserWhereInput } from './user-where.input';
 
 @ArgsType()
 export class UpdateManyUserArgs {
-  @Field(() => UserUpdateManyMutationInput, { nullable: false })
-  @Type(() => UserUpdateManyMutationInput)
-  data!: UserUpdateManyMutationInput;
 
-  @Field(() => UserWhereInput, { nullable: true })
-  @Type(() => UserWhereInput)
-  where?: UserWhereInput;
+    @Field(() => UserUpdateManyMutationInput, {nullable:false})
+    @Type(() => UserUpdateManyMutationInput)
+    data!: UserUpdateManyMutationInput;
+
+    @Field(() => UserWhereInput, {nullable:true})
+    @Type(() => UserWhereInput)
+    where?: UserWhereInput;
 }
diff --git a/@generated/user/update-one-user.args.ts b/@generated/user/update-one-user.args.ts
index 753f0043..0669619d 100644
--- a/@generated/user/update-one-user.args.ts
+++ b/@generated/user/update-one-user.args.ts
@@ -2,16 +2,17 @@ import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
 import { UserUpdateInput } from './user-update.input';
 import { Type } from 'class-transformer';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 
 @ArgsType()
 export class UpdateOneUserArgs {
-  @Field(() => UserUpdateInput, { nullable: false })
-  @Type(() => UserUpdateInput)
-  data!: UserUpdateInput;
 
-  @Field(() => UserWhereUniqueInput, { nullable: false })
-  @Type(() => UserWhereUniqueInput)
-  where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
+    @Field(() => UserUpdateInput, {nullable:false})
+    @Type(() => UserUpdateInput)
+    data!: UserUpdateInput;
+
+    @Field(() => UserWhereUniqueInput, {nullable:false})
+    @Type(() => UserWhereUniqueInput)
+    where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
 }
diff --git a/@generated/user/upsert-one-user.args.ts b/@generated/user/upsert-one-user.args.ts
index a19329e3..9619aca3 100644
--- a/@generated/user/upsert-one-user.args.ts
+++ b/@generated/user/upsert-one-user.args.ts
@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { ArgsType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 import { Type } from 'class-transformer';
 import { UserCreateInput } from './user-create.input';
@@ -8,15 +8,16 @@ import { UserUpdateInput } from './user-update.input';
 
 @ArgsType()
 export class UpsertOneUserArgs {
-  @Field(() => UserWhereUniqueInput, { nullable: false })
-  @Type(() => UserWhereUniqueInput)
-  where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
 
-  @Field(() => UserCreateInput, { nullable: false })
-  @Type(() => UserCreateInput)
-  create!: UserCreateInput;
+    @Field(() => UserWhereUniqueInput, {nullable:false})
+    @Type(() => UserWhereUniqueInput)
+    where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
 
-  @Field(() => UserUpdateInput, { nullable: false })
-  @Type(() => UserUpdateInput)
-  update!: UserUpdateInput;
+    @Field(() => UserCreateInput, {nullable:false})
+    @Type(() => UserCreateInput)
+    create!: UserCreateInput;
+
+    @Field(() => UserUpdateInput, {nullable:false})
+    @Type(() => UserUpdateInput)
+    update!: UserUpdateInput;
 }
diff --git a/@generated/user/user-aggregate.args.ts b/@generated/user/user-aggregate.args.ts
index 8c7eb181..4b5c3f76 100644
--- a/@generated/user/user-aggregate.args.ts
+++ b/@generated/user/user-aggregate.args.ts
@@ -3,7 +3,7 @@ import { ArgsType } from '@nestjs/graphql';
 import { UserWhereInput } from './user-where.input';
 import { Type } from 'class-transformer';
 import { UserOrderByWithRelationAndSearchRelevanceInput } from './user-order-by-with-relation-and-search-relevance.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 import { Int } from '@nestjs/graphql';
 import { UserCountAggregateInput } from './user-count-aggregate.input';
@@ -14,41 +14,42 @@ import { UserMaxAggregateInput } from './user-max-aggregate.input';
 
 @ArgsType()
 export class UserAggregateArgs {
-  @Field(() => UserWhereInput, { nullable: true })
-  @Type(() => UserWhereInput)
-  where?: UserWhereInput;
 
-  @Field(() => [UserOrderByWithRelationAndSearchRelevanceInput], { nullable: true })
-  @Type(() => UserOrderByWithRelationAndSearchRelevanceInput)
-  orderBy?: Array<UserOrderByWithRelationAndSearchRelevanceInput>;
+    @Field(() => UserWhereInput, {nullable:true})
+    @Type(() => UserWhereInput)
+    where?: UserWhereInput;
 
-  @Field(() => UserWhereUniqueInput, { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  cursor?: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
+    @Field(() => [UserOrderByWithRelationAndSearchRelevanceInput], {nullable:true})
+    @Type(() => UserOrderByWithRelationAndSearchRelevanceInput)
+    orderBy?: Array<UserOrderByWithRelationAndSearchRelevanceInput>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => UserWhereUniqueInput, {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    cursor?: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => UserCountAggregateInput, { nullable: true })
-  @Type(() => UserCountAggregateInput)
-  _count?: UserCountAggregateInput;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
 
-  @Field(() => UserAvgAggregateInput, { nullable: true })
-  @Type(() => UserAvgAggregateInput)
-  _avg?: UserAvgAggregateInput;
+    @Field(() => UserCountAggregateInput, {nullable:true})
+    @Type(() => UserCountAggregateInput)
+    _count?: UserCountAggregateInput;
 
-  @Field(() => UserSumAggregateInput, { nullable: true })
-  @Type(() => UserSumAggregateInput)
-  _sum?: UserSumAggregateInput;
+    @Field(() => UserAvgAggregateInput, {nullable:true})
+    @Type(() => UserAvgAggregateInput)
+    _avg?: UserAvgAggregateInput;
 
-  @Field(() => UserMinAggregateInput, { nullable: true })
-  @Type(() => UserMinAggregateInput)
-  _min?: UserMinAggregateInput;
+    @Field(() => UserSumAggregateInput, {nullable:true})
+    @Type(() => UserSumAggregateInput)
+    _sum?: UserSumAggregateInput;
 
-  @Field(() => UserMaxAggregateInput, { nullable: true })
-  @Type(() => UserMaxAggregateInput)
-  _max?: UserMaxAggregateInput;
+    @Field(() => UserMinAggregateInput, {nullable:true})
+    @Type(() => UserMinAggregateInput)
+    _min?: UserMinAggregateInput;
+
+    @Field(() => UserMaxAggregateInput, {nullable:true})
+    @Type(() => UserMaxAggregateInput)
+    _max?: UserMaxAggregateInput;
 }
diff --git a/@generated/user/user-avg-aggregate.input.ts b/@generated/user/user-avg-aggregate.input.ts
index 6c42464e..dbe3fd95 100644
--- a/@generated/user/user-avg-aggregate.input.ts
+++ b/@generated/user/user-avg-aggregate.input.ts
@@ -3,12 +3,13 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class UserAvgAggregateInput {
-  @Field(() => Boolean, { nullable: true })
-  countComments?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  rating?: true;
+    @Field(() => Boolean, {nullable:true})
+    countComments?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  money?: true;
+    @Field(() => Boolean, {nullable:true})
+    rating?: true;
+
+    @Field(() => Boolean, {nullable:true})
+    money?: true;
 }
diff --git a/@generated/user/user-avg-aggregate.output.ts b/@generated/user/user-avg-aggregate.output.ts
index b0f4c86f..e75e1fcb 100644
--- a/@generated/user/user-avg-aggregate.output.ts
+++ b/@generated/user/user-avg-aggregate.output.ts
@@ -1,17 +1,18 @@
 import { Field } from '@nestjs/graphql';
 import { ObjectType } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 
 @ObjectType()
 export class UserAvgAggregate {
-  @Field(() => Float, { nullable: true })
-  countComments?: number;
 
-  @Field(() => Float, { nullable: true })
-  rating?: number;
+    @Field(() => Float, {nullable:true})
+    countComments?: number;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  money?: Decimal;
+    @Field(() => Float, {nullable:true})
+    rating?: number;
+
+    @Field(() => GraphQLDecimal, {nullable:true})
+    money?: Decimal;
 }
diff --git a/@generated/user/user-avg-order-by-aggregate.input.ts b/@generated/user/user-avg-order-by-aggregate.input.ts
index d5db4f90..dbe1f385 100644
--- a/@generated/user/user-avg-order-by-aggregate.input.ts
+++ b/@generated/user/user-avg-order-by-aggregate.input.ts
@@ -4,12 +4,13 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class UserAvgOrderByAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  countComments?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  rating?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    countComments?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  money?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    rating?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    money?: keyof typeof SortOrder;
 }
diff --git a/@generated/user/user-count-aggregate.input.ts b/@generated/user/user-count-aggregate.input.ts
index 24deca18..b9146bfe 100644
--- a/@generated/user/user-count-aggregate.input.ts
+++ b/@generated/user/user-count-aggregate.input.ts
@@ -3,36 +3,37 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class UserCountAggregateInput {
-  @Field(() => Boolean, { nullable: true })
-  id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  email?: true;
+    @Field(() => Boolean, {nullable:true})
+    id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  name?: true;
+    @Field(() => Boolean, {nullable:true})
+    email?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  password?: true;
+    @Field(() => Boolean, {nullable:true})
+    name?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  bio?: true;
+    @Field(() => Boolean, {nullable:true})
+    password?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  image?: true;
+    @Field(() => Boolean, {nullable:true})
+    bio?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  countComments?: true;
+    @Field(() => Boolean, {nullable:true})
+    image?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  rating?: true;
+    @Field(() => Boolean, {nullable:true})
+    countComments?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  money?: true;
+    @Field(() => Boolean, {nullable:true})
+    rating?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  role?: true;
+    @Field(() => Boolean, {nullable:true})
+    money?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  _all?: true;
+    @Field(() => Boolean, {nullable:true})
+    role?: true;
+
+    @Field(() => Boolean, {nullable:true})
+    _all?: true;
 }
diff --git a/@generated/user/user-count-aggregate.output.ts b/@generated/user/user-count-aggregate.output.ts
index 06d69475..2bb57d8a 100644
--- a/@generated/user/user-count-aggregate.output.ts
+++ b/@generated/user/user-count-aggregate.output.ts
@@ -5,36 +5,37 @@ import { HideField } from '@nestjs/graphql';
 
 @ObjectType()
 export class UserCountAggregate {
-  @Field(() => Int, { nullable: false })
-  id!: number;
 
-  @Field(() => Int, { nullable: false })
-  email!: number;
+    @Field(() => Int, {nullable:false})
+    id!: number;
 
-  @Field(() => Int, { nullable: false })
-  name!: number;
+    @Field(() => Int, {nullable:false})
+    email!: number;
 
-  @HideField()
-  password!: number;
+    @Field(() => Int, {nullable:false})
+    name!: number;
 
-  @Field(() => Int, { nullable: false })
-  bio!: number;
+    @HideField()
+    password!: number;
 
-  @Field(() => Int, { nullable: false })
-  image!: number;
+    @Field(() => Int, {nullable:false})
+    bio!: number;
 
-  @Field(() => Int, { nullable: false })
-  countComments!: number;
+    @Field(() => Int, {nullable:false})
+    image!: number;
 
-  @Field(() => Int, { nullable: false })
-  rating!: number;
+    @Field(() => Int, {nullable:false})
+    countComments!: number;
 
-  @Field(() => Int, { nullable: false })
-  money!: number;
+    @Field(() => Int, {nullable:false})
+    rating!: number;
 
-  @Field(() => Int, { nullable: false })
-  role!: number;
+    @Field(() => Int, {nullable:false})
+    money!: number;
 
-  @Field(() => Int, { nullable: false })
-  _all!: number;
+    @Field(() => Int, {nullable:false})
+    role!: number;
+
+    @Field(() => Int, {nullable:false})
+    _all!: number;
 }
diff --git a/@generated/user/user-count-order-by-aggregate.input.ts b/@generated/user/user-count-order-by-aggregate.input.ts
index 90239fd1..32ca2a44 100644
--- a/@generated/user/user-count-order-by-aggregate.input.ts
+++ b/@generated/user/user-count-order-by-aggregate.input.ts
@@ -4,33 +4,34 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class UserCountOrderByAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  email?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  name?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    email?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  password?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    name?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  bio?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    password?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  image?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    bio?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  countComments?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    image?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  rating?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    countComments?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  money?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    rating?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  role?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    money?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    role?: keyof typeof SortOrder;
 }
diff --git a/@generated/user/user-count.output.ts b/@generated/user/user-count.output.ts
index da705521..57ceb3ed 100644
--- a/@generated/user/user-count.output.ts
+++ b/@generated/user/user-count.output.ts
@@ -4,18 +4,19 @@ import { Int } from '@nestjs/graphql';
 
 @ObjectType()
 export class UserCount {
-  @Field(() => Int, { nullable: false })
-  following?: number;
 
-  @Field(() => Int, { nullable: false })
-  followers?: number;
+    @Field(() => Int, {nullable:false})
+    following?: number;
 
-  @Field(() => Int, { nullable: false })
-  favoriteArticles?: number;
+    @Field(() => Int, {nullable:false})
+    followers?: number;
 
-  @Field(() => Int, { nullable: false })
-  articles?: number;
+    @Field(() => Int, {nullable:false})
+    favoriteArticles?: number;
 
-  @Field(() => Int, { nullable: false })
-  comments?: number;
+    @Field(() => Int, {nullable:false})
+    articles?: number;
+
+    @Field(() => Int, {nullable:false})
+    comments?: number;
 }
diff --git a/@generated/user/user-create-many.input.ts b/@generated/user/user-create-many.input.ts
index d888bf5e..894c056a 100644
--- a/@generated/user/user-create-many.input.ts
+++ b/@generated/user/user-create-many.input.ts
@@ -4,7 +4,7 @@ import * as Scalars from 'graphql-scalars';
 import * as Validator from 'class-validator';
 import { Int } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -13,37 +13,38 @@ import { Role } from '../prisma/role.enum';
 
 @InputType()
 export class UserCreateManyInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => Scalars.GraphQLEmailAddress, { nullable: false })
-  email!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: false })
-  @Validator.MinLength(3)
-  @Validator.MaxLength(50)
-  name!: string;
+    @Field(() => Scalars.GraphQLEmailAddress, {nullable:false})
+    email!: string;
 
-  @Field(() => String, { nullable: false })
-  password!: string;
+    @Field(() => String, {nullable:false})
+    @Validator.MinLength(3)
+    @Validator.MaxLength(50)
+    name!: string;
 
-  @Field(() => String, { nullable: true })
-  bio?: string;
+    @Field(() => String, {nullable:false})
+    password!: string;
 
-  @Field(() => String, { nullable: true })
-  image?: string;
+    @Field(() => String, {nullable:true})
+    bio?: string;
 
-  @Field(() => Int, { nullable: true })
-  countComments?: number;
+    @Field(() => String, {nullable:true})
+    image?: string;
 
-  @Field(() => Float, { nullable: true })
-  rating?: number;
+    @Field(() => Int, {nullable:true})
+    countComments?: number;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  money?: Decimal;
+    @Field(() => Float, {nullable:true})
+    rating?: number;
 
-  @Field(() => Role, { nullable: true })
-  role?: keyof typeof Role;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    money?: Decimal;
+
+    @Field(() => Role, {nullable:true})
+    role?: keyof typeof Role;
 }
diff --git a/@generated/user/user-create-nested-many-without-favorite-articles.input.ts b/@generated/user/user-create-nested-many-without-favorite-articles.input.ts
index e87c6b04..2a11a7a8 100644
--- a/@generated/user/user-create-nested-many-without-favorite-articles.input.ts
+++ b/@generated/user/user-create-nested-many-without-favorite-articles.input.ts
@@ -3,22 +3,21 @@ import { InputType } from '@nestjs/graphql';
 import { UserCreateWithoutFavoriteArticlesInput } from './user-create-without-favorite-articles.input';
 import { Type } from 'class-transformer';
 import { UserCreateOrConnectWithoutFavoriteArticlesInput } from './user-create-or-connect-without-favorite-articles.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 
 @InputType()
 export class UserCreateNestedManyWithoutFavoriteArticlesInput {
-  @Field(() => [UserCreateWithoutFavoriteArticlesInput], { nullable: true })
-  @Type(() => UserCreateWithoutFavoriteArticlesInput)
-  create?: Array<UserCreateWithoutFavoriteArticlesInput>;
 
-  @Field(() => [UserCreateOrConnectWithoutFavoriteArticlesInput], { nullable: true })
-  @Type(() => UserCreateOrConnectWithoutFavoriteArticlesInput)
-  connectOrCreate?: Array<UserCreateOrConnectWithoutFavoriteArticlesInput>;
+    @Field(() => [UserCreateWithoutFavoriteArticlesInput], {nullable:true})
+    @Type(() => UserCreateWithoutFavoriteArticlesInput)
+    create?: Array<UserCreateWithoutFavoriteArticlesInput>;
 
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  connect?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
+    @Field(() => [UserCreateOrConnectWithoutFavoriteArticlesInput], {nullable:true})
+    @Type(() => UserCreateOrConnectWithoutFavoriteArticlesInput)
+    connectOrCreate?: Array<UserCreateOrConnectWithoutFavoriteArticlesInput>;
+
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
 }
diff --git a/@generated/user/user-create-nested-many-without-followers.input.ts b/@generated/user/user-create-nested-many-without-followers.input.ts
index 8dcef2b2..a2174b2b 100644
--- a/@generated/user/user-create-nested-many-without-followers.input.ts
+++ b/@generated/user/user-create-nested-many-without-followers.input.ts
@@ -3,22 +3,21 @@ import { InputType } from '@nestjs/graphql';
 import { UserCreateWithoutFollowersInput } from './user-create-without-followers.input';
 import { Type } from 'class-transformer';
 import { UserCreateOrConnectWithoutFollowersInput } from './user-create-or-connect-without-followers.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 
 @InputType()
 export class UserCreateNestedManyWithoutFollowersInput {
-  @Field(() => [UserCreateWithoutFollowersInput], { nullable: true })
-  @Type(() => UserCreateWithoutFollowersInput)
-  create?: Array<UserCreateWithoutFollowersInput>;
 
-  @Field(() => [UserCreateOrConnectWithoutFollowersInput], { nullable: true })
-  @Type(() => UserCreateOrConnectWithoutFollowersInput)
-  connectOrCreate?: Array<UserCreateOrConnectWithoutFollowersInput>;
+    @Field(() => [UserCreateWithoutFollowersInput], {nullable:true})
+    @Type(() => UserCreateWithoutFollowersInput)
+    create?: Array<UserCreateWithoutFollowersInput>;
 
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  connect?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
+    @Field(() => [UserCreateOrConnectWithoutFollowersInput], {nullable:true})
+    @Type(() => UserCreateOrConnectWithoutFollowersInput)
+    connectOrCreate?: Array<UserCreateOrConnectWithoutFollowersInput>;
+
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
 }
diff --git a/@generated/user/user-create-nested-many-without-following.input.ts b/@generated/user/user-create-nested-many-without-following.input.ts
index 3ab58c44..3ea1b526 100644
--- a/@generated/user/user-create-nested-many-without-following.input.ts
+++ b/@generated/user/user-create-nested-many-without-following.input.ts
@@ -3,22 +3,21 @@ import { InputType } from '@nestjs/graphql';
 import { UserCreateWithoutFollowingInput } from './user-create-without-following.input';
 import { Type } from 'class-transformer';
 import { UserCreateOrConnectWithoutFollowingInput } from './user-create-or-connect-without-following.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 
 @InputType()
 export class UserCreateNestedManyWithoutFollowingInput {
-  @Field(() => [UserCreateWithoutFollowingInput], { nullable: true })
-  @Type(() => UserCreateWithoutFollowingInput)
-  create?: Array<UserCreateWithoutFollowingInput>;
 
-  @Field(() => [UserCreateOrConnectWithoutFollowingInput], { nullable: true })
-  @Type(() => UserCreateOrConnectWithoutFollowingInput)
-  connectOrCreate?: Array<UserCreateOrConnectWithoutFollowingInput>;
+    @Field(() => [UserCreateWithoutFollowingInput], {nullable:true})
+    @Type(() => UserCreateWithoutFollowingInput)
+    create?: Array<UserCreateWithoutFollowingInput>;
 
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  connect?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
+    @Field(() => [UserCreateOrConnectWithoutFollowingInput], {nullable:true})
+    @Type(() => UserCreateOrConnectWithoutFollowingInput)
+    connectOrCreate?: Array<UserCreateOrConnectWithoutFollowingInput>;
+
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
 }
diff --git a/@generated/user/user-create-nested-one-without-articles.input.ts b/@generated/user/user-create-nested-one-without-articles.input.ts
index d48a17af..715485f0 100644
--- a/@generated/user/user-create-nested-one-without-articles.input.ts
+++ b/@generated/user/user-create-nested-one-without-articles.input.ts
@@ -3,23 +3,21 @@ import { InputType } from '@nestjs/graphql';
 import { UserCreateWithoutArticlesInput } from './user-create-without-articles.input';
 import { Type } from 'class-transformer';
 import { UserCreateOrConnectWithoutArticlesInput } from './user-create-or-connect-without-articles.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 
 @InputType()
 export class UserCreateNestedOneWithoutArticlesInput {
-  @Field(() => UserCreateWithoutArticlesInput, { nullable: true })
-  @Type(() => UserCreateWithoutArticlesInput)
-  create?: UserCreateWithoutArticlesInput;
 
-  @Field(() => UserCreateOrConnectWithoutArticlesInput, { nullable: true })
-  @Type(() => UserCreateOrConnectWithoutArticlesInput)
-  connectOrCreate?: UserCreateOrConnectWithoutArticlesInput;
+    @Field(() => UserCreateWithoutArticlesInput, {nullable:true})
+    @Type(() => UserCreateWithoutArticlesInput)
+    create?: UserCreateWithoutArticlesInput;
 
-  @Field(() => UserWhereUniqueInput, { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  connect?: Prisma.AtLeast<
-    UserWhereUniqueInput,
-    'id' | 'email' | 'name' | 'email_name'
-  >;
+    @Field(() => UserCreateOrConnectWithoutArticlesInput, {nullable:true})
+    @Type(() => UserCreateOrConnectWithoutArticlesInput)
+    connectOrCreate?: UserCreateOrConnectWithoutArticlesInput;
+
+    @Field(() => UserWhereUniqueInput, {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    connect?: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
 }
diff --git a/@generated/user/user-create-nested-one-without-comments.input.ts b/@generated/user/user-create-nested-one-without-comments.input.ts
index a48bd9d7..245eaa6f 100644
--- a/@generated/user/user-create-nested-one-without-comments.input.ts
+++ b/@generated/user/user-create-nested-one-without-comments.input.ts
@@ -3,23 +3,21 @@ import { InputType } from '@nestjs/graphql';
 import { UserCreateWithoutCommentsInput } from './user-create-without-comments.input';
 import { Type } from 'class-transformer';
 import { UserCreateOrConnectWithoutCommentsInput } from './user-create-or-connect-without-comments.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 
 @InputType()
 export class UserCreateNestedOneWithoutCommentsInput {
-  @Field(() => UserCreateWithoutCommentsInput, { nullable: true })
-  @Type(() => UserCreateWithoutCommentsInput)
-  create?: UserCreateWithoutCommentsInput;
 
-  @Field(() => UserCreateOrConnectWithoutCommentsInput, { nullable: true })
-  @Type(() => UserCreateOrConnectWithoutCommentsInput)
-  connectOrCreate?: UserCreateOrConnectWithoutCommentsInput;
+    @Field(() => UserCreateWithoutCommentsInput, {nullable:true})
+    @Type(() => UserCreateWithoutCommentsInput)
+    create?: UserCreateWithoutCommentsInput;
 
-  @Field(() => UserWhereUniqueInput, { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  connect?: Prisma.AtLeast<
-    UserWhereUniqueInput,
-    'id' | 'email' | 'name' | 'email_name'
-  >;
+    @Field(() => UserCreateOrConnectWithoutCommentsInput, {nullable:true})
+    @Type(() => UserCreateOrConnectWithoutCommentsInput)
+    connectOrCreate?: UserCreateOrConnectWithoutCommentsInput;
+
+    @Field(() => UserWhereUniqueInput, {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    connect?: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
 }
diff --git a/@generated/user/user-create-nested-one-without-profile.input.ts b/@generated/user/user-create-nested-one-without-profile.input.ts
index 69f4c282..74193383 100644
--- a/@generated/user/user-create-nested-one-without-profile.input.ts
+++ b/@generated/user/user-create-nested-one-without-profile.input.ts
@@ -3,23 +3,21 @@ import { InputType } from '@nestjs/graphql';
 import { UserCreateWithoutProfileInput } from './user-create-without-profile.input';
 import { Type } from 'class-transformer';
 import { UserCreateOrConnectWithoutProfileInput } from './user-create-or-connect-without-profile.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 
 @InputType()
 export class UserCreateNestedOneWithoutProfileInput {
-  @Field(() => UserCreateWithoutProfileInput, { nullable: true })
-  @Type(() => UserCreateWithoutProfileInput)
-  create?: UserCreateWithoutProfileInput;
 
-  @Field(() => UserCreateOrConnectWithoutProfileInput, { nullable: true })
-  @Type(() => UserCreateOrConnectWithoutProfileInput)
-  connectOrCreate?: UserCreateOrConnectWithoutProfileInput;
+    @Field(() => UserCreateWithoutProfileInput, {nullable:true})
+    @Type(() => UserCreateWithoutProfileInput)
+    create?: UserCreateWithoutProfileInput;
 
-  @Field(() => UserWhereUniqueInput, { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  connect?: Prisma.AtLeast<
-    UserWhereUniqueInput,
-    'id' | 'email' | 'name' | 'email_name'
-  >;
+    @Field(() => UserCreateOrConnectWithoutProfileInput, {nullable:true})
+    @Type(() => UserCreateOrConnectWithoutProfileInput)
+    connectOrCreate?: UserCreateOrConnectWithoutProfileInput;
+
+    @Field(() => UserWhereUniqueInput, {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    connect?: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
 }
diff --git a/@generated/user/user-create-or-connect-without-articles.input.ts b/@generated/user/user-create-or-connect-without-articles.input.ts
index 093bdefa..dce91172 100644
--- a/@generated/user/user-create-or-connect-without-articles.input.ts
+++ b/@generated/user/user-create-or-connect-without-articles.input.ts
@@ -1,17 +1,18 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 import { Type } from 'class-transformer';
 import { UserCreateWithoutArticlesInput } from './user-create-without-articles.input';
 
 @InputType()
 export class UserCreateOrConnectWithoutArticlesInput {
-  @Field(() => UserWhereUniqueInput, { nullable: false })
-  @Type(() => UserWhereUniqueInput)
-  where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
 
-  @Field(() => UserCreateWithoutArticlesInput, { nullable: false })
-  @Type(() => UserCreateWithoutArticlesInput)
-  create!: UserCreateWithoutArticlesInput;
+    @Field(() => UserWhereUniqueInput, {nullable:false})
+    @Type(() => UserWhereUniqueInput)
+    where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
+
+    @Field(() => UserCreateWithoutArticlesInput, {nullable:false})
+    @Type(() => UserCreateWithoutArticlesInput)
+    create!: UserCreateWithoutArticlesInput;
 }
diff --git a/@generated/user/user-create-or-connect-without-comments.input.ts b/@generated/user/user-create-or-connect-without-comments.input.ts
index 59c365da..90f59189 100644
--- a/@generated/user/user-create-or-connect-without-comments.input.ts
+++ b/@generated/user/user-create-or-connect-without-comments.input.ts
@@ -1,17 +1,18 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 import { Type } from 'class-transformer';
 import { UserCreateWithoutCommentsInput } from './user-create-without-comments.input';
 
 @InputType()
 export class UserCreateOrConnectWithoutCommentsInput {
-  @Field(() => UserWhereUniqueInput, { nullable: false })
-  @Type(() => UserWhereUniqueInput)
-  where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
 
-  @Field(() => UserCreateWithoutCommentsInput, { nullable: false })
-  @Type(() => UserCreateWithoutCommentsInput)
-  create!: UserCreateWithoutCommentsInput;
+    @Field(() => UserWhereUniqueInput, {nullable:false})
+    @Type(() => UserWhereUniqueInput)
+    where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
+
+    @Field(() => UserCreateWithoutCommentsInput, {nullable:false})
+    @Type(() => UserCreateWithoutCommentsInput)
+    create!: UserCreateWithoutCommentsInput;
 }
diff --git a/@generated/user/user-create-or-connect-without-favorite-articles.input.ts b/@generated/user/user-create-or-connect-without-favorite-articles.input.ts
index 823f3567..29e1ac5b 100644
--- a/@generated/user/user-create-or-connect-without-favorite-articles.input.ts
+++ b/@generated/user/user-create-or-connect-without-favorite-articles.input.ts
@@ -1,17 +1,18 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 import { Type } from 'class-transformer';
 import { UserCreateWithoutFavoriteArticlesInput } from './user-create-without-favorite-articles.input';
 
 @InputType()
 export class UserCreateOrConnectWithoutFavoriteArticlesInput {
-  @Field(() => UserWhereUniqueInput, { nullable: false })
-  @Type(() => UserWhereUniqueInput)
-  where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
 
-  @Field(() => UserCreateWithoutFavoriteArticlesInput, { nullable: false })
-  @Type(() => UserCreateWithoutFavoriteArticlesInput)
-  create!: UserCreateWithoutFavoriteArticlesInput;
+    @Field(() => UserWhereUniqueInput, {nullable:false})
+    @Type(() => UserWhereUniqueInput)
+    where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
+
+    @Field(() => UserCreateWithoutFavoriteArticlesInput, {nullable:false})
+    @Type(() => UserCreateWithoutFavoriteArticlesInput)
+    create!: UserCreateWithoutFavoriteArticlesInput;
 }
diff --git a/@generated/user/user-create-or-connect-without-followers.input.ts b/@generated/user/user-create-or-connect-without-followers.input.ts
index dc3bb9f1..a9f904d2 100644
--- a/@generated/user/user-create-or-connect-without-followers.input.ts
+++ b/@generated/user/user-create-or-connect-without-followers.input.ts
@@ -1,17 +1,18 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 import { Type } from 'class-transformer';
 import { UserCreateWithoutFollowersInput } from './user-create-without-followers.input';
 
 @InputType()
 export class UserCreateOrConnectWithoutFollowersInput {
-  @Field(() => UserWhereUniqueInput, { nullable: false })
-  @Type(() => UserWhereUniqueInput)
-  where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
 
-  @Field(() => UserCreateWithoutFollowersInput, { nullable: false })
-  @Type(() => UserCreateWithoutFollowersInput)
-  create!: UserCreateWithoutFollowersInput;
+    @Field(() => UserWhereUniqueInput, {nullable:false})
+    @Type(() => UserWhereUniqueInput)
+    where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
+
+    @Field(() => UserCreateWithoutFollowersInput, {nullable:false})
+    @Type(() => UserCreateWithoutFollowersInput)
+    create!: UserCreateWithoutFollowersInput;
 }
diff --git a/@generated/user/user-create-or-connect-without-following.input.ts b/@generated/user/user-create-or-connect-without-following.input.ts
index bfda27a2..7b594baf 100644
--- a/@generated/user/user-create-or-connect-without-following.input.ts
+++ b/@generated/user/user-create-or-connect-without-following.input.ts
@@ -1,17 +1,18 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 import { Type } from 'class-transformer';
 import { UserCreateWithoutFollowingInput } from './user-create-without-following.input';
 
 @InputType()
 export class UserCreateOrConnectWithoutFollowingInput {
-  @Field(() => UserWhereUniqueInput, { nullable: false })
-  @Type(() => UserWhereUniqueInput)
-  where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
 
-  @Field(() => UserCreateWithoutFollowingInput, { nullable: false })
-  @Type(() => UserCreateWithoutFollowingInput)
-  create!: UserCreateWithoutFollowingInput;
+    @Field(() => UserWhereUniqueInput, {nullable:false})
+    @Type(() => UserWhereUniqueInput)
+    where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
+
+    @Field(() => UserCreateWithoutFollowingInput, {nullable:false})
+    @Type(() => UserCreateWithoutFollowingInput)
+    create!: UserCreateWithoutFollowingInput;
 }
diff --git a/@generated/user/user-create-or-connect-without-profile.input.ts b/@generated/user/user-create-or-connect-without-profile.input.ts
index 1f820238..1d299dce 100644
--- a/@generated/user/user-create-or-connect-without-profile.input.ts
+++ b/@generated/user/user-create-or-connect-without-profile.input.ts
@@ -1,17 +1,18 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 import { Type } from 'class-transformer';
 import { UserCreateWithoutProfileInput } from './user-create-without-profile.input';
 
 @InputType()
 export class UserCreateOrConnectWithoutProfileInput {
-  @Field(() => UserWhereUniqueInput, { nullable: false })
-  @Type(() => UserWhereUniqueInput)
-  where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
 
-  @Field(() => UserCreateWithoutProfileInput, { nullable: false })
-  @Type(() => UserCreateWithoutProfileInput)
-  create!: UserCreateWithoutProfileInput;
+    @Field(() => UserWhereUniqueInput, {nullable:false})
+    @Type(() => UserWhereUniqueInput)
+    where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
+
+    @Field(() => UserCreateWithoutProfileInput, {nullable:false})
+    @Type(() => UserCreateWithoutProfileInput)
+    create!: UserCreateWithoutProfileInput;
 }
diff --git a/@generated/user/user-create-without-articles.input.ts b/@generated/user/user-create-without-articles.input.ts
index 65b95739..6891ebca 100644
--- a/@generated/user/user-create-without-articles.input.ts
+++ b/@generated/user/user-create-without-articles.input.ts
@@ -4,7 +4,7 @@ import * as Scalars from 'graphql-scalars';
 import * as Validator from 'class-validator';
 import { Int } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -18,57 +18,58 @@ import { ProfileCreateNestedOneWithoutUserInput } from '../profile/profile-creat
 
 @InputType()
 export class UserCreateWithoutArticlesInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => Scalars.GraphQLEmailAddress, { nullable: false })
-  email!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: false })
-  @Validator.MinLength(3)
-  @Validator.MaxLength(50)
-  name!: string;
+    @Field(() => Scalars.GraphQLEmailAddress, {nullable:false})
+    email!: string;
 
-  @Field(() => String, { nullable: false })
-  password!: string;
+    @Field(() => String, {nullable:false})
+    @Validator.MinLength(3)
+    @Validator.MaxLength(50)
+    name!: string;
 
-  @Field(() => String, { nullable: true })
-  bio?: string;
+    @Field(() => String, {nullable:false})
+    password!: string;
 
-  @Field(() => String, { nullable: true })
-  image?: string;
+    @Field(() => String, {nullable:true})
+    bio?: string;
 
-  @Field(() => Int, { nullable: true })
-  countComments?: number;
+    @Field(() => String, {nullable:true})
+    image?: string;
 
-  @Field(() => Float, { nullable: true })
-  rating?: number;
+    @Field(() => Int, {nullable:true})
+    countComments?: number;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  money?: Decimal;
+    @Field(() => Float, {nullable:true})
+    rating?: number;
 
-  @Field(() => Role, { nullable: true })
-  role?: keyof typeof Role;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    money?: Decimal;
 
-  @Field(() => UserCreateNestedManyWithoutFollowersInput, { nullable: true })
-  @Type(() => UserCreateNestedManyWithoutFollowersInput)
-  following?: UserCreateNestedManyWithoutFollowersInput;
+    @Field(() => Role, {nullable:true})
+    role?: keyof typeof Role;
 
-  @Field(() => UserCreateNestedManyWithoutFollowingInput, { nullable: true })
-  @Type(() => UserCreateNestedManyWithoutFollowingInput)
-  followers?: UserCreateNestedManyWithoutFollowingInput;
+    @Field(() => UserCreateNestedManyWithoutFollowersInput, {nullable:true})
+    @Type(() => UserCreateNestedManyWithoutFollowersInput)
+    following?: UserCreateNestedManyWithoutFollowersInput;
 
-  @Field(() => ArticleCreateNestedManyWithoutFavoritedByInput, { nullable: true })
-  @Type(() => ArticleCreateNestedManyWithoutFavoritedByInput)
-  favoriteArticles?: ArticleCreateNestedManyWithoutFavoritedByInput;
+    @Field(() => UserCreateNestedManyWithoutFollowingInput, {nullable:true})
+    @Type(() => UserCreateNestedManyWithoutFollowingInput)
+    followers?: UserCreateNestedManyWithoutFollowingInput;
 
-  @Field(() => CommentCreateNestedManyWithoutAuthorInput, { nullable: true })
-  @Type(() => CommentCreateNestedManyWithoutAuthorInput)
-  comments?: CommentCreateNestedManyWithoutAuthorInput;
+    @Field(() => ArticleCreateNestedManyWithoutFavoritedByInput, {nullable:true})
+    @Type(() => ArticleCreateNestedManyWithoutFavoritedByInput)
+    favoriteArticles?: ArticleCreateNestedManyWithoutFavoritedByInput;
 
-  @Field(() => ProfileCreateNestedOneWithoutUserInput, { nullable: true })
-  @Type(() => ProfileCreateNestedOneWithoutUserInput)
-  profile?: ProfileCreateNestedOneWithoutUserInput;
+    @Field(() => CommentCreateNestedManyWithoutAuthorInput, {nullable:true})
+    @Type(() => CommentCreateNestedManyWithoutAuthorInput)
+    comments?: CommentCreateNestedManyWithoutAuthorInput;
+
+    @Field(() => ProfileCreateNestedOneWithoutUserInput, {nullable:true})
+    @Type(() => ProfileCreateNestedOneWithoutUserInput)
+    profile?: ProfileCreateNestedOneWithoutUserInput;
 }
diff --git a/@generated/user/user-create-without-comments.input.ts b/@generated/user/user-create-without-comments.input.ts
index ec76ff78..afafd1cf 100644
--- a/@generated/user/user-create-without-comments.input.ts
+++ b/@generated/user/user-create-without-comments.input.ts
@@ -4,7 +4,7 @@ import * as Scalars from 'graphql-scalars';
 import * as Validator from 'class-validator';
 import { Int } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -18,57 +18,58 @@ import { ProfileCreateNestedOneWithoutUserInput } from '../profile/profile-creat
 
 @InputType()
 export class UserCreateWithoutCommentsInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => Scalars.GraphQLEmailAddress, { nullable: false })
-  email!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: false })
-  @Validator.MinLength(3)
-  @Validator.MaxLength(50)
-  name!: string;
+    @Field(() => Scalars.GraphQLEmailAddress, {nullable:false})
+    email!: string;
 
-  @Field(() => String, { nullable: false })
-  password!: string;
+    @Field(() => String, {nullable:false})
+    @Validator.MinLength(3)
+    @Validator.MaxLength(50)
+    name!: string;
 
-  @Field(() => String, { nullable: true })
-  bio?: string;
+    @Field(() => String, {nullable:false})
+    password!: string;
 
-  @Field(() => String, { nullable: true })
-  image?: string;
+    @Field(() => String, {nullable:true})
+    bio?: string;
 
-  @Field(() => Int, { nullable: true })
-  countComments?: number;
+    @Field(() => String, {nullable:true})
+    image?: string;
 
-  @Field(() => Float, { nullable: true })
-  rating?: number;
+    @Field(() => Int, {nullable:true})
+    countComments?: number;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  money?: Decimal;
+    @Field(() => Float, {nullable:true})
+    rating?: number;
 
-  @Field(() => Role, { nullable: true })
-  role?: keyof typeof Role;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    money?: Decimal;
 
-  @Field(() => UserCreateNestedManyWithoutFollowersInput, { nullable: true })
-  @Type(() => UserCreateNestedManyWithoutFollowersInput)
-  following?: UserCreateNestedManyWithoutFollowersInput;
+    @Field(() => Role, {nullable:true})
+    role?: keyof typeof Role;
 
-  @Field(() => UserCreateNestedManyWithoutFollowingInput, { nullable: true })
-  @Type(() => UserCreateNestedManyWithoutFollowingInput)
-  followers?: UserCreateNestedManyWithoutFollowingInput;
+    @Field(() => UserCreateNestedManyWithoutFollowersInput, {nullable:true})
+    @Type(() => UserCreateNestedManyWithoutFollowersInput)
+    following?: UserCreateNestedManyWithoutFollowersInput;
 
-  @Field(() => ArticleCreateNestedManyWithoutFavoritedByInput, { nullable: true })
-  @Type(() => ArticleCreateNestedManyWithoutFavoritedByInput)
-  favoriteArticles?: ArticleCreateNestedManyWithoutFavoritedByInput;
+    @Field(() => UserCreateNestedManyWithoutFollowingInput, {nullable:true})
+    @Type(() => UserCreateNestedManyWithoutFollowingInput)
+    followers?: UserCreateNestedManyWithoutFollowingInput;
 
-  @Field(() => ArticleCreateNestedManyWithoutAuthorInput, { nullable: true })
-  @Type(() => ArticleCreateNestedManyWithoutAuthorInput)
-  articles?: ArticleCreateNestedManyWithoutAuthorInput;
+    @Field(() => ArticleCreateNestedManyWithoutFavoritedByInput, {nullable:true})
+    @Type(() => ArticleCreateNestedManyWithoutFavoritedByInput)
+    favoriteArticles?: ArticleCreateNestedManyWithoutFavoritedByInput;
 
-  @Field(() => ProfileCreateNestedOneWithoutUserInput, { nullable: true })
-  @Type(() => ProfileCreateNestedOneWithoutUserInput)
-  profile?: ProfileCreateNestedOneWithoutUserInput;
+    @Field(() => ArticleCreateNestedManyWithoutAuthorInput, {nullable:true})
+    @Type(() => ArticleCreateNestedManyWithoutAuthorInput)
+    articles?: ArticleCreateNestedManyWithoutAuthorInput;
+
+    @Field(() => ProfileCreateNestedOneWithoutUserInput, {nullable:true})
+    @Type(() => ProfileCreateNestedOneWithoutUserInput)
+    profile?: ProfileCreateNestedOneWithoutUserInput;
 }
diff --git a/@generated/user/user-create-without-favorite-articles.input.ts b/@generated/user/user-create-without-favorite-articles.input.ts
index 9d7b1b0a..5082a00d 100644
--- a/@generated/user/user-create-without-favorite-articles.input.ts
+++ b/@generated/user/user-create-without-favorite-articles.input.ts
@@ -4,7 +4,7 @@ import * as Scalars from 'graphql-scalars';
 import * as Validator from 'class-validator';
 import { Int } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -18,57 +18,58 @@ import { ProfileCreateNestedOneWithoutUserInput } from '../profile/profile-creat
 
 @InputType()
 export class UserCreateWithoutFavoriteArticlesInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => Scalars.GraphQLEmailAddress, { nullable: false })
-  email!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: false })
-  @Validator.MinLength(3)
-  @Validator.MaxLength(50)
-  name!: string;
+    @Field(() => Scalars.GraphQLEmailAddress, {nullable:false})
+    email!: string;
 
-  @Field(() => String, { nullable: false })
-  password!: string;
+    @Field(() => String, {nullable:false})
+    @Validator.MinLength(3)
+    @Validator.MaxLength(50)
+    name!: string;
 
-  @Field(() => String, { nullable: true })
-  bio?: string;
+    @Field(() => String, {nullable:false})
+    password!: string;
 
-  @Field(() => String, { nullable: true })
-  image?: string;
+    @Field(() => String, {nullable:true})
+    bio?: string;
 
-  @Field(() => Int, { nullable: true })
-  countComments?: number;
+    @Field(() => String, {nullable:true})
+    image?: string;
 
-  @Field(() => Float, { nullable: true })
-  rating?: number;
+    @Field(() => Int, {nullable:true})
+    countComments?: number;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  money?: Decimal;
+    @Field(() => Float, {nullable:true})
+    rating?: number;
 
-  @Field(() => Role, { nullable: true })
-  role?: keyof typeof Role;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    money?: Decimal;
 
-  @Field(() => UserCreateNestedManyWithoutFollowersInput, { nullable: true })
-  @Type(() => UserCreateNestedManyWithoutFollowersInput)
-  following?: UserCreateNestedManyWithoutFollowersInput;
+    @Field(() => Role, {nullable:true})
+    role?: keyof typeof Role;
 
-  @Field(() => UserCreateNestedManyWithoutFollowingInput, { nullable: true })
-  @Type(() => UserCreateNestedManyWithoutFollowingInput)
-  followers?: UserCreateNestedManyWithoutFollowingInput;
+    @Field(() => UserCreateNestedManyWithoutFollowersInput, {nullable:true})
+    @Type(() => UserCreateNestedManyWithoutFollowersInput)
+    following?: UserCreateNestedManyWithoutFollowersInput;
 
-  @Field(() => ArticleCreateNestedManyWithoutAuthorInput, { nullable: true })
-  @Type(() => ArticleCreateNestedManyWithoutAuthorInput)
-  articles?: ArticleCreateNestedManyWithoutAuthorInput;
+    @Field(() => UserCreateNestedManyWithoutFollowingInput, {nullable:true})
+    @Type(() => UserCreateNestedManyWithoutFollowingInput)
+    followers?: UserCreateNestedManyWithoutFollowingInput;
 
-  @Field(() => CommentCreateNestedManyWithoutAuthorInput, { nullable: true })
-  @Type(() => CommentCreateNestedManyWithoutAuthorInput)
-  comments?: CommentCreateNestedManyWithoutAuthorInput;
+    @Field(() => ArticleCreateNestedManyWithoutAuthorInput, {nullable:true})
+    @Type(() => ArticleCreateNestedManyWithoutAuthorInput)
+    articles?: ArticleCreateNestedManyWithoutAuthorInput;
 
-  @Field(() => ProfileCreateNestedOneWithoutUserInput, { nullable: true })
-  @Type(() => ProfileCreateNestedOneWithoutUserInput)
-  profile?: ProfileCreateNestedOneWithoutUserInput;
+    @Field(() => CommentCreateNestedManyWithoutAuthorInput, {nullable:true})
+    @Type(() => CommentCreateNestedManyWithoutAuthorInput)
+    comments?: CommentCreateNestedManyWithoutAuthorInput;
+
+    @Field(() => ProfileCreateNestedOneWithoutUserInput, {nullable:true})
+    @Type(() => ProfileCreateNestedOneWithoutUserInput)
+    profile?: ProfileCreateNestedOneWithoutUserInput;
 }
diff --git a/@generated/user/user-create-without-followers.input.ts b/@generated/user/user-create-without-followers.input.ts
index cd592693..10ff8eb1 100644
--- a/@generated/user/user-create-without-followers.input.ts
+++ b/@generated/user/user-create-without-followers.input.ts
@@ -4,7 +4,7 @@ import * as Scalars from 'graphql-scalars';
 import * as Validator from 'class-validator';
 import { Int } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -18,57 +18,58 @@ import { ProfileCreateNestedOneWithoutUserInput } from '../profile/profile-creat
 
 @InputType()
 export class UserCreateWithoutFollowersInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => Scalars.GraphQLEmailAddress, { nullable: false })
-  email!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: false })
-  @Validator.MinLength(3)
-  @Validator.MaxLength(50)
-  name!: string;
+    @Field(() => Scalars.GraphQLEmailAddress, {nullable:false})
+    email!: string;
 
-  @Field(() => String, { nullable: false })
-  password!: string;
+    @Field(() => String, {nullable:false})
+    @Validator.MinLength(3)
+    @Validator.MaxLength(50)
+    name!: string;
 
-  @Field(() => String, { nullable: true })
-  bio?: string;
+    @Field(() => String, {nullable:false})
+    password!: string;
 
-  @Field(() => String, { nullable: true })
-  image?: string;
+    @Field(() => String, {nullable:true})
+    bio?: string;
 
-  @Field(() => Int, { nullable: true })
-  countComments?: number;
+    @Field(() => String, {nullable:true})
+    image?: string;
 
-  @Field(() => Float, { nullable: true })
-  rating?: number;
+    @Field(() => Int, {nullable:true})
+    countComments?: number;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  money?: Decimal;
+    @Field(() => Float, {nullable:true})
+    rating?: number;
 
-  @Field(() => Role, { nullable: true })
-  role?: keyof typeof Role;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    money?: Decimal;
 
-  @Field(() => UserCreateNestedManyWithoutFollowersInput, { nullable: true })
-  @Type(() => UserCreateNestedManyWithoutFollowersInput)
-  following?: UserCreateNestedManyWithoutFollowersInput;
+    @Field(() => Role, {nullable:true})
+    role?: keyof typeof Role;
 
-  @Field(() => ArticleCreateNestedManyWithoutFavoritedByInput, { nullable: true })
-  @Type(() => ArticleCreateNestedManyWithoutFavoritedByInput)
-  favoriteArticles?: ArticleCreateNestedManyWithoutFavoritedByInput;
+    @Field(() => UserCreateNestedManyWithoutFollowersInput, {nullable:true})
+    @Type(() => UserCreateNestedManyWithoutFollowersInput)
+    following?: UserCreateNestedManyWithoutFollowersInput;
 
-  @Field(() => ArticleCreateNestedManyWithoutAuthorInput, { nullable: true })
-  @Type(() => ArticleCreateNestedManyWithoutAuthorInput)
-  articles?: ArticleCreateNestedManyWithoutAuthorInput;
+    @Field(() => ArticleCreateNestedManyWithoutFavoritedByInput, {nullable:true})
+    @Type(() => ArticleCreateNestedManyWithoutFavoritedByInput)
+    favoriteArticles?: ArticleCreateNestedManyWithoutFavoritedByInput;
 
-  @Field(() => CommentCreateNestedManyWithoutAuthorInput, { nullable: true })
-  @Type(() => CommentCreateNestedManyWithoutAuthorInput)
-  comments?: CommentCreateNestedManyWithoutAuthorInput;
+    @Field(() => ArticleCreateNestedManyWithoutAuthorInput, {nullable:true})
+    @Type(() => ArticleCreateNestedManyWithoutAuthorInput)
+    articles?: ArticleCreateNestedManyWithoutAuthorInput;
 
-  @Field(() => ProfileCreateNestedOneWithoutUserInput, { nullable: true })
-  @Type(() => ProfileCreateNestedOneWithoutUserInput)
-  profile?: ProfileCreateNestedOneWithoutUserInput;
+    @Field(() => CommentCreateNestedManyWithoutAuthorInput, {nullable:true})
+    @Type(() => CommentCreateNestedManyWithoutAuthorInput)
+    comments?: CommentCreateNestedManyWithoutAuthorInput;
+
+    @Field(() => ProfileCreateNestedOneWithoutUserInput, {nullable:true})
+    @Type(() => ProfileCreateNestedOneWithoutUserInput)
+    profile?: ProfileCreateNestedOneWithoutUserInput;
 }
diff --git a/@generated/user/user-create-without-following.input.ts b/@generated/user/user-create-without-following.input.ts
index 6c38e021..d10b8bd9 100644
--- a/@generated/user/user-create-without-following.input.ts
+++ b/@generated/user/user-create-without-following.input.ts
@@ -4,7 +4,7 @@ import * as Scalars from 'graphql-scalars';
 import * as Validator from 'class-validator';
 import { Int } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -18,57 +18,58 @@ import { ProfileCreateNestedOneWithoutUserInput } from '../profile/profile-creat
 
 @InputType()
 export class UserCreateWithoutFollowingInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => Scalars.GraphQLEmailAddress, { nullable: false })
-  email!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: false })
-  @Validator.MinLength(3)
-  @Validator.MaxLength(50)
-  name!: string;
+    @Field(() => Scalars.GraphQLEmailAddress, {nullable:false})
+    email!: string;
 
-  @Field(() => String, { nullable: false })
-  password!: string;
+    @Field(() => String, {nullable:false})
+    @Validator.MinLength(3)
+    @Validator.MaxLength(50)
+    name!: string;
 
-  @Field(() => String, { nullable: true })
-  bio?: string;
+    @Field(() => String, {nullable:false})
+    password!: string;
 
-  @Field(() => String, { nullable: true })
-  image?: string;
+    @Field(() => String, {nullable:true})
+    bio?: string;
 
-  @Field(() => Int, { nullable: true })
-  countComments?: number;
+    @Field(() => String, {nullable:true})
+    image?: string;
 
-  @Field(() => Float, { nullable: true })
-  rating?: number;
+    @Field(() => Int, {nullable:true})
+    countComments?: number;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  money?: Decimal;
+    @Field(() => Float, {nullable:true})
+    rating?: number;
 
-  @Field(() => Role, { nullable: true })
-  role?: keyof typeof Role;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    money?: Decimal;
 
-  @Field(() => UserCreateNestedManyWithoutFollowingInput, { nullable: true })
-  @Type(() => UserCreateNestedManyWithoutFollowingInput)
-  followers?: UserCreateNestedManyWithoutFollowingInput;
+    @Field(() => Role, {nullable:true})
+    role?: keyof typeof Role;
 
-  @Field(() => ArticleCreateNestedManyWithoutFavoritedByInput, { nullable: true })
-  @Type(() => ArticleCreateNestedManyWithoutFavoritedByInput)
-  favoriteArticles?: ArticleCreateNestedManyWithoutFavoritedByInput;
+    @Field(() => UserCreateNestedManyWithoutFollowingInput, {nullable:true})
+    @Type(() => UserCreateNestedManyWithoutFollowingInput)
+    followers?: UserCreateNestedManyWithoutFollowingInput;
 
-  @Field(() => ArticleCreateNestedManyWithoutAuthorInput, { nullable: true })
-  @Type(() => ArticleCreateNestedManyWithoutAuthorInput)
-  articles?: ArticleCreateNestedManyWithoutAuthorInput;
+    @Field(() => ArticleCreateNestedManyWithoutFavoritedByInput, {nullable:true})
+    @Type(() => ArticleCreateNestedManyWithoutFavoritedByInput)
+    favoriteArticles?: ArticleCreateNestedManyWithoutFavoritedByInput;
 
-  @Field(() => CommentCreateNestedManyWithoutAuthorInput, { nullable: true })
-  @Type(() => CommentCreateNestedManyWithoutAuthorInput)
-  comments?: CommentCreateNestedManyWithoutAuthorInput;
+    @Field(() => ArticleCreateNestedManyWithoutAuthorInput, {nullable:true})
+    @Type(() => ArticleCreateNestedManyWithoutAuthorInput)
+    articles?: ArticleCreateNestedManyWithoutAuthorInput;
 
-  @Field(() => ProfileCreateNestedOneWithoutUserInput, { nullable: true })
-  @Type(() => ProfileCreateNestedOneWithoutUserInput)
-  profile?: ProfileCreateNestedOneWithoutUserInput;
+    @Field(() => CommentCreateNestedManyWithoutAuthorInput, {nullable:true})
+    @Type(() => CommentCreateNestedManyWithoutAuthorInput)
+    comments?: CommentCreateNestedManyWithoutAuthorInput;
+
+    @Field(() => ProfileCreateNestedOneWithoutUserInput, {nullable:true})
+    @Type(() => ProfileCreateNestedOneWithoutUserInput)
+    profile?: ProfileCreateNestedOneWithoutUserInput;
 }
diff --git a/@generated/user/user-create-without-profile.input.ts b/@generated/user/user-create-without-profile.input.ts
index ce133dfe..cf0de7a4 100644
--- a/@generated/user/user-create-without-profile.input.ts
+++ b/@generated/user/user-create-without-profile.input.ts
@@ -4,7 +4,7 @@ import * as Scalars from 'graphql-scalars';
 import * as Validator from 'class-validator';
 import { Int } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -18,57 +18,58 @@ import { CommentCreateNestedManyWithoutAuthorInput } from '../comment/comment-cr
 
 @InputType()
 export class UserCreateWithoutProfileInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => Scalars.GraphQLEmailAddress, { nullable: false })
-  email!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: false })
-  @Validator.MinLength(3)
-  @Validator.MaxLength(50)
-  name!: string;
+    @Field(() => Scalars.GraphQLEmailAddress, {nullable:false})
+    email!: string;
 
-  @Field(() => String, { nullable: false })
-  password!: string;
+    @Field(() => String, {nullable:false})
+    @Validator.MinLength(3)
+    @Validator.MaxLength(50)
+    name!: string;
 
-  @Field(() => String, { nullable: true })
-  bio?: string;
+    @Field(() => String, {nullable:false})
+    password!: string;
 
-  @Field(() => String, { nullable: true })
-  image?: string;
+    @Field(() => String, {nullable:true})
+    bio?: string;
 
-  @Field(() => Int, { nullable: true })
-  countComments?: number;
+    @Field(() => String, {nullable:true})
+    image?: string;
 
-  @Field(() => Float, { nullable: true })
-  rating?: number;
+    @Field(() => Int, {nullable:true})
+    countComments?: number;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  money?: Decimal;
+    @Field(() => Float, {nullable:true})
+    rating?: number;
 
-  @Field(() => Role, { nullable: true })
-  role?: keyof typeof Role;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    money?: Decimal;
 
-  @Field(() => UserCreateNestedManyWithoutFollowersInput, { nullable: true })
-  @Type(() => UserCreateNestedManyWithoutFollowersInput)
-  following?: UserCreateNestedManyWithoutFollowersInput;
+    @Field(() => Role, {nullable:true})
+    role?: keyof typeof Role;
 
-  @Field(() => UserCreateNestedManyWithoutFollowingInput, { nullable: true })
-  @Type(() => UserCreateNestedManyWithoutFollowingInput)
-  followers?: UserCreateNestedManyWithoutFollowingInput;
+    @Field(() => UserCreateNestedManyWithoutFollowersInput, {nullable:true})
+    @Type(() => UserCreateNestedManyWithoutFollowersInput)
+    following?: UserCreateNestedManyWithoutFollowersInput;
 
-  @Field(() => ArticleCreateNestedManyWithoutFavoritedByInput, { nullable: true })
-  @Type(() => ArticleCreateNestedManyWithoutFavoritedByInput)
-  favoriteArticles?: ArticleCreateNestedManyWithoutFavoritedByInput;
+    @Field(() => UserCreateNestedManyWithoutFollowingInput, {nullable:true})
+    @Type(() => UserCreateNestedManyWithoutFollowingInput)
+    followers?: UserCreateNestedManyWithoutFollowingInput;
 
-  @Field(() => ArticleCreateNestedManyWithoutAuthorInput, { nullable: true })
-  @Type(() => ArticleCreateNestedManyWithoutAuthorInput)
-  articles?: ArticleCreateNestedManyWithoutAuthorInput;
+    @Field(() => ArticleCreateNestedManyWithoutFavoritedByInput, {nullable:true})
+    @Type(() => ArticleCreateNestedManyWithoutFavoritedByInput)
+    favoriteArticles?: ArticleCreateNestedManyWithoutFavoritedByInput;
 
-  @Field(() => CommentCreateNestedManyWithoutAuthorInput, { nullable: true })
-  @Type(() => CommentCreateNestedManyWithoutAuthorInput)
-  comments?: CommentCreateNestedManyWithoutAuthorInput;
+    @Field(() => ArticleCreateNestedManyWithoutAuthorInput, {nullable:true})
+    @Type(() => ArticleCreateNestedManyWithoutAuthorInput)
+    articles?: ArticleCreateNestedManyWithoutAuthorInput;
+
+    @Field(() => CommentCreateNestedManyWithoutAuthorInput, {nullable:true})
+    @Type(() => CommentCreateNestedManyWithoutAuthorInput)
+    comments?: CommentCreateNestedManyWithoutAuthorInput;
 }
diff --git a/@generated/user/user-create.input.ts b/@generated/user/user-create.input.ts
index 655a9a8e..d9c66190 100644
--- a/@generated/user/user-create.input.ts
+++ b/@generated/user/user-create.input.ts
@@ -4,7 +4,7 @@ import * as Scalars from 'graphql-scalars';
 import * as Validator from 'class-validator';
 import { Int } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -19,61 +19,62 @@ import { ProfileCreateNestedOneWithoutUserInput } from '../profile/profile-creat
 
 @InputType()
 export class UserCreateInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => Scalars.GraphQLEmailAddress, { nullable: false })
-  email!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: false })
-  @Validator.MinLength(3)
-  @Validator.MaxLength(50)
-  name!: string;
+    @Field(() => Scalars.GraphQLEmailAddress, {nullable:false})
+    email!: string;
 
-  @Field(() => String, { nullable: false })
-  password!: string;
+    @Field(() => String, {nullable:false})
+    @Validator.MinLength(3)
+    @Validator.MaxLength(50)
+    name!: string;
 
-  @Field(() => String, { nullable: true })
-  bio?: string;
+    @Field(() => String, {nullable:false})
+    password!: string;
 
-  @Field(() => String, { nullable: true })
-  image?: string;
+    @Field(() => String, {nullable:true})
+    bio?: string;
 
-  @Field(() => Int, { nullable: true })
-  countComments?: number;
+    @Field(() => String, {nullable:true})
+    image?: string;
 
-  @Field(() => Float, { nullable: true })
-  rating?: number;
+    @Field(() => Int, {nullable:true})
+    countComments?: number;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  money?: Decimal;
+    @Field(() => Float, {nullable:true})
+    rating?: number;
 
-  @Field(() => Role, { nullable: true })
-  role?: keyof typeof Role;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    money?: Decimal;
 
-  @Field(() => UserCreateNestedManyWithoutFollowersInput, { nullable: true })
-  @Type(() => UserCreateNestedManyWithoutFollowersInput)
-  following?: UserCreateNestedManyWithoutFollowersInput;
+    @Field(() => Role, {nullable:true})
+    role?: keyof typeof Role;
 
-  @Field(() => UserCreateNestedManyWithoutFollowingInput, { nullable: true })
-  @Type(() => UserCreateNestedManyWithoutFollowingInput)
-  followers?: UserCreateNestedManyWithoutFollowingInput;
+    @Field(() => UserCreateNestedManyWithoutFollowersInput, {nullable:true})
+    @Type(() => UserCreateNestedManyWithoutFollowersInput)
+    following?: UserCreateNestedManyWithoutFollowersInput;
 
-  @Field(() => ArticleCreateNestedManyWithoutFavoritedByInput, { nullable: true })
-  @Type(() => ArticleCreateNestedManyWithoutFavoritedByInput)
-  favoriteArticles?: ArticleCreateNestedManyWithoutFavoritedByInput;
+    @Field(() => UserCreateNestedManyWithoutFollowingInput, {nullable:true})
+    @Type(() => UserCreateNestedManyWithoutFollowingInput)
+    followers?: UserCreateNestedManyWithoutFollowingInput;
 
-  @Field(() => ArticleCreateNestedManyWithoutAuthorInput, { nullable: true })
-  @Type(() => ArticleCreateNestedManyWithoutAuthorInput)
-  articles?: ArticleCreateNestedManyWithoutAuthorInput;
+    @Field(() => ArticleCreateNestedManyWithoutFavoritedByInput, {nullable:true})
+    @Type(() => ArticleCreateNestedManyWithoutFavoritedByInput)
+    favoriteArticles?: ArticleCreateNestedManyWithoutFavoritedByInput;
 
-  @Field(() => CommentCreateNestedManyWithoutAuthorInput, { nullable: true })
-  @Type(() => CommentCreateNestedManyWithoutAuthorInput)
-  comments?: CommentCreateNestedManyWithoutAuthorInput;
+    @Field(() => ArticleCreateNestedManyWithoutAuthorInput, {nullable:true})
+    @Type(() => ArticleCreateNestedManyWithoutAuthorInput)
+    articles?: ArticleCreateNestedManyWithoutAuthorInput;
 
-  @Field(() => ProfileCreateNestedOneWithoutUserInput, { nullable: true })
-  @Type(() => ProfileCreateNestedOneWithoutUserInput)
-  profile?: ProfileCreateNestedOneWithoutUserInput;
+    @Field(() => CommentCreateNestedManyWithoutAuthorInput, {nullable:true})
+    @Type(() => CommentCreateNestedManyWithoutAuthorInput)
+    comments?: CommentCreateNestedManyWithoutAuthorInput;
+
+    @Field(() => ProfileCreateNestedOneWithoutUserInput, {nullable:true})
+    @Type(() => ProfileCreateNestedOneWithoutUserInput)
+    profile?: ProfileCreateNestedOneWithoutUserInput;
 }
diff --git a/@generated/user/user-email-name-compound-unique.input.ts b/@generated/user/user-email-name-compound-unique.input.ts
index ff9c42a2..eceddbfe 100644
--- a/@generated/user/user-email-name-compound-unique.input.ts
+++ b/@generated/user/user-email-name-compound-unique.input.ts
@@ -5,11 +5,12 @@ import * as Validator from 'class-validator';
 
 @InputType()
 export class UserEmailNameCompoundUniqueInput {
-  @Field(() => Scalars.GraphQLEmailAddress, { nullable: false })
-  email!: string;
 
-  @Field(() => String, { nullable: false })
-  @Validator.MinLength(3)
-  @Validator.MaxLength(50)
-  name!: string;
+    @Field(() => Scalars.GraphQLEmailAddress, {nullable:false})
+    email!: string;
+
+    @Field(() => String, {nullable:false})
+    @Validator.MinLength(3)
+    @Validator.MaxLength(50)
+    name!: string;
 }
diff --git a/@generated/user/user-group-by.args.ts b/@generated/user/user-group-by.args.ts
index 1ac234b1..ffdc3b3c 100644
--- a/@generated/user/user-group-by.args.ts
+++ b/@generated/user/user-group-by.args.ts
@@ -14,44 +14,45 @@ import { UserMaxAggregateInput } from './user-max-aggregate.input';
 
 @ArgsType()
 export class UserGroupByArgs {
-  @Field(() => UserWhereInput, { nullable: true })
-  @Type(() => UserWhereInput)
-  where?: UserWhereInput;
 
-  @Field(() => [UserOrderByWithAggregationInput], { nullable: true })
-  @Type(() => UserOrderByWithAggregationInput)
-  orderBy?: Array<UserOrderByWithAggregationInput>;
+    @Field(() => UserWhereInput, {nullable:true})
+    @Type(() => UserWhereInput)
+    where?: UserWhereInput;
 
-  @Field(() => [UserScalarFieldEnum], { nullable: false })
-  by!: Array<keyof typeof UserScalarFieldEnum>;
+    @Field(() => [UserOrderByWithAggregationInput], {nullable:true})
+    @Type(() => UserOrderByWithAggregationInput)
+    orderBy?: Array<UserOrderByWithAggregationInput>;
 
-  @Field(() => UserScalarWhereWithAggregatesInput, { nullable: true })
-  @Type(() => UserScalarWhereWithAggregatesInput)
-  having?: UserScalarWhereWithAggregatesInput;
+    @Field(() => [UserScalarFieldEnum], {nullable:false})
+    by!: Array<keyof typeof UserScalarFieldEnum>;
 
-  @Field(() => Int, { nullable: true })
-  take?: number;
+    @Field(() => UserScalarWhereWithAggregatesInput, {nullable:true})
+    @Type(() => UserScalarWhereWithAggregatesInput)
+    having?: UserScalarWhereWithAggregatesInput;
 
-  @Field(() => Int, { nullable: true })
-  skip?: number;
+    @Field(() => Int, {nullable:true})
+    take?: number;
 
-  @Field(() => UserCountAggregateInput, { nullable: true })
-  @Type(() => UserCountAggregateInput)
-  _count?: UserCountAggregateInput;
+    @Field(() => Int, {nullable:true})
+    skip?: number;
 
-  @Field(() => UserAvgAggregateInput, { nullable: true })
-  @Type(() => UserAvgAggregateInput)
-  _avg?: UserAvgAggregateInput;
+    @Field(() => UserCountAggregateInput, {nullable:true})
+    @Type(() => UserCountAggregateInput)
+    _count?: UserCountAggregateInput;
 
-  @Field(() => UserSumAggregateInput, { nullable: true })
-  @Type(() => UserSumAggregateInput)
-  _sum?: UserSumAggregateInput;
+    @Field(() => UserAvgAggregateInput, {nullable:true})
+    @Type(() => UserAvgAggregateInput)
+    _avg?: UserAvgAggregateInput;
 
-  @Field(() => UserMinAggregateInput, { nullable: true })
-  @Type(() => UserMinAggregateInput)
-  _min?: UserMinAggregateInput;
+    @Field(() => UserSumAggregateInput, {nullable:true})
+    @Type(() => UserSumAggregateInput)
+    _sum?: UserSumAggregateInput;
 
-  @Field(() => UserMaxAggregateInput, { nullable: true })
-  @Type(() => UserMaxAggregateInput)
-  _max?: UserMaxAggregateInput;
+    @Field(() => UserMinAggregateInput, {nullable:true})
+    @Type(() => UserMinAggregateInput)
+    _min?: UserMinAggregateInput;
+
+    @Field(() => UserMaxAggregateInput, {nullable:true})
+    @Type(() => UserMaxAggregateInput)
+    _max?: UserMaxAggregateInput;
 }
diff --git a/@generated/user/user-group-by.output.ts b/@generated/user/user-group-by.output.ts
index fc073556..1a6d7b7b 100644
--- a/@generated/user/user-group-by.output.ts
+++ b/@generated/user/user-group-by.output.ts
@@ -3,7 +3,7 @@ import { ObjectType } from '@nestjs/graphql';
 import { HideField } from '@nestjs/graphql';
 import { Int } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { Role } from '../prisma/role.enum';
 import { UserCountAggregate } from './user-count-aggregate.output';
@@ -14,48 +14,49 @@ import { UserMaxAggregate } from './user-max-aggregate.output';
 
 @ObjectType()
 export class UserGroupBy {
-  @Field(() => String, { nullable: false })
-  id!: string;
 
-  @Field(() => String, { nullable: false })
-  email!: string;
+    @Field(() => String, {nullable:false})
+    id!: string;
 
-  @Field(() => String, { nullable: false })
-  name!: string;
+    @Field(() => String, {nullable:false})
+    email!: string;
 
-  @HideField()
-  password!: string;
+    @Field(() => String, {nullable:false})
+    name!: string;
 
-  @Field(() => String, { nullable: true })
-  bio?: string;
+    @HideField()
+    password!: string;
 
-  @Field(() => String, { nullable: true })
-  image?: string;
+    @Field(() => String, {nullable:true})
+    bio?: string;
 
-  @Field(() => Int, { nullable: true })
-  countComments?: number;
+    @Field(() => String, {nullable:true})
+    image?: string;
 
-  @Field(() => Float, { nullable: true })
-  rating?: number;
+    @Field(() => Int, {nullable:true})
+    countComments?: number;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  money?: Decimal;
+    @Field(() => Float, {nullable:true})
+    rating?: number;
 
-  @Field(() => Role, { nullable: true })
-  role?: keyof typeof Role;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    money?: Decimal;
 
-  @Field(() => UserCountAggregate, { nullable: true })
-  _count?: UserCountAggregate;
+    @Field(() => Role, {nullable:true})
+    role?: keyof typeof Role;
 
-  @Field(() => UserAvgAggregate, { nullable: true })
-  _avg?: UserAvgAggregate;
+    @Field(() => UserCountAggregate, {nullable:true})
+    _count?: UserCountAggregate;
 
-  @Field(() => UserSumAggregate, { nullable: true })
-  _sum?: UserSumAggregate;
+    @Field(() => UserAvgAggregate, {nullable:true})
+    _avg?: UserAvgAggregate;
 
-  @Field(() => UserMinAggregate, { nullable: true })
-  _min?: UserMinAggregate;
+    @Field(() => UserSumAggregate, {nullable:true})
+    _sum?: UserSumAggregate;
 
-  @Field(() => UserMaxAggregate, { nullable: true })
-  _max?: UserMaxAggregate;
+    @Field(() => UserMinAggregate, {nullable:true})
+    _min?: UserMinAggregate;
+
+    @Field(() => UserMaxAggregate, {nullable:true})
+    _max?: UserMaxAggregate;
 }
diff --git a/@generated/user/user-list-relation-filter.input.ts b/@generated/user/user-list-relation-filter.input.ts
index 2523b2ef..adeafd46 100644
--- a/@generated/user/user-list-relation-filter.input.ts
+++ b/@generated/user/user-list-relation-filter.input.ts
@@ -5,15 +5,16 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class UserListRelationFilter {
-  @Field(() => UserWhereInput, { nullable: true })
-  @Type(() => UserWhereInput)
-  every?: UserWhereInput;
 
-  @Field(() => UserWhereInput, { nullable: true })
-  @Type(() => UserWhereInput)
-  some?: UserWhereInput;
+    @Field(() => UserWhereInput, {nullable:true})
+    @Type(() => UserWhereInput)
+    every?: UserWhereInput;
 
-  @Field(() => UserWhereInput, { nullable: true })
-  @Type(() => UserWhereInput)
-  none?: UserWhereInput;
+    @Field(() => UserWhereInput, {nullable:true})
+    @Type(() => UserWhereInput)
+    some?: UserWhereInput;
+
+    @Field(() => UserWhereInput, {nullable:true})
+    @Type(() => UserWhereInput)
+    none?: UserWhereInput;
 }
diff --git a/@generated/user/user-max-aggregate.input.ts b/@generated/user/user-max-aggregate.input.ts
index f3920921..3f1564e7 100644
--- a/@generated/user/user-max-aggregate.input.ts
+++ b/@generated/user/user-max-aggregate.input.ts
@@ -3,33 +3,34 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class UserMaxAggregateInput {
-  @Field(() => Boolean, { nullable: true })
-  id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  email?: true;
+    @Field(() => Boolean, {nullable:true})
+    id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  name?: true;
+    @Field(() => Boolean, {nullable:true})
+    email?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  password?: true;
+    @Field(() => Boolean, {nullable:true})
+    name?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  bio?: true;
+    @Field(() => Boolean, {nullable:true})
+    password?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  image?: true;
+    @Field(() => Boolean, {nullable:true})
+    bio?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  countComments?: true;
+    @Field(() => Boolean, {nullable:true})
+    image?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  rating?: true;
+    @Field(() => Boolean, {nullable:true})
+    countComments?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  money?: true;
+    @Field(() => Boolean, {nullable:true})
+    rating?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  role?: true;
+    @Field(() => Boolean, {nullable:true})
+    money?: true;
+
+    @Field(() => Boolean, {nullable:true})
+    role?: true;
 }
diff --git a/@generated/user/user-max-aggregate.output.ts b/@generated/user/user-max-aggregate.output.ts
index e8ba333f..a773c7a5 100644
--- a/@generated/user/user-max-aggregate.output.ts
+++ b/@generated/user/user-max-aggregate.output.ts
@@ -3,39 +3,40 @@ import { ObjectType } from '@nestjs/graphql';
 import { HideField } from '@nestjs/graphql';
 import { Int } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { Role } from '../prisma/role.enum';
 
 @ObjectType()
 export class UserMaxAggregate {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => String, { nullable: true })
-  email?: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: true })
-  name?: string;
+    @Field(() => String, {nullable:true})
+    email?: string;
 
-  @HideField()
-  password?: string;
+    @Field(() => String, {nullable:true})
+    name?: string;
 
-  @Field(() => String, { nullable: true })
-  bio?: string;
+    @HideField()
+    password?: string;
 
-  @Field(() => String, { nullable: true })
-  image?: string;
+    @Field(() => String, {nullable:true})
+    bio?: string;
 
-  @Field(() => Int, { nullable: true })
-  countComments?: number;
+    @Field(() => String, {nullable:true})
+    image?: string;
 
-  @Field(() => Float, { nullable: true })
-  rating?: number;
+    @Field(() => Int, {nullable:true})
+    countComments?: number;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  money?: Decimal;
+    @Field(() => Float, {nullable:true})
+    rating?: number;
 
-  @Field(() => Role, { nullable: true })
-  role?: keyof typeof Role;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    money?: Decimal;
+
+    @Field(() => Role, {nullable:true})
+    role?: keyof typeof Role;
 }
diff --git a/@generated/user/user-max-order-by-aggregate.input.ts b/@generated/user/user-max-order-by-aggregate.input.ts
index 57a956c3..4e5e2d21 100644
--- a/@generated/user/user-max-order-by-aggregate.input.ts
+++ b/@generated/user/user-max-order-by-aggregate.input.ts
@@ -4,33 +4,34 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class UserMaxOrderByAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  email?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  name?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    email?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  password?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    name?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  bio?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    password?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  image?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    bio?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  countComments?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    image?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  rating?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    countComments?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  money?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    rating?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  role?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    money?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    role?: keyof typeof SortOrder;
 }
diff --git a/@generated/user/user-min-aggregate.input.ts b/@generated/user/user-min-aggregate.input.ts
index de25c6bb..ce742ffe 100644
--- a/@generated/user/user-min-aggregate.input.ts
+++ b/@generated/user/user-min-aggregate.input.ts
@@ -3,33 +3,34 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class UserMinAggregateInput {
-  @Field(() => Boolean, { nullable: true })
-  id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  email?: true;
+    @Field(() => Boolean, {nullable:true})
+    id?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  name?: true;
+    @Field(() => Boolean, {nullable:true})
+    email?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  password?: true;
+    @Field(() => Boolean, {nullable:true})
+    name?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  bio?: true;
+    @Field(() => Boolean, {nullable:true})
+    password?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  image?: true;
+    @Field(() => Boolean, {nullable:true})
+    bio?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  countComments?: true;
+    @Field(() => Boolean, {nullable:true})
+    image?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  rating?: true;
+    @Field(() => Boolean, {nullable:true})
+    countComments?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  money?: true;
+    @Field(() => Boolean, {nullable:true})
+    rating?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  role?: true;
+    @Field(() => Boolean, {nullable:true})
+    money?: true;
+
+    @Field(() => Boolean, {nullable:true})
+    role?: true;
 }
diff --git a/@generated/user/user-min-aggregate.output.ts b/@generated/user/user-min-aggregate.output.ts
index 77b87c7f..9eea533d 100644
--- a/@generated/user/user-min-aggregate.output.ts
+++ b/@generated/user/user-min-aggregate.output.ts
@@ -3,39 +3,40 @@ import { ObjectType } from '@nestjs/graphql';
 import { HideField } from '@nestjs/graphql';
 import { Int } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { Role } from '../prisma/role.enum';
 
 @ObjectType()
 export class UserMinAggregate {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => String, { nullable: true })
-  email?: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: true })
-  name?: string;
+    @Field(() => String, {nullable:true})
+    email?: string;
 
-  @HideField()
-  password?: string;
+    @Field(() => String, {nullable:true})
+    name?: string;
 
-  @Field(() => String, { nullable: true })
-  bio?: string;
+    @HideField()
+    password?: string;
 
-  @Field(() => String, { nullable: true })
-  image?: string;
+    @Field(() => String, {nullable:true})
+    bio?: string;
 
-  @Field(() => Int, { nullable: true })
-  countComments?: number;
+    @Field(() => String, {nullable:true})
+    image?: string;
 
-  @Field(() => Float, { nullable: true })
-  rating?: number;
+    @Field(() => Int, {nullable:true})
+    countComments?: number;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  money?: Decimal;
+    @Field(() => Float, {nullable:true})
+    rating?: number;
 
-  @Field(() => Role, { nullable: true })
-  role?: keyof typeof Role;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    money?: Decimal;
+
+    @Field(() => Role, {nullable:true})
+    role?: keyof typeof Role;
 }
diff --git a/@generated/user/user-min-order-by-aggregate.input.ts b/@generated/user/user-min-order-by-aggregate.input.ts
index 3967a710..62001976 100644
--- a/@generated/user/user-min-order-by-aggregate.input.ts
+++ b/@generated/user/user-min-order-by-aggregate.input.ts
@@ -4,33 +4,34 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class UserMinOrderByAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  email?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  name?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    email?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  password?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    name?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  bio?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    password?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  image?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    bio?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  countComments?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    image?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  rating?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    countComments?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  money?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    rating?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  role?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    money?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    role?: keyof typeof SortOrder;
 }
diff --git a/@generated/user/user-order-by-relation-aggregate.input.ts b/@generated/user/user-order-by-relation-aggregate.input.ts
index 58cb846b..b7b3bd36 100644
--- a/@generated/user/user-order-by-relation-aggregate.input.ts
+++ b/@generated/user/user-order-by-relation-aggregate.input.ts
@@ -4,6 +4,7 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class UserOrderByRelationAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  _count?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    _count?: keyof typeof SortOrder;
 }
diff --git a/@generated/user/user-order-by-relevance-field.enum.ts b/@generated/user/user-order-by-relevance-field.enum.ts
index f993dae0..90121ee2 100644
--- a/@generated/user/user-order-by-relevance-field.enum.ts
+++ b/@generated/user/user-order-by-relevance-field.enum.ts
@@ -1,15 +1,13 @@
 import { registerEnumType } from '@nestjs/graphql';
 
 export enum UserOrderByRelevanceFieldEnum {
-  id = 'id',
-  email = 'email',
-  name = 'name',
-  password = 'password',
-  bio = 'bio',
-  image = 'image',
+    id = "id",
+    email = "email",
+    name = "name",
+    password = "password",
+    bio = "bio",
+    image = "image"
 }
 
-registerEnumType(UserOrderByRelevanceFieldEnum, {
-  name: 'UserOrderByRelevanceFieldEnum',
-  description: undefined,
-});
+
+registerEnumType(UserOrderByRelevanceFieldEnum, { name: 'UserOrderByRelevanceFieldEnum', description: undefined })
diff --git a/@generated/user/user-order-by-relevance.input.ts b/@generated/user/user-order-by-relevance.input.ts
index 12d1566f..34306603 100644
--- a/@generated/user/user-order-by-relevance.input.ts
+++ b/@generated/user/user-order-by-relevance.input.ts
@@ -5,12 +5,13 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class UserOrderByRelevanceInput {
-  @Field(() => [UserOrderByRelevanceFieldEnum], { nullable: false })
-  fields!: Array<keyof typeof UserOrderByRelevanceFieldEnum>;
 
-  @Field(() => SortOrder, { nullable: false })
-  sort!: keyof typeof SortOrder;
+    @Field(() => [UserOrderByRelevanceFieldEnum], {nullable:false})
+    fields!: Array<keyof typeof UserOrderByRelevanceFieldEnum>;
 
-  @Field(() => String, { nullable: false })
-  search!: string;
+    @Field(() => SortOrder, {nullable:false})
+    sort!: keyof typeof SortOrder;
+
+    @Field(() => String, {nullable:false})
+    search!: string;
 }
diff --git a/@generated/user/user-order-by-with-aggregation.input.ts b/@generated/user/user-order-by-with-aggregation.input.ts
index 61f37628..2f44a599 100644
--- a/@generated/user/user-order-by-with-aggregation.input.ts
+++ b/@generated/user/user-order-by-with-aggregation.input.ts
@@ -11,54 +11,55 @@ import { UserSumOrderByAggregateInput } from './user-sum-order-by-aggregate.inpu
 
 @InputType()
 export class UserOrderByWithAggregationInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  email?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  name?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    email?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  password?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    name?: keyof typeof SortOrder;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  bio?: SortOrderInput;
+    @Field(() => SortOrder, {nullable:true})
+    password?: keyof typeof SortOrder;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  image?: SortOrderInput;
+    @Field(() => SortOrderInput, {nullable:true})
+    bio?: SortOrderInput;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  countComments?: SortOrderInput;
+    @Field(() => SortOrderInput, {nullable:true})
+    image?: SortOrderInput;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  rating?: SortOrderInput;
+    @Field(() => SortOrderInput, {nullable:true})
+    countComments?: SortOrderInput;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  @Type(() => SortOrderInput)
-  money?: SortOrderInput;
+    @Field(() => SortOrderInput, {nullable:true})
+    rating?: SortOrderInput;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  role?: SortOrderInput;
+    @Field(() => SortOrderInput, {nullable:true})
+    @Type(() => SortOrderInput)
+    money?: SortOrderInput;
 
-  @Field(() => UserCountOrderByAggregateInput, { nullable: true })
-  @Type(() => UserCountOrderByAggregateInput)
-  _count?: UserCountOrderByAggregateInput;
+    @Field(() => SortOrderInput, {nullable:true})
+    role?: SortOrderInput;
 
-  @Field(() => UserAvgOrderByAggregateInput, { nullable: true })
-  @Type(() => UserAvgOrderByAggregateInput)
-  _avg?: UserAvgOrderByAggregateInput;
+    @Field(() => UserCountOrderByAggregateInput, {nullable:true})
+    @Type(() => UserCountOrderByAggregateInput)
+    _count?: UserCountOrderByAggregateInput;
 
-  @Field(() => UserMaxOrderByAggregateInput, { nullable: true })
-  @Type(() => UserMaxOrderByAggregateInput)
-  _max?: UserMaxOrderByAggregateInput;
+    @Field(() => UserAvgOrderByAggregateInput, {nullable:true})
+    @Type(() => UserAvgOrderByAggregateInput)
+    _avg?: UserAvgOrderByAggregateInput;
 
-  @Field(() => UserMinOrderByAggregateInput, { nullable: true })
-  @Type(() => UserMinOrderByAggregateInput)
-  _min?: UserMinOrderByAggregateInput;
+    @Field(() => UserMaxOrderByAggregateInput, {nullable:true})
+    @Type(() => UserMaxOrderByAggregateInput)
+    _max?: UserMaxOrderByAggregateInput;
 
-  @Field(() => UserSumOrderByAggregateInput, { nullable: true })
-  @Type(() => UserSumOrderByAggregateInput)
-  _sum?: UserSumOrderByAggregateInput;
+    @Field(() => UserMinOrderByAggregateInput, {nullable:true})
+    @Type(() => UserMinOrderByAggregateInput)
+    _min?: UserMinOrderByAggregateInput;
+
+    @Field(() => UserSumOrderByAggregateInput, {nullable:true})
+    @Type(() => UserSumOrderByAggregateInput)
+    _sum?: UserSumOrderByAggregateInput;
 }
diff --git a/@generated/user/user-order-by-with-relation-and-search-relevance.input.ts b/@generated/user/user-order-by-with-relation-and-search-relevance.input.ts
index eae18230..c5ea3224 100644
--- a/@generated/user/user-order-by-with-relation-and-search-relevance.input.ts
+++ b/@generated/user/user-order-by-with-relation-and-search-relevance.input.ts
@@ -11,62 +11,63 @@ import { UserOrderByRelevanceInput } from './user-order-by-relevance.input';
 
 @InputType()
 export class UserOrderByWithRelationAndSearchRelevanceInput {
-  @Field(() => SortOrder, { nullable: true })
-  id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  email?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    id?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  name?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    email?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  password?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    name?: keyof typeof SortOrder;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  bio?: SortOrderInput;
+    @Field(() => SortOrder, {nullable:true})
+    password?: keyof typeof SortOrder;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  image?: SortOrderInput;
+    @Field(() => SortOrderInput, {nullable:true})
+    bio?: SortOrderInput;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  countComments?: SortOrderInput;
+    @Field(() => SortOrderInput, {nullable:true})
+    image?: SortOrderInput;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  rating?: SortOrderInput;
+    @Field(() => SortOrderInput, {nullable:true})
+    countComments?: SortOrderInput;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  @Type(() => SortOrderInput)
-  money?: SortOrderInput;
+    @Field(() => SortOrderInput, {nullable:true})
+    rating?: SortOrderInput;
 
-  @Field(() => SortOrderInput, { nullable: true })
-  role?: SortOrderInput;
+    @Field(() => SortOrderInput, {nullable:true})
+    @Type(() => SortOrderInput)
+    money?: SortOrderInput;
 
-  @Field(() => UserOrderByRelationAggregateInput, { nullable: true })
-  @Type(() => UserOrderByRelationAggregateInput)
-  following?: UserOrderByRelationAggregateInput;
+    @Field(() => SortOrderInput, {nullable:true})
+    role?: SortOrderInput;
 
-  @Field(() => UserOrderByRelationAggregateInput, { nullable: true })
-  @Type(() => UserOrderByRelationAggregateInput)
-  followers?: UserOrderByRelationAggregateInput;
+    @Field(() => UserOrderByRelationAggregateInput, {nullable:true})
+    @Type(() => UserOrderByRelationAggregateInput)
+    following?: UserOrderByRelationAggregateInput;
 
-  @Field(() => ArticleOrderByRelationAggregateInput, { nullable: true })
-  @Type(() => ArticleOrderByRelationAggregateInput)
-  favoriteArticles?: ArticleOrderByRelationAggregateInput;
+    @Field(() => UserOrderByRelationAggregateInput, {nullable:true})
+    @Type(() => UserOrderByRelationAggregateInput)
+    followers?: UserOrderByRelationAggregateInput;
 
-  @Field(() => ArticleOrderByRelationAggregateInput, { nullable: true })
-  @Type(() => ArticleOrderByRelationAggregateInput)
-  articles?: ArticleOrderByRelationAggregateInput;
+    @Field(() => ArticleOrderByRelationAggregateInput, {nullable:true})
+    @Type(() => ArticleOrderByRelationAggregateInput)
+    favoriteArticles?: ArticleOrderByRelationAggregateInput;
 
-  @Field(() => CommentOrderByRelationAggregateInput, { nullable: true })
-  @Type(() => CommentOrderByRelationAggregateInput)
-  comments?: CommentOrderByRelationAggregateInput;
+    @Field(() => ArticleOrderByRelationAggregateInput, {nullable:true})
+    @Type(() => ArticleOrderByRelationAggregateInput)
+    articles?: ArticleOrderByRelationAggregateInput;
 
-  @Field(() => ProfileOrderByWithRelationAndSearchRelevanceInput, { nullable: true })
-  @Type(() => ProfileOrderByWithRelationAndSearchRelevanceInput)
-  profile?: ProfileOrderByWithRelationAndSearchRelevanceInput;
+    @Field(() => CommentOrderByRelationAggregateInput, {nullable:true})
+    @Type(() => CommentOrderByRelationAggregateInput)
+    comments?: CommentOrderByRelationAggregateInput;
 
-  @Field(() => UserOrderByRelevanceInput, { nullable: true })
-  @Type(() => UserOrderByRelevanceInput)
-  _relevance?: UserOrderByRelevanceInput;
+    @Field(() => ProfileOrderByWithRelationAndSearchRelevanceInput, {nullable:true})
+    @Type(() => ProfileOrderByWithRelationAndSearchRelevanceInput)
+    profile?: ProfileOrderByWithRelationAndSearchRelevanceInput;
+
+    @Field(() => UserOrderByRelevanceInput, {nullable:true})
+    @Type(() => UserOrderByRelevanceInput)
+    _relevance?: UserOrderByRelevanceInput;
 }
diff --git a/@generated/user/user-relation-filter.input.ts b/@generated/user/user-relation-filter.input.ts
index 80cc6916..54bafe6d 100644
--- a/@generated/user/user-relation-filter.input.ts
+++ b/@generated/user/user-relation-filter.input.ts
@@ -5,11 +5,12 @@ import { Type } from 'class-transformer';
 
 @InputType()
 export class UserRelationFilter {
-  @Field(() => UserWhereInput, { nullable: true })
-  @Type(() => UserWhereInput)
-  is?: UserWhereInput;
 
-  @Field(() => UserWhereInput, { nullable: true })
-  @Type(() => UserWhereInput)
-  isNot?: UserWhereInput;
+    @Field(() => UserWhereInput, {nullable:true})
+    @Type(() => UserWhereInput)
+    is?: UserWhereInput;
+
+    @Field(() => UserWhereInput, {nullable:true})
+    @Type(() => UserWhereInput)
+    isNot?: UserWhereInput;
 }
diff --git a/@generated/user/user-scalar-field.enum.ts b/@generated/user/user-scalar-field.enum.ts
index d1755369..8125c74f 100644
--- a/@generated/user/user-scalar-field.enum.ts
+++ b/@generated/user/user-scalar-field.enum.ts
@@ -1,19 +1,17 @@
 import { registerEnumType } from '@nestjs/graphql';
 
 export enum UserScalarFieldEnum {
-  id = 'id',
-  email = 'email',
-  name = 'name',
-  password = 'password',
-  bio = 'bio',
-  image = 'image',
-  countComments = 'countComments',
-  rating = 'rating',
-  money = 'money',
-  role = 'role',
+    id = "id",
+    email = "email",
+    name = "name",
+    password = "password",
+    bio = "bio",
+    image = "image",
+    countComments = "countComments",
+    rating = "rating",
+    money = "money",
+    role = "role"
 }
 
-registerEnumType(UserScalarFieldEnum, {
-  name: 'UserScalarFieldEnum',
-  description: undefined,
-});
+
+registerEnumType(UserScalarFieldEnum, { name: 'UserScalarFieldEnum', description: undefined })
diff --git a/@generated/user/user-scalar-where-with-aggregates.input.ts b/@generated/user/user-scalar-where-with-aggregates.input.ts
index 3ab62388..66b743b6 100644
--- a/@generated/user/user-scalar-where-with-aggregates.input.ts
+++ b/@generated/user/user-scalar-where-with-aggregates.input.ts
@@ -10,46 +10,47 @@ import { EnumRoleNullableWithAggregatesFilter } from '../prisma/enum-role-nullab
 
 @InputType()
 export class UserScalarWhereWithAggregatesInput {
-  @Field(() => [UserScalarWhereWithAggregatesInput], { nullable: true })
-  @Type(() => UserScalarWhereWithAggregatesInput)
-  AND?: Array<UserScalarWhereWithAggregatesInput>;
 
-  @Field(() => [UserScalarWhereWithAggregatesInput], { nullable: true })
-  @Type(() => UserScalarWhereWithAggregatesInput)
-  OR?: Array<UserScalarWhereWithAggregatesInput>;
+    @Field(() => [UserScalarWhereWithAggregatesInput], {nullable:true})
+    @Type(() => UserScalarWhereWithAggregatesInput)
+    AND?: Array<UserScalarWhereWithAggregatesInput>;
 
-  @Field(() => [UserScalarWhereWithAggregatesInput], { nullable: true })
-  @Type(() => UserScalarWhereWithAggregatesInput)
-  NOT?: Array<UserScalarWhereWithAggregatesInput>;
+    @Field(() => [UserScalarWhereWithAggregatesInput], {nullable:true})
+    @Type(() => UserScalarWhereWithAggregatesInput)
+    OR?: Array<UserScalarWhereWithAggregatesInput>;
 
-  @Field(() => StringWithAggregatesFilter, { nullable: true })
-  id?: StringWithAggregatesFilter;
+    @Field(() => [UserScalarWhereWithAggregatesInput], {nullable:true})
+    @Type(() => UserScalarWhereWithAggregatesInput)
+    NOT?: Array<UserScalarWhereWithAggregatesInput>;
 
-  @Field(() => StringWithAggregatesFilter, { nullable: true })
-  email?: StringWithAggregatesFilter;
+    @Field(() => StringWithAggregatesFilter, {nullable:true})
+    id?: StringWithAggregatesFilter;
 
-  @Field(() => StringWithAggregatesFilter, { nullable: true })
-  name?: StringWithAggregatesFilter;
+    @Field(() => StringWithAggregatesFilter, {nullable:true})
+    email?: StringWithAggregatesFilter;
 
-  @Field(() => StringWithAggregatesFilter, { nullable: true })
-  password?: StringWithAggregatesFilter;
+    @Field(() => StringWithAggregatesFilter, {nullable:true})
+    name?: StringWithAggregatesFilter;
 
-  @Field(() => StringNullableWithAggregatesFilter, { nullable: true })
-  bio?: StringNullableWithAggregatesFilter;
+    @Field(() => StringWithAggregatesFilter, {nullable:true})
+    password?: StringWithAggregatesFilter;
 
-  @Field(() => StringNullableWithAggregatesFilter, { nullable: true })
-  image?: StringNullableWithAggregatesFilter;
+    @Field(() => StringNullableWithAggregatesFilter, {nullable:true})
+    bio?: StringNullableWithAggregatesFilter;
 
-  @Field(() => IntNullableWithAggregatesFilter, { nullable: true })
-  countComments?: IntNullableWithAggregatesFilter;
+    @Field(() => StringNullableWithAggregatesFilter, {nullable:true})
+    image?: StringNullableWithAggregatesFilter;
 
-  @Field(() => FloatNullableWithAggregatesFilter, { nullable: true })
-  rating?: FloatNullableWithAggregatesFilter;
+    @Field(() => IntNullableWithAggregatesFilter, {nullable:true})
+    countComments?: IntNullableWithAggregatesFilter;
 
-  @Field(() => DecimalNullableWithAggregatesFilter, { nullable: true })
-  @Type(() => DecimalNullableWithAggregatesFilter)
-  money?: DecimalNullableWithAggregatesFilter;
+    @Field(() => FloatNullableWithAggregatesFilter, {nullable:true})
+    rating?: FloatNullableWithAggregatesFilter;
 
-  @Field(() => EnumRoleNullableWithAggregatesFilter, { nullable: true })
-  role?: EnumRoleNullableWithAggregatesFilter;
+    @Field(() => DecimalNullableWithAggregatesFilter, {nullable:true})
+    @Type(() => DecimalNullableWithAggregatesFilter)
+    money?: DecimalNullableWithAggregatesFilter;
+
+    @Field(() => EnumRoleNullableWithAggregatesFilter, {nullable:true})
+    role?: EnumRoleNullableWithAggregatesFilter;
 }
diff --git a/@generated/user/user-scalar-where.input.ts b/@generated/user/user-scalar-where.input.ts
index fb73a41a..1453c44d 100644
--- a/@generated/user/user-scalar-where.input.ts
+++ b/@generated/user/user-scalar-where.input.ts
@@ -10,46 +10,47 @@ import { EnumRoleNullableFilter } from '../prisma/enum-role-nullable-filter.inpu
 
 @InputType()
 export class UserScalarWhereInput {
-  @Field(() => [UserScalarWhereInput], { nullable: true })
-  @Type(() => UserScalarWhereInput)
-  AND?: Array<UserScalarWhereInput>;
 
-  @Field(() => [UserScalarWhereInput], { nullable: true })
-  @Type(() => UserScalarWhereInput)
-  OR?: Array<UserScalarWhereInput>;
+    @Field(() => [UserScalarWhereInput], {nullable:true})
+    @Type(() => UserScalarWhereInput)
+    AND?: Array<UserScalarWhereInput>;
 
-  @Field(() => [UserScalarWhereInput], { nullable: true })
-  @Type(() => UserScalarWhereInput)
-  NOT?: Array<UserScalarWhereInput>;
+    @Field(() => [UserScalarWhereInput], {nullable:true})
+    @Type(() => UserScalarWhereInput)
+    OR?: Array<UserScalarWhereInput>;
 
-  @Field(() => StringFilter, { nullable: true })
-  id?: StringFilter;
+    @Field(() => [UserScalarWhereInput], {nullable:true})
+    @Type(() => UserScalarWhereInput)
+    NOT?: Array<UserScalarWhereInput>;
 
-  @Field(() => StringFilter, { nullable: true })
-  email?: StringFilter;
+    @Field(() => StringFilter, {nullable:true})
+    id?: StringFilter;
 
-  @Field(() => StringFilter, { nullable: true })
-  name?: StringFilter;
+    @Field(() => StringFilter, {nullable:true})
+    email?: StringFilter;
 
-  @Field(() => StringFilter, { nullable: true })
-  password?: StringFilter;
+    @Field(() => StringFilter, {nullable:true})
+    name?: StringFilter;
 
-  @Field(() => StringNullableFilter, { nullable: true })
-  bio?: StringNullableFilter;
+    @Field(() => StringFilter, {nullable:true})
+    password?: StringFilter;
 
-  @Field(() => StringNullableFilter, { nullable: true })
-  image?: StringNullableFilter;
+    @Field(() => StringNullableFilter, {nullable:true})
+    bio?: StringNullableFilter;
 
-  @Field(() => IntNullableFilter, { nullable: true })
-  countComments?: IntNullableFilter;
+    @Field(() => StringNullableFilter, {nullable:true})
+    image?: StringNullableFilter;
 
-  @Field(() => FloatNullableFilter, { nullable: true })
-  rating?: FloatNullableFilter;
+    @Field(() => IntNullableFilter, {nullable:true})
+    countComments?: IntNullableFilter;
 
-  @Field(() => DecimalNullableFilter, { nullable: true })
-  @Type(() => DecimalNullableFilter)
-  money?: DecimalNullableFilter;
+    @Field(() => FloatNullableFilter, {nullable:true})
+    rating?: FloatNullableFilter;
 
-  @Field(() => EnumRoleNullableFilter, { nullable: true })
-  role?: EnumRoleNullableFilter;
+    @Field(() => DecimalNullableFilter, {nullable:true})
+    @Type(() => DecimalNullableFilter)
+    money?: DecimalNullableFilter;
+
+    @Field(() => EnumRoleNullableFilter, {nullable:true})
+    role?: EnumRoleNullableFilter;
 }
diff --git a/@generated/user/user-sum-aggregate.input.ts b/@generated/user/user-sum-aggregate.input.ts
index e347d25c..d6d9ba60 100644
--- a/@generated/user/user-sum-aggregate.input.ts
+++ b/@generated/user/user-sum-aggregate.input.ts
@@ -3,12 +3,13 @@ import { InputType } from '@nestjs/graphql';
 
 @InputType()
 export class UserSumAggregateInput {
-  @Field(() => Boolean, { nullable: true })
-  countComments?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  rating?: true;
+    @Field(() => Boolean, {nullable:true})
+    countComments?: true;
 
-  @Field(() => Boolean, { nullable: true })
-  money?: true;
+    @Field(() => Boolean, {nullable:true})
+    rating?: true;
+
+    @Field(() => Boolean, {nullable:true})
+    money?: true;
 }
diff --git a/@generated/user/user-sum-aggregate.output.ts b/@generated/user/user-sum-aggregate.output.ts
index 98c6cd61..a42f0b6d 100644
--- a/@generated/user/user-sum-aggregate.output.ts
+++ b/@generated/user/user-sum-aggregate.output.ts
@@ -2,17 +2,18 @@ import { Field } from '@nestjs/graphql';
 import { ObjectType } from '@nestjs/graphql';
 import { Int } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 
 @ObjectType()
 export class UserSumAggregate {
-  @Field(() => Int, { nullable: true })
-  countComments?: number;
 
-  @Field(() => Float, { nullable: true })
-  rating?: number;
+    @Field(() => Int, {nullable:true})
+    countComments?: number;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  money?: Decimal;
+    @Field(() => Float, {nullable:true})
+    rating?: number;
+
+    @Field(() => GraphQLDecimal, {nullable:true})
+    money?: Decimal;
 }
diff --git a/@generated/user/user-sum-order-by-aggregate.input.ts b/@generated/user/user-sum-order-by-aggregate.input.ts
index cb7e5cb8..76d62a4c 100644
--- a/@generated/user/user-sum-order-by-aggregate.input.ts
+++ b/@generated/user/user-sum-order-by-aggregate.input.ts
@@ -4,12 +4,13 @@ import { SortOrder } from '../prisma/sort-order.enum';
 
 @InputType()
 export class UserSumOrderByAggregateInput {
-  @Field(() => SortOrder, { nullable: true })
-  countComments?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  rating?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    countComments?: keyof typeof SortOrder;
 
-  @Field(() => SortOrder, { nullable: true })
-  money?: keyof typeof SortOrder;
+    @Field(() => SortOrder, {nullable:true})
+    rating?: keyof typeof SortOrder;
+
+    @Field(() => SortOrder, {nullable:true})
+    money?: keyof typeof SortOrder;
 }
diff --git a/@generated/user/user-unchecked-create-nested-many-without-favorite-articles.input.ts b/@generated/user/user-unchecked-create-nested-many-without-favorite-articles.input.ts
index 0e03c698..700c7917 100644
--- a/@generated/user/user-unchecked-create-nested-many-without-favorite-articles.input.ts
+++ b/@generated/user/user-unchecked-create-nested-many-without-favorite-articles.input.ts
@@ -3,22 +3,21 @@ import { InputType } from '@nestjs/graphql';
 import { UserCreateWithoutFavoriteArticlesInput } from './user-create-without-favorite-articles.input';
 import { Type } from 'class-transformer';
 import { UserCreateOrConnectWithoutFavoriteArticlesInput } from './user-create-or-connect-without-favorite-articles.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 
 @InputType()
 export class UserUncheckedCreateNestedManyWithoutFavoriteArticlesInput {
-  @Field(() => [UserCreateWithoutFavoriteArticlesInput], { nullable: true })
-  @Type(() => UserCreateWithoutFavoriteArticlesInput)
-  create?: Array<UserCreateWithoutFavoriteArticlesInput>;
 
-  @Field(() => [UserCreateOrConnectWithoutFavoriteArticlesInput], { nullable: true })
-  @Type(() => UserCreateOrConnectWithoutFavoriteArticlesInput)
-  connectOrCreate?: Array<UserCreateOrConnectWithoutFavoriteArticlesInput>;
+    @Field(() => [UserCreateWithoutFavoriteArticlesInput], {nullable:true})
+    @Type(() => UserCreateWithoutFavoriteArticlesInput)
+    create?: Array<UserCreateWithoutFavoriteArticlesInput>;
 
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  connect?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
+    @Field(() => [UserCreateOrConnectWithoutFavoriteArticlesInput], {nullable:true})
+    @Type(() => UserCreateOrConnectWithoutFavoriteArticlesInput)
+    connectOrCreate?: Array<UserCreateOrConnectWithoutFavoriteArticlesInput>;
+
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
 }
diff --git a/@generated/user/user-unchecked-create-nested-many-without-followers.input.ts b/@generated/user/user-unchecked-create-nested-many-without-followers.input.ts
index 7521e226..bd88abf2 100644
--- a/@generated/user/user-unchecked-create-nested-many-without-followers.input.ts
+++ b/@generated/user/user-unchecked-create-nested-many-without-followers.input.ts
@@ -3,22 +3,21 @@ import { InputType } from '@nestjs/graphql';
 import { UserCreateWithoutFollowersInput } from './user-create-without-followers.input';
 import { Type } from 'class-transformer';
 import { UserCreateOrConnectWithoutFollowersInput } from './user-create-or-connect-without-followers.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 
 @InputType()
 export class UserUncheckedCreateNestedManyWithoutFollowersInput {
-  @Field(() => [UserCreateWithoutFollowersInput], { nullable: true })
-  @Type(() => UserCreateWithoutFollowersInput)
-  create?: Array<UserCreateWithoutFollowersInput>;
 
-  @Field(() => [UserCreateOrConnectWithoutFollowersInput], { nullable: true })
-  @Type(() => UserCreateOrConnectWithoutFollowersInput)
-  connectOrCreate?: Array<UserCreateOrConnectWithoutFollowersInput>;
+    @Field(() => [UserCreateWithoutFollowersInput], {nullable:true})
+    @Type(() => UserCreateWithoutFollowersInput)
+    create?: Array<UserCreateWithoutFollowersInput>;
 
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  connect?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
+    @Field(() => [UserCreateOrConnectWithoutFollowersInput], {nullable:true})
+    @Type(() => UserCreateOrConnectWithoutFollowersInput)
+    connectOrCreate?: Array<UserCreateOrConnectWithoutFollowersInput>;
+
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
 }
diff --git a/@generated/user/user-unchecked-create-nested-many-without-following.input.ts b/@generated/user/user-unchecked-create-nested-many-without-following.input.ts
index b64b8b24..25128c18 100644
--- a/@generated/user/user-unchecked-create-nested-many-without-following.input.ts
+++ b/@generated/user/user-unchecked-create-nested-many-without-following.input.ts
@@ -3,22 +3,21 @@ import { InputType } from '@nestjs/graphql';
 import { UserCreateWithoutFollowingInput } from './user-create-without-following.input';
 import { Type } from 'class-transformer';
 import { UserCreateOrConnectWithoutFollowingInput } from './user-create-or-connect-without-following.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 
 @InputType()
 export class UserUncheckedCreateNestedManyWithoutFollowingInput {
-  @Field(() => [UserCreateWithoutFollowingInput], { nullable: true })
-  @Type(() => UserCreateWithoutFollowingInput)
-  create?: Array<UserCreateWithoutFollowingInput>;
 
-  @Field(() => [UserCreateOrConnectWithoutFollowingInput], { nullable: true })
-  @Type(() => UserCreateOrConnectWithoutFollowingInput)
-  connectOrCreate?: Array<UserCreateOrConnectWithoutFollowingInput>;
+    @Field(() => [UserCreateWithoutFollowingInput], {nullable:true})
+    @Type(() => UserCreateWithoutFollowingInput)
+    create?: Array<UserCreateWithoutFollowingInput>;
 
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  connect?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
+    @Field(() => [UserCreateOrConnectWithoutFollowingInput], {nullable:true})
+    @Type(() => UserCreateOrConnectWithoutFollowingInput)
+    connectOrCreate?: Array<UserCreateOrConnectWithoutFollowingInput>;
+
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
 }
diff --git a/@generated/user/user-unchecked-create-without-articles.input.ts b/@generated/user/user-unchecked-create-without-articles.input.ts
index ccd6c0b3..b5ccbec6 100644
--- a/@generated/user/user-unchecked-create-without-articles.input.ts
+++ b/@generated/user/user-unchecked-create-without-articles.input.ts
@@ -4,7 +4,7 @@ import * as Scalars from 'graphql-scalars';
 import * as Validator from 'class-validator';
 import { Int } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -18,59 +18,58 @@ import { ProfileUncheckedCreateNestedOneWithoutUserInput } from '../profile/prof
 
 @InputType()
 export class UserUncheckedCreateWithoutArticlesInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => Scalars.GraphQLEmailAddress, { nullable: false })
-  email!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: false })
-  @Validator.MinLength(3)
-  @Validator.MaxLength(50)
-  name!: string;
+    @Field(() => Scalars.GraphQLEmailAddress, {nullable:false})
+    email!: string;
 
-  @Field(() => String, { nullable: false })
-  password!: string;
+    @Field(() => String, {nullable:false})
+    @Validator.MinLength(3)
+    @Validator.MaxLength(50)
+    name!: string;
 
-  @Field(() => String, { nullable: true })
-  bio?: string;
+    @Field(() => String, {nullable:false})
+    password!: string;
 
-  @Field(() => String, { nullable: true })
-  image?: string;
+    @Field(() => String, {nullable:true})
+    bio?: string;
 
-  @Field(() => Int, { nullable: true })
-  countComments?: number;
+    @Field(() => String, {nullable:true})
+    image?: string;
 
-  @Field(() => Float, { nullable: true })
-  rating?: number;
+    @Field(() => Int, {nullable:true})
+    countComments?: number;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  money?: Decimal;
+    @Field(() => Float, {nullable:true})
+    rating?: number;
 
-  @Field(() => Role, { nullable: true })
-  role?: keyof typeof Role;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    money?: Decimal;
 
-  @Field(() => UserUncheckedCreateNestedManyWithoutFollowersInput, { nullable: true })
-  @Type(() => UserUncheckedCreateNestedManyWithoutFollowersInput)
-  following?: UserUncheckedCreateNestedManyWithoutFollowersInput;
+    @Field(() => Role, {nullable:true})
+    role?: keyof typeof Role;
 
-  @Field(() => UserUncheckedCreateNestedManyWithoutFollowingInput, { nullable: true })
-  @Type(() => UserUncheckedCreateNestedManyWithoutFollowingInput)
-  followers?: UserUncheckedCreateNestedManyWithoutFollowingInput;
+    @Field(() => UserUncheckedCreateNestedManyWithoutFollowersInput, {nullable:true})
+    @Type(() => UserUncheckedCreateNestedManyWithoutFollowersInput)
+    following?: UserUncheckedCreateNestedManyWithoutFollowersInput;
 
-  @Field(() => ArticleUncheckedCreateNestedManyWithoutFavoritedByInput, {
-    nullable: true,
-  })
-  @Type(() => ArticleUncheckedCreateNestedManyWithoutFavoritedByInput)
-  favoriteArticles?: ArticleUncheckedCreateNestedManyWithoutFavoritedByInput;
+    @Field(() => UserUncheckedCreateNestedManyWithoutFollowingInput, {nullable:true})
+    @Type(() => UserUncheckedCreateNestedManyWithoutFollowingInput)
+    followers?: UserUncheckedCreateNestedManyWithoutFollowingInput;
 
-  @Field(() => CommentUncheckedCreateNestedManyWithoutAuthorInput, { nullable: true })
-  @Type(() => CommentUncheckedCreateNestedManyWithoutAuthorInput)
-  comments?: CommentUncheckedCreateNestedManyWithoutAuthorInput;
+    @Field(() => ArticleUncheckedCreateNestedManyWithoutFavoritedByInput, {nullable:true})
+    @Type(() => ArticleUncheckedCreateNestedManyWithoutFavoritedByInput)
+    favoriteArticles?: ArticleUncheckedCreateNestedManyWithoutFavoritedByInput;
 
-  @Field(() => ProfileUncheckedCreateNestedOneWithoutUserInput, { nullable: true })
-  @Type(() => ProfileUncheckedCreateNestedOneWithoutUserInput)
-  profile?: ProfileUncheckedCreateNestedOneWithoutUserInput;
+    @Field(() => CommentUncheckedCreateNestedManyWithoutAuthorInput, {nullable:true})
+    @Type(() => CommentUncheckedCreateNestedManyWithoutAuthorInput)
+    comments?: CommentUncheckedCreateNestedManyWithoutAuthorInput;
+
+    @Field(() => ProfileUncheckedCreateNestedOneWithoutUserInput, {nullable:true})
+    @Type(() => ProfileUncheckedCreateNestedOneWithoutUserInput)
+    profile?: ProfileUncheckedCreateNestedOneWithoutUserInput;
 }
diff --git a/@generated/user/user-unchecked-create-without-comments.input.ts b/@generated/user/user-unchecked-create-without-comments.input.ts
index 5c13067a..1dbfd033 100644
--- a/@generated/user/user-unchecked-create-without-comments.input.ts
+++ b/@generated/user/user-unchecked-create-without-comments.input.ts
@@ -4,7 +4,7 @@ import * as Scalars from 'graphql-scalars';
 import * as Validator from 'class-validator';
 import { Int } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -18,59 +18,58 @@ import { ProfileUncheckedCreateNestedOneWithoutUserInput } from '../profile/prof
 
 @InputType()
 export class UserUncheckedCreateWithoutCommentsInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => Scalars.GraphQLEmailAddress, { nullable: false })
-  email!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: false })
-  @Validator.MinLength(3)
-  @Validator.MaxLength(50)
-  name!: string;
+    @Field(() => Scalars.GraphQLEmailAddress, {nullable:false})
+    email!: string;
 
-  @Field(() => String, { nullable: false })
-  password!: string;
+    @Field(() => String, {nullable:false})
+    @Validator.MinLength(3)
+    @Validator.MaxLength(50)
+    name!: string;
 
-  @Field(() => String, { nullable: true })
-  bio?: string;
+    @Field(() => String, {nullable:false})
+    password!: string;
 
-  @Field(() => String, { nullable: true })
-  image?: string;
+    @Field(() => String, {nullable:true})
+    bio?: string;
 
-  @Field(() => Int, { nullable: true })
-  countComments?: number;
+    @Field(() => String, {nullable:true})
+    image?: string;
 
-  @Field(() => Float, { nullable: true })
-  rating?: number;
+    @Field(() => Int, {nullable:true})
+    countComments?: number;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  money?: Decimal;
+    @Field(() => Float, {nullable:true})
+    rating?: number;
 
-  @Field(() => Role, { nullable: true })
-  role?: keyof typeof Role;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    money?: Decimal;
 
-  @Field(() => UserUncheckedCreateNestedManyWithoutFollowersInput, { nullable: true })
-  @Type(() => UserUncheckedCreateNestedManyWithoutFollowersInput)
-  following?: UserUncheckedCreateNestedManyWithoutFollowersInput;
+    @Field(() => Role, {nullable:true})
+    role?: keyof typeof Role;
 
-  @Field(() => UserUncheckedCreateNestedManyWithoutFollowingInput, { nullable: true })
-  @Type(() => UserUncheckedCreateNestedManyWithoutFollowingInput)
-  followers?: UserUncheckedCreateNestedManyWithoutFollowingInput;
+    @Field(() => UserUncheckedCreateNestedManyWithoutFollowersInput, {nullable:true})
+    @Type(() => UserUncheckedCreateNestedManyWithoutFollowersInput)
+    following?: UserUncheckedCreateNestedManyWithoutFollowersInput;
 
-  @Field(() => ArticleUncheckedCreateNestedManyWithoutFavoritedByInput, {
-    nullable: true,
-  })
-  @Type(() => ArticleUncheckedCreateNestedManyWithoutFavoritedByInput)
-  favoriteArticles?: ArticleUncheckedCreateNestedManyWithoutFavoritedByInput;
+    @Field(() => UserUncheckedCreateNestedManyWithoutFollowingInput, {nullable:true})
+    @Type(() => UserUncheckedCreateNestedManyWithoutFollowingInput)
+    followers?: UserUncheckedCreateNestedManyWithoutFollowingInput;
 
-  @Field(() => ArticleUncheckedCreateNestedManyWithoutAuthorInput, { nullable: true })
-  @Type(() => ArticleUncheckedCreateNestedManyWithoutAuthorInput)
-  articles?: ArticleUncheckedCreateNestedManyWithoutAuthorInput;
+    @Field(() => ArticleUncheckedCreateNestedManyWithoutFavoritedByInput, {nullable:true})
+    @Type(() => ArticleUncheckedCreateNestedManyWithoutFavoritedByInput)
+    favoriteArticles?: ArticleUncheckedCreateNestedManyWithoutFavoritedByInput;
 
-  @Field(() => ProfileUncheckedCreateNestedOneWithoutUserInput, { nullable: true })
-  @Type(() => ProfileUncheckedCreateNestedOneWithoutUserInput)
-  profile?: ProfileUncheckedCreateNestedOneWithoutUserInput;
+    @Field(() => ArticleUncheckedCreateNestedManyWithoutAuthorInput, {nullable:true})
+    @Type(() => ArticleUncheckedCreateNestedManyWithoutAuthorInput)
+    articles?: ArticleUncheckedCreateNestedManyWithoutAuthorInput;
+
+    @Field(() => ProfileUncheckedCreateNestedOneWithoutUserInput, {nullable:true})
+    @Type(() => ProfileUncheckedCreateNestedOneWithoutUserInput)
+    profile?: ProfileUncheckedCreateNestedOneWithoutUserInput;
 }
diff --git a/@generated/user/user-unchecked-create-without-favorite-articles.input.ts b/@generated/user/user-unchecked-create-without-favorite-articles.input.ts
index 2ff85d0a..64adac3e 100644
--- a/@generated/user/user-unchecked-create-without-favorite-articles.input.ts
+++ b/@generated/user/user-unchecked-create-without-favorite-articles.input.ts
@@ -4,7 +4,7 @@ import * as Scalars from 'graphql-scalars';
 import * as Validator from 'class-validator';
 import { Int } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -18,57 +18,58 @@ import { ProfileUncheckedCreateNestedOneWithoutUserInput } from '../profile/prof
 
 @InputType()
 export class UserUncheckedCreateWithoutFavoriteArticlesInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => Scalars.GraphQLEmailAddress, { nullable: false })
-  email!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: false })
-  @Validator.MinLength(3)
-  @Validator.MaxLength(50)
-  name!: string;
+    @Field(() => Scalars.GraphQLEmailAddress, {nullable:false})
+    email!: string;
 
-  @Field(() => String, { nullable: false })
-  password!: string;
+    @Field(() => String, {nullable:false})
+    @Validator.MinLength(3)
+    @Validator.MaxLength(50)
+    name!: string;
 
-  @Field(() => String, { nullable: true })
-  bio?: string;
+    @Field(() => String, {nullable:false})
+    password!: string;
 
-  @Field(() => String, { nullable: true })
-  image?: string;
+    @Field(() => String, {nullable:true})
+    bio?: string;
 
-  @Field(() => Int, { nullable: true })
-  countComments?: number;
+    @Field(() => String, {nullable:true})
+    image?: string;
 
-  @Field(() => Float, { nullable: true })
-  rating?: number;
+    @Field(() => Int, {nullable:true})
+    countComments?: number;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  money?: Decimal;
+    @Field(() => Float, {nullable:true})
+    rating?: number;
 
-  @Field(() => Role, { nullable: true })
-  role?: keyof typeof Role;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    money?: Decimal;
 
-  @Field(() => UserUncheckedCreateNestedManyWithoutFollowersInput, { nullable: true })
-  @Type(() => UserUncheckedCreateNestedManyWithoutFollowersInput)
-  following?: UserUncheckedCreateNestedManyWithoutFollowersInput;
+    @Field(() => Role, {nullable:true})
+    role?: keyof typeof Role;
 
-  @Field(() => UserUncheckedCreateNestedManyWithoutFollowingInput, { nullable: true })
-  @Type(() => UserUncheckedCreateNestedManyWithoutFollowingInput)
-  followers?: UserUncheckedCreateNestedManyWithoutFollowingInput;
+    @Field(() => UserUncheckedCreateNestedManyWithoutFollowersInput, {nullable:true})
+    @Type(() => UserUncheckedCreateNestedManyWithoutFollowersInput)
+    following?: UserUncheckedCreateNestedManyWithoutFollowersInput;
 
-  @Field(() => ArticleUncheckedCreateNestedManyWithoutAuthorInput, { nullable: true })
-  @Type(() => ArticleUncheckedCreateNestedManyWithoutAuthorInput)
-  articles?: ArticleUncheckedCreateNestedManyWithoutAuthorInput;
+    @Field(() => UserUncheckedCreateNestedManyWithoutFollowingInput, {nullable:true})
+    @Type(() => UserUncheckedCreateNestedManyWithoutFollowingInput)
+    followers?: UserUncheckedCreateNestedManyWithoutFollowingInput;
 
-  @Field(() => CommentUncheckedCreateNestedManyWithoutAuthorInput, { nullable: true })
-  @Type(() => CommentUncheckedCreateNestedManyWithoutAuthorInput)
-  comments?: CommentUncheckedCreateNestedManyWithoutAuthorInput;
+    @Field(() => ArticleUncheckedCreateNestedManyWithoutAuthorInput, {nullable:true})
+    @Type(() => ArticleUncheckedCreateNestedManyWithoutAuthorInput)
+    articles?: ArticleUncheckedCreateNestedManyWithoutAuthorInput;
 
-  @Field(() => ProfileUncheckedCreateNestedOneWithoutUserInput, { nullable: true })
-  @Type(() => ProfileUncheckedCreateNestedOneWithoutUserInput)
-  profile?: ProfileUncheckedCreateNestedOneWithoutUserInput;
+    @Field(() => CommentUncheckedCreateNestedManyWithoutAuthorInput, {nullable:true})
+    @Type(() => CommentUncheckedCreateNestedManyWithoutAuthorInput)
+    comments?: CommentUncheckedCreateNestedManyWithoutAuthorInput;
+
+    @Field(() => ProfileUncheckedCreateNestedOneWithoutUserInput, {nullable:true})
+    @Type(() => ProfileUncheckedCreateNestedOneWithoutUserInput)
+    profile?: ProfileUncheckedCreateNestedOneWithoutUserInput;
 }
diff --git a/@generated/user/user-unchecked-create-without-followers.input.ts b/@generated/user/user-unchecked-create-without-followers.input.ts
index 0a2c1650..83919f31 100644
--- a/@generated/user/user-unchecked-create-without-followers.input.ts
+++ b/@generated/user/user-unchecked-create-without-followers.input.ts
@@ -4,7 +4,7 @@ import * as Scalars from 'graphql-scalars';
 import * as Validator from 'class-validator';
 import { Int } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -18,59 +18,58 @@ import { ProfileUncheckedCreateNestedOneWithoutUserInput } from '../profile/prof
 
 @InputType()
 export class UserUncheckedCreateWithoutFollowersInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => Scalars.GraphQLEmailAddress, { nullable: false })
-  email!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: false })
-  @Validator.MinLength(3)
-  @Validator.MaxLength(50)
-  name!: string;
+    @Field(() => Scalars.GraphQLEmailAddress, {nullable:false})
+    email!: string;
 
-  @Field(() => String, { nullable: false })
-  password!: string;
+    @Field(() => String, {nullable:false})
+    @Validator.MinLength(3)
+    @Validator.MaxLength(50)
+    name!: string;
 
-  @Field(() => String, { nullable: true })
-  bio?: string;
+    @Field(() => String, {nullable:false})
+    password!: string;
 
-  @Field(() => String, { nullable: true })
-  image?: string;
+    @Field(() => String, {nullable:true})
+    bio?: string;
 
-  @Field(() => Int, { nullable: true })
-  countComments?: number;
+    @Field(() => String, {nullable:true})
+    image?: string;
 
-  @Field(() => Float, { nullable: true })
-  rating?: number;
+    @Field(() => Int, {nullable:true})
+    countComments?: number;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  money?: Decimal;
+    @Field(() => Float, {nullable:true})
+    rating?: number;
 
-  @Field(() => Role, { nullable: true })
-  role?: keyof typeof Role;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    money?: Decimal;
 
-  @Field(() => UserUncheckedCreateNestedManyWithoutFollowersInput, { nullable: true })
-  @Type(() => UserUncheckedCreateNestedManyWithoutFollowersInput)
-  following?: UserUncheckedCreateNestedManyWithoutFollowersInput;
+    @Field(() => Role, {nullable:true})
+    role?: keyof typeof Role;
 
-  @Field(() => ArticleUncheckedCreateNestedManyWithoutFavoritedByInput, {
-    nullable: true,
-  })
-  @Type(() => ArticleUncheckedCreateNestedManyWithoutFavoritedByInput)
-  favoriteArticles?: ArticleUncheckedCreateNestedManyWithoutFavoritedByInput;
+    @Field(() => UserUncheckedCreateNestedManyWithoutFollowersInput, {nullable:true})
+    @Type(() => UserUncheckedCreateNestedManyWithoutFollowersInput)
+    following?: UserUncheckedCreateNestedManyWithoutFollowersInput;
 
-  @Field(() => ArticleUncheckedCreateNestedManyWithoutAuthorInput, { nullable: true })
-  @Type(() => ArticleUncheckedCreateNestedManyWithoutAuthorInput)
-  articles?: ArticleUncheckedCreateNestedManyWithoutAuthorInput;
+    @Field(() => ArticleUncheckedCreateNestedManyWithoutFavoritedByInput, {nullable:true})
+    @Type(() => ArticleUncheckedCreateNestedManyWithoutFavoritedByInput)
+    favoriteArticles?: ArticleUncheckedCreateNestedManyWithoutFavoritedByInput;
 
-  @Field(() => CommentUncheckedCreateNestedManyWithoutAuthorInput, { nullable: true })
-  @Type(() => CommentUncheckedCreateNestedManyWithoutAuthorInput)
-  comments?: CommentUncheckedCreateNestedManyWithoutAuthorInput;
+    @Field(() => ArticleUncheckedCreateNestedManyWithoutAuthorInput, {nullable:true})
+    @Type(() => ArticleUncheckedCreateNestedManyWithoutAuthorInput)
+    articles?: ArticleUncheckedCreateNestedManyWithoutAuthorInput;
 
-  @Field(() => ProfileUncheckedCreateNestedOneWithoutUserInput, { nullable: true })
-  @Type(() => ProfileUncheckedCreateNestedOneWithoutUserInput)
-  profile?: ProfileUncheckedCreateNestedOneWithoutUserInput;
+    @Field(() => CommentUncheckedCreateNestedManyWithoutAuthorInput, {nullable:true})
+    @Type(() => CommentUncheckedCreateNestedManyWithoutAuthorInput)
+    comments?: CommentUncheckedCreateNestedManyWithoutAuthorInput;
+
+    @Field(() => ProfileUncheckedCreateNestedOneWithoutUserInput, {nullable:true})
+    @Type(() => ProfileUncheckedCreateNestedOneWithoutUserInput)
+    profile?: ProfileUncheckedCreateNestedOneWithoutUserInput;
 }
diff --git a/@generated/user/user-unchecked-create-without-following.input.ts b/@generated/user/user-unchecked-create-without-following.input.ts
index 2341cb87..e6e03ba7 100644
--- a/@generated/user/user-unchecked-create-without-following.input.ts
+++ b/@generated/user/user-unchecked-create-without-following.input.ts
@@ -4,7 +4,7 @@ import * as Scalars from 'graphql-scalars';
 import * as Validator from 'class-validator';
 import { Int } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -18,59 +18,58 @@ import { ProfileUncheckedCreateNestedOneWithoutUserInput } from '../profile/prof
 
 @InputType()
 export class UserUncheckedCreateWithoutFollowingInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => Scalars.GraphQLEmailAddress, { nullable: false })
-  email!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: false })
-  @Validator.MinLength(3)
-  @Validator.MaxLength(50)
-  name!: string;
+    @Field(() => Scalars.GraphQLEmailAddress, {nullable:false})
+    email!: string;
 
-  @Field(() => String, { nullable: false })
-  password!: string;
+    @Field(() => String, {nullable:false})
+    @Validator.MinLength(3)
+    @Validator.MaxLength(50)
+    name!: string;
 
-  @Field(() => String, { nullable: true })
-  bio?: string;
+    @Field(() => String, {nullable:false})
+    password!: string;
 
-  @Field(() => String, { nullable: true })
-  image?: string;
+    @Field(() => String, {nullable:true})
+    bio?: string;
 
-  @Field(() => Int, { nullable: true })
-  countComments?: number;
+    @Field(() => String, {nullable:true})
+    image?: string;
 
-  @Field(() => Float, { nullable: true })
-  rating?: number;
+    @Field(() => Int, {nullable:true})
+    countComments?: number;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  money?: Decimal;
+    @Field(() => Float, {nullable:true})
+    rating?: number;
 
-  @Field(() => Role, { nullable: true })
-  role?: keyof typeof Role;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    money?: Decimal;
 
-  @Field(() => UserUncheckedCreateNestedManyWithoutFollowingInput, { nullable: true })
-  @Type(() => UserUncheckedCreateNestedManyWithoutFollowingInput)
-  followers?: UserUncheckedCreateNestedManyWithoutFollowingInput;
+    @Field(() => Role, {nullable:true})
+    role?: keyof typeof Role;
 
-  @Field(() => ArticleUncheckedCreateNestedManyWithoutFavoritedByInput, {
-    nullable: true,
-  })
-  @Type(() => ArticleUncheckedCreateNestedManyWithoutFavoritedByInput)
-  favoriteArticles?: ArticleUncheckedCreateNestedManyWithoutFavoritedByInput;
+    @Field(() => UserUncheckedCreateNestedManyWithoutFollowingInput, {nullable:true})
+    @Type(() => UserUncheckedCreateNestedManyWithoutFollowingInput)
+    followers?: UserUncheckedCreateNestedManyWithoutFollowingInput;
 
-  @Field(() => ArticleUncheckedCreateNestedManyWithoutAuthorInput, { nullable: true })
-  @Type(() => ArticleUncheckedCreateNestedManyWithoutAuthorInput)
-  articles?: ArticleUncheckedCreateNestedManyWithoutAuthorInput;
+    @Field(() => ArticleUncheckedCreateNestedManyWithoutFavoritedByInput, {nullable:true})
+    @Type(() => ArticleUncheckedCreateNestedManyWithoutFavoritedByInput)
+    favoriteArticles?: ArticleUncheckedCreateNestedManyWithoutFavoritedByInput;
 
-  @Field(() => CommentUncheckedCreateNestedManyWithoutAuthorInput, { nullable: true })
-  @Type(() => CommentUncheckedCreateNestedManyWithoutAuthorInput)
-  comments?: CommentUncheckedCreateNestedManyWithoutAuthorInput;
+    @Field(() => ArticleUncheckedCreateNestedManyWithoutAuthorInput, {nullable:true})
+    @Type(() => ArticleUncheckedCreateNestedManyWithoutAuthorInput)
+    articles?: ArticleUncheckedCreateNestedManyWithoutAuthorInput;
 
-  @Field(() => ProfileUncheckedCreateNestedOneWithoutUserInput, { nullable: true })
-  @Type(() => ProfileUncheckedCreateNestedOneWithoutUserInput)
-  profile?: ProfileUncheckedCreateNestedOneWithoutUserInput;
+    @Field(() => CommentUncheckedCreateNestedManyWithoutAuthorInput, {nullable:true})
+    @Type(() => CommentUncheckedCreateNestedManyWithoutAuthorInput)
+    comments?: CommentUncheckedCreateNestedManyWithoutAuthorInput;
+
+    @Field(() => ProfileUncheckedCreateNestedOneWithoutUserInput, {nullable:true})
+    @Type(() => ProfileUncheckedCreateNestedOneWithoutUserInput)
+    profile?: ProfileUncheckedCreateNestedOneWithoutUserInput;
 }
diff --git a/@generated/user/user-unchecked-create-without-profile.input.ts b/@generated/user/user-unchecked-create-without-profile.input.ts
index 60cde512..1e90ba5f 100644
--- a/@generated/user/user-unchecked-create-without-profile.input.ts
+++ b/@generated/user/user-unchecked-create-without-profile.input.ts
@@ -4,7 +4,7 @@ import * as Scalars from 'graphql-scalars';
 import * as Validator from 'class-validator';
 import { Int } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -18,59 +18,58 @@ import { CommentUncheckedCreateNestedManyWithoutAuthorInput } from '../comment/c
 
 @InputType()
 export class UserUncheckedCreateWithoutProfileInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => Scalars.GraphQLEmailAddress, { nullable: false })
-  email!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: false })
-  @Validator.MinLength(3)
-  @Validator.MaxLength(50)
-  name!: string;
+    @Field(() => Scalars.GraphQLEmailAddress, {nullable:false})
+    email!: string;
 
-  @Field(() => String, { nullable: false })
-  password!: string;
+    @Field(() => String, {nullable:false})
+    @Validator.MinLength(3)
+    @Validator.MaxLength(50)
+    name!: string;
 
-  @Field(() => String, { nullable: true })
-  bio?: string;
+    @Field(() => String, {nullable:false})
+    password!: string;
 
-  @Field(() => String, { nullable: true })
-  image?: string;
+    @Field(() => String, {nullable:true})
+    bio?: string;
 
-  @Field(() => Int, { nullable: true })
-  countComments?: number;
+    @Field(() => String, {nullable:true})
+    image?: string;
 
-  @Field(() => Float, { nullable: true })
-  rating?: number;
+    @Field(() => Int, {nullable:true})
+    countComments?: number;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  money?: Decimal;
+    @Field(() => Float, {nullable:true})
+    rating?: number;
 
-  @Field(() => Role, { nullable: true })
-  role?: keyof typeof Role;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    money?: Decimal;
 
-  @Field(() => UserUncheckedCreateNestedManyWithoutFollowersInput, { nullable: true })
-  @Type(() => UserUncheckedCreateNestedManyWithoutFollowersInput)
-  following?: UserUncheckedCreateNestedManyWithoutFollowersInput;
+    @Field(() => Role, {nullable:true})
+    role?: keyof typeof Role;
 
-  @Field(() => UserUncheckedCreateNestedManyWithoutFollowingInput, { nullable: true })
-  @Type(() => UserUncheckedCreateNestedManyWithoutFollowingInput)
-  followers?: UserUncheckedCreateNestedManyWithoutFollowingInput;
+    @Field(() => UserUncheckedCreateNestedManyWithoutFollowersInput, {nullable:true})
+    @Type(() => UserUncheckedCreateNestedManyWithoutFollowersInput)
+    following?: UserUncheckedCreateNestedManyWithoutFollowersInput;
 
-  @Field(() => ArticleUncheckedCreateNestedManyWithoutFavoritedByInput, {
-    nullable: true,
-  })
-  @Type(() => ArticleUncheckedCreateNestedManyWithoutFavoritedByInput)
-  favoriteArticles?: ArticleUncheckedCreateNestedManyWithoutFavoritedByInput;
+    @Field(() => UserUncheckedCreateNestedManyWithoutFollowingInput, {nullable:true})
+    @Type(() => UserUncheckedCreateNestedManyWithoutFollowingInput)
+    followers?: UserUncheckedCreateNestedManyWithoutFollowingInput;
 
-  @Field(() => ArticleUncheckedCreateNestedManyWithoutAuthorInput, { nullable: true })
-  @Type(() => ArticleUncheckedCreateNestedManyWithoutAuthorInput)
-  articles?: ArticleUncheckedCreateNestedManyWithoutAuthorInput;
+    @Field(() => ArticleUncheckedCreateNestedManyWithoutFavoritedByInput, {nullable:true})
+    @Type(() => ArticleUncheckedCreateNestedManyWithoutFavoritedByInput)
+    favoriteArticles?: ArticleUncheckedCreateNestedManyWithoutFavoritedByInput;
 
-  @Field(() => CommentUncheckedCreateNestedManyWithoutAuthorInput, { nullable: true })
-  @Type(() => CommentUncheckedCreateNestedManyWithoutAuthorInput)
-  comments?: CommentUncheckedCreateNestedManyWithoutAuthorInput;
+    @Field(() => ArticleUncheckedCreateNestedManyWithoutAuthorInput, {nullable:true})
+    @Type(() => ArticleUncheckedCreateNestedManyWithoutAuthorInput)
+    articles?: ArticleUncheckedCreateNestedManyWithoutAuthorInput;
+
+    @Field(() => CommentUncheckedCreateNestedManyWithoutAuthorInput, {nullable:true})
+    @Type(() => CommentUncheckedCreateNestedManyWithoutAuthorInput)
+    comments?: CommentUncheckedCreateNestedManyWithoutAuthorInput;
 }
diff --git a/@generated/user/user-unchecked-create.input.ts b/@generated/user/user-unchecked-create.input.ts
index cab71b58..cca4d016 100644
--- a/@generated/user/user-unchecked-create.input.ts
+++ b/@generated/user/user-unchecked-create.input.ts
@@ -4,7 +4,7 @@ import * as Scalars from 'graphql-scalars';
 import * as Validator from 'class-validator';
 import { Int } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
 import { transformToDecimal } from 'prisma-graphql-type-decimal';
 import { Transform } from 'class-transformer';
@@ -19,63 +19,62 @@ import { ProfileUncheckedCreateNestedOneWithoutUserInput } from '../profile/prof
 
 @InputType()
 export class UserUncheckedCreateInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => Scalars.GraphQLEmailAddress, { nullable: false })
-  email!: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: false })
-  @Validator.MinLength(3)
-  @Validator.MaxLength(50)
-  name!: string;
+    @Field(() => Scalars.GraphQLEmailAddress, {nullable:false})
+    email!: string;
 
-  @Field(() => String, { nullable: false })
-  password!: string;
+    @Field(() => String, {nullable:false})
+    @Validator.MinLength(3)
+    @Validator.MaxLength(50)
+    name!: string;
 
-  @Field(() => String, { nullable: true })
-  bio?: string;
+    @Field(() => String, {nullable:false})
+    password!: string;
 
-  @Field(() => String, { nullable: true })
-  image?: string;
+    @Field(() => String, {nullable:true})
+    bio?: string;
 
-  @Field(() => Int, { nullable: true })
-  countComments?: number;
+    @Field(() => String, {nullable:true})
+    image?: string;
 
-  @Field(() => Float, { nullable: true })
-  rating?: number;
+    @Field(() => Int, {nullable:true})
+    countComments?: number;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  @Type(() => Object)
-  @Transform(transformToDecimal)
-  money?: Decimal;
+    @Field(() => Float, {nullable:true})
+    rating?: number;
 
-  @Field(() => Role, { nullable: true })
-  role?: keyof typeof Role;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    @Type(() => Object)
+    @Transform(transformToDecimal)
+    money?: Decimal;
 
-  @Field(() => UserUncheckedCreateNestedManyWithoutFollowersInput, { nullable: true })
-  @Type(() => UserUncheckedCreateNestedManyWithoutFollowersInput)
-  following?: UserUncheckedCreateNestedManyWithoutFollowersInput;
+    @Field(() => Role, {nullable:true})
+    role?: keyof typeof Role;
 
-  @Field(() => UserUncheckedCreateNestedManyWithoutFollowingInput, { nullable: true })
-  @Type(() => UserUncheckedCreateNestedManyWithoutFollowingInput)
-  followers?: UserUncheckedCreateNestedManyWithoutFollowingInput;
+    @Field(() => UserUncheckedCreateNestedManyWithoutFollowersInput, {nullable:true})
+    @Type(() => UserUncheckedCreateNestedManyWithoutFollowersInput)
+    following?: UserUncheckedCreateNestedManyWithoutFollowersInput;
 
-  @Field(() => ArticleUncheckedCreateNestedManyWithoutFavoritedByInput, {
-    nullable: true,
-  })
-  @Type(() => ArticleUncheckedCreateNestedManyWithoutFavoritedByInput)
-  favoriteArticles?: ArticleUncheckedCreateNestedManyWithoutFavoritedByInput;
+    @Field(() => UserUncheckedCreateNestedManyWithoutFollowingInput, {nullable:true})
+    @Type(() => UserUncheckedCreateNestedManyWithoutFollowingInput)
+    followers?: UserUncheckedCreateNestedManyWithoutFollowingInput;
 
-  @Field(() => ArticleUncheckedCreateNestedManyWithoutAuthorInput, { nullable: true })
-  @Type(() => ArticleUncheckedCreateNestedManyWithoutAuthorInput)
-  articles?: ArticleUncheckedCreateNestedManyWithoutAuthorInput;
+    @Field(() => ArticleUncheckedCreateNestedManyWithoutFavoritedByInput, {nullable:true})
+    @Type(() => ArticleUncheckedCreateNestedManyWithoutFavoritedByInput)
+    favoriteArticles?: ArticleUncheckedCreateNestedManyWithoutFavoritedByInput;
 
-  @Field(() => CommentUncheckedCreateNestedManyWithoutAuthorInput, { nullable: true })
-  @Type(() => CommentUncheckedCreateNestedManyWithoutAuthorInput)
-  comments?: CommentUncheckedCreateNestedManyWithoutAuthorInput;
+    @Field(() => ArticleUncheckedCreateNestedManyWithoutAuthorInput, {nullable:true})
+    @Type(() => ArticleUncheckedCreateNestedManyWithoutAuthorInput)
+    articles?: ArticleUncheckedCreateNestedManyWithoutAuthorInput;
 
-  @Field(() => ProfileUncheckedCreateNestedOneWithoutUserInput, { nullable: true })
-  @Type(() => ProfileUncheckedCreateNestedOneWithoutUserInput)
-  profile?: ProfileUncheckedCreateNestedOneWithoutUserInput;
+    @Field(() => CommentUncheckedCreateNestedManyWithoutAuthorInput, {nullable:true})
+    @Type(() => CommentUncheckedCreateNestedManyWithoutAuthorInput)
+    comments?: CommentUncheckedCreateNestedManyWithoutAuthorInput;
+
+    @Field(() => ProfileUncheckedCreateNestedOneWithoutUserInput, {nullable:true})
+    @Type(() => ProfileUncheckedCreateNestedOneWithoutUserInput)
+    profile?: ProfileUncheckedCreateNestedOneWithoutUserInput;
 }
diff --git a/@generated/user/user-unchecked-update-many-without-favorite-articles-nested.input.ts b/@generated/user/user-unchecked-update-many-without-favorite-articles-nested.input.ts
index cd229ab3..a29d9ef3 100644
--- a/@generated/user/user-unchecked-update-many-without-favorite-articles-nested.input.ts
+++ b/@generated/user/user-unchecked-update-many-without-favorite-articles-nested.input.ts
@@ -4,7 +4,7 @@ import { UserCreateWithoutFavoriteArticlesInput } from './user-create-without-fa
 import { Type } from 'class-transformer';
 import { UserCreateOrConnectWithoutFavoriteArticlesInput } from './user-create-or-connect-without-favorite-articles.input';
 import { UserUpsertWithWhereUniqueWithoutFavoriteArticlesInput } from './user-upsert-with-where-unique-without-favorite-articles.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 import { UserUpdateWithWhereUniqueWithoutFavoriteArticlesInput } from './user-update-with-where-unique-without-favorite-articles.input';
 import { UserUpdateManyWithWhereWithoutFavoriteArticlesInput } from './user-update-many-with-where-without-favorite-articles.input';
@@ -12,57 +12,44 @@ import { UserScalarWhereInput } from './user-scalar-where.input';
 
 @InputType()
 export class UserUncheckedUpdateManyWithoutFavoriteArticlesNestedInput {
-  @Field(() => [UserCreateWithoutFavoriteArticlesInput], { nullable: true })
-  @Type(() => UserCreateWithoutFavoriteArticlesInput)
-  create?: Array<UserCreateWithoutFavoriteArticlesInput>;
 
-  @Field(() => [UserCreateOrConnectWithoutFavoriteArticlesInput], { nullable: true })
-  @Type(() => UserCreateOrConnectWithoutFavoriteArticlesInput)
-  connectOrCreate?: Array<UserCreateOrConnectWithoutFavoriteArticlesInput>;
+    @Field(() => [UserCreateWithoutFavoriteArticlesInput], {nullable:true})
+    @Type(() => UserCreateWithoutFavoriteArticlesInput)
+    create?: Array<UserCreateWithoutFavoriteArticlesInput>;
 
-  @Field(() => [UserUpsertWithWhereUniqueWithoutFavoriteArticlesInput], {
-    nullable: true,
-  })
-  @Type(() => UserUpsertWithWhereUniqueWithoutFavoriteArticlesInput)
-  upsert?: Array<UserUpsertWithWhereUniqueWithoutFavoriteArticlesInput>;
+    @Field(() => [UserCreateOrConnectWithoutFavoriteArticlesInput], {nullable:true})
+    @Type(() => UserCreateOrConnectWithoutFavoriteArticlesInput)
+    connectOrCreate?: Array<UserCreateOrConnectWithoutFavoriteArticlesInput>;
 
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  set?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
+    @Field(() => [UserUpsertWithWhereUniqueWithoutFavoriteArticlesInput], {nullable:true})
+    @Type(() => UserUpsertWithWhereUniqueWithoutFavoriteArticlesInput)
+    upsert?: Array<UserUpsertWithWhereUniqueWithoutFavoriteArticlesInput>;
 
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  disconnect?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    set?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
 
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  delete?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    disconnect?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
 
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  connect?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    delete?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
 
-  @Field(() => [UserUpdateWithWhereUniqueWithoutFavoriteArticlesInput], {
-    nullable: true,
-  })
-  @Type(() => UserUpdateWithWhereUniqueWithoutFavoriteArticlesInput)
-  update?: Array<UserUpdateWithWhereUniqueWithoutFavoriteArticlesInput>;
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
 
-  @Field(() => [UserUpdateManyWithWhereWithoutFavoriteArticlesInput], {
-    nullable: true,
-  })
-  @Type(() => UserUpdateManyWithWhereWithoutFavoriteArticlesInput)
-  updateMany?: Array<UserUpdateManyWithWhereWithoutFavoriteArticlesInput>;
+    @Field(() => [UserUpdateWithWhereUniqueWithoutFavoriteArticlesInput], {nullable:true})
+    @Type(() => UserUpdateWithWhereUniqueWithoutFavoriteArticlesInput)
+    update?: Array<UserUpdateWithWhereUniqueWithoutFavoriteArticlesInput>;
 
-  @Field(() => [UserScalarWhereInput], { nullable: true })
-  @Type(() => UserScalarWhereInput)
-  deleteMany?: Array<UserScalarWhereInput>;
+    @Field(() => [UserUpdateManyWithWhereWithoutFavoriteArticlesInput], {nullable:true})
+    @Type(() => UserUpdateManyWithWhereWithoutFavoriteArticlesInput)
+    updateMany?: Array<UserUpdateManyWithWhereWithoutFavoriteArticlesInput>;
+
+    @Field(() => [UserScalarWhereInput], {nullable:true})
+    @Type(() => UserScalarWhereInput)
+    deleteMany?: Array<UserScalarWhereInput>;
 }
diff --git a/@generated/user/user-unchecked-update-many-without-favorite-articles.input.ts b/@generated/user/user-unchecked-update-many-without-favorite-articles.input.ts
index c7349de5..ee61743c 100644
--- a/@generated/user/user-unchecked-update-many-without-favorite-articles.input.ts
+++ b/@generated/user/user-unchecked-update-many-without-favorite-articles.input.ts
@@ -10,34 +10,35 @@ import { NullableEnumRoleFieldUpdateOperationsInput } from '../prisma/nullable-e
 
 @InputType()
 export class UserUncheckedUpdateManyWithoutFavoriteArticlesInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  email?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  name?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    email?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  password?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    name?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  bio?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    password?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  image?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    bio?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableIntFieldUpdateOperationsInput, { nullable: true })
-  countComments?: NullableIntFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    image?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableFloatFieldUpdateOperationsInput, { nullable: true })
-  rating?: NullableFloatFieldUpdateOperationsInput;
+    @Field(() => NullableIntFieldUpdateOperationsInput, {nullable:true})
+    countComments?: NullableIntFieldUpdateOperationsInput;
 
-  @Field(() => NullableDecimalFieldUpdateOperationsInput, { nullable: true })
-  @Type(() => NullableDecimalFieldUpdateOperationsInput)
-  money?: NullableDecimalFieldUpdateOperationsInput;
+    @Field(() => NullableFloatFieldUpdateOperationsInput, {nullable:true})
+    rating?: NullableFloatFieldUpdateOperationsInput;
 
-  @Field(() => NullableEnumRoleFieldUpdateOperationsInput, { nullable: true })
-  role?: NullableEnumRoleFieldUpdateOperationsInput;
+    @Field(() => NullableDecimalFieldUpdateOperationsInput, {nullable:true})
+    @Type(() => NullableDecimalFieldUpdateOperationsInput)
+    money?: NullableDecimalFieldUpdateOperationsInput;
+
+    @Field(() => NullableEnumRoleFieldUpdateOperationsInput, {nullable:true})
+    role?: NullableEnumRoleFieldUpdateOperationsInput;
 }
diff --git a/@generated/user/user-unchecked-update-many-without-followers-nested.input.ts b/@generated/user/user-unchecked-update-many-without-followers-nested.input.ts
index af0ad472..df7178be 100644
--- a/@generated/user/user-unchecked-update-many-without-followers-nested.input.ts
+++ b/@generated/user/user-unchecked-update-many-without-followers-nested.input.ts
@@ -4,7 +4,7 @@ import { UserCreateWithoutFollowersInput } from './user-create-without-followers
 import { Type } from 'class-transformer';
 import { UserCreateOrConnectWithoutFollowersInput } from './user-create-or-connect-without-followers.input';
 import { UserUpsertWithWhereUniqueWithoutFollowersInput } from './user-upsert-with-where-unique-without-followers.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 import { UserUpdateWithWhereUniqueWithoutFollowersInput } from './user-update-with-where-unique-without-followers.input';
 import { UserUpdateManyWithWhereWithoutFollowersInput } from './user-update-many-with-where-without-followers.input';
@@ -12,51 +12,44 @@ import { UserScalarWhereInput } from './user-scalar-where.input';
 
 @InputType()
 export class UserUncheckedUpdateManyWithoutFollowersNestedInput {
-  @Field(() => [UserCreateWithoutFollowersInput], { nullable: true })
-  @Type(() => UserCreateWithoutFollowersInput)
-  create?: Array<UserCreateWithoutFollowersInput>;
-
-  @Field(() => [UserCreateOrConnectWithoutFollowersInput], { nullable: true })
-  @Type(() => UserCreateOrConnectWithoutFollowersInput)
-  connectOrCreate?: Array<UserCreateOrConnectWithoutFollowersInput>;
-
-  @Field(() => [UserUpsertWithWhereUniqueWithoutFollowersInput], { nullable: true })
-  @Type(() => UserUpsertWithWhereUniqueWithoutFollowersInput)
-  upsert?: Array<UserUpsertWithWhereUniqueWithoutFollowersInput>;
-
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  set?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
-
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  disconnect?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
-
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  delete?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
-
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  connect?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
-
-  @Field(() => [UserUpdateWithWhereUniqueWithoutFollowersInput], { nullable: true })
-  @Type(() => UserUpdateWithWhereUniqueWithoutFollowersInput)
-  update?: Array<UserUpdateWithWhereUniqueWithoutFollowersInput>;
-
-  @Field(() => [UserUpdateManyWithWhereWithoutFollowersInput], { nullable: true })
-  @Type(() => UserUpdateManyWithWhereWithoutFollowersInput)
-  updateMany?: Array<UserUpdateManyWithWhereWithoutFollowersInput>;
-
-  @Field(() => [UserScalarWhereInput], { nullable: true })
-  @Type(() => UserScalarWhereInput)
-  deleteMany?: Array<UserScalarWhereInput>;
+
+    @Field(() => [UserCreateWithoutFollowersInput], {nullable:true})
+    @Type(() => UserCreateWithoutFollowersInput)
+    create?: Array<UserCreateWithoutFollowersInput>;
+
+    @Field(() => [UserCreateOrConnectWithoutFollowersInput], {nullable:true})
+    @Type(() => UserCreateOrConnectWithoutFollowersInput)
+    connectOrCreate?: Array<UserCreateOrConnectWithoutFollowersInput>;
+
+    @Field(() => [UserUpsertWithWhereUniqueWithoutFollowersInput], {nullable:true})
+    @Type(() => UserUpsertWithWhereUniqueWithoutFollowersInput)
+    upsert?: Array<UserUpsertWithWhereUniqueWithoutFollowersInput>;
+
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    set?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
+
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    disconnect?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
+
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    delete?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
+
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
+
+    @Field(() => [UserUpdateWithWhereUniqueWithoutFollowersInput], {nullable:true})
+    @Type(() => UserUpdateWithWhereUniqueWithoutFollowersInput)
+    update?: Array<UserUpdateWithWhereUniqueWithoutFollowersInput>;
+
+    @Field(() => [UserUpdateManyWithWhereWithoutFollowersInput], {nullable:true})
+    @Type(() => UserUpdateManyWithWhereWithoutFollowersInput)
+    updateMany?: Array<UserUpdateManyWithWhereWithoutFollowersInput>;
+
+    @Field(() => [UserScalarWhereInput], {nullable:true})
+    @Type(() => UserScalarWhereInput)
+    deleteMany?: Array<UserScalarWhereInput>;
 }
diff --git a/@generated/user/user-unchecked-update-many-without-followers.input.ts b/@generated/user/user-unchecked-update-many-without-followers.input.ts
index d89dad98..5370b2d4 100644
--- a/@generated/user/user-unchecked-update-many-without-followers.input.ts
+++ b/@generated/user/user-unchecked-update-many-without-followers.input.ts
@@ -10,34 +10,35 @@ import { NullableEnumRoleFieldUpdateOperationsInput } from '../prisma/nullable-e
 
 @InputType()
 export class UserUncheckedUpdateManyWithoutFollowersInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  email?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  name?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    email?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  password?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    name?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  bio?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    password?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  image?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    bio?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableIntFieldUpdateOperationsInput, { nullable: true })
-  countComments?: NullableIntFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    image?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableFloatFieldUpdateOperationsInput, { nullable: true })
-  rating?: NullableFloatFieldUpdateOperationsInput;
+    @Field(() => NullableIntFieldUpdateOperationsInput, {nullable:true})
+    countComments?: NullableIntFieldUpdateOperationsInput;
 
-  @Field(() => NullableDecimalFieldUpdateOperationsInput, { nullable: true })
-  @Type(() => NullableDecimalFieldUpdateOperationsInput)
-  money?: NullableDecimalFieldUpdateOperationsInput;
+    @Field(() => NullableFloatFieldUpdateOperationsInput, {nullable:true})
+    rating?: NullableFloatFieldUpdateOperationsInput;
 
-  @Field(() => NullableEnumRoleFieldUpdateOperationsInput, { nullable: true })
-  role?: NullableEnumRoleFieldUpdateOperationsInput;
+    @Field(() => NullableDecimalFieldUpdateOperationsInput, {nullable:true})
+    @Type(() => NullableDecimalFieldUpdateOperationsInput)
+    money?: NullableDecimalFieldUpdateOperationsInput;
+
+    @Field(() => NullableEnumRoleFieldUpdateOperationsInput, {nullable:true})
+    role?: NullableEnumRoleFieldUpdateOperationsInput;
 }
diff --git a/@generated/user/user-unchecked-update-many-without-following-nested.input.ts b/@generated/user/user-unchecked-update-many-without-following-nested.input.ts
index 0543a1b8..53a083e6 100644
--- a/@generated/user/user-unchecked-update-many-without-following-nested.input.ts
+++ b/@generated/user/user-unchecked-update-many-without-following-nested.input.ts
@@ -4,7 +4,7 @@ import { UserCreateWithoutFollowingInput } from './user-create-without-following
 import { Type } from 'class-transformer';
 import { UserCreateOrConnectWithoutFollowingInput } from './user-create-or-connect-without-following.input';
 import { UserUpsertWithWhereUniqueWithoutFollowingInput } from './user-upsert-with-where-unique-without-following.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 import { UserUpdateWithWhereUniqueWithoutFollowingInput } from './user-update-with-where-unique-without-following.input';
 import { UserUpdateManyWithWhereWithoutFollowingInput } from './user-update-many-with-where-without-following.input';
@@ -12,51 +12,44 @@ import { UserScalarWhereInput } from './user-scalar-where.input';
 
 @InputType()
 export class UserUncheckedUpdateManyWithoutFollowingNestedInput {
-  @Field(() => [UserCreateWithoutFollowingInput], { nullable: true })
-  @Type(() => UserCreateWithoutFollowingInput)
-  create?: Array<UserCreateWithoutFollowingInput>;
-
-  @Field(() => [UserCreateOrConnectWithoutFollowingInput], { nullable: true })
-  @Type(() => UserCreateOrConnectWithoutFollowingInput)
-  connectOrCreate?: Array<UserCreateOrConnectWithoutFollowingInput>;
-
-  @Field(() => [UserUpsertWithWhereUniqueWithoutFollowingInput], { nullable: true })
-  @Type(() => UserUpsertWithWhereUniqueWithoutFollowingInput)
-  upsert?: Array<UserUpsertWithWhereUniqueWithoutFollowingInput>;
-
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  set?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
-
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  disconnect?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
-
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  delete?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
-
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  connect?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
-
-  @Field(() => [UserUpdateWithWhereUniqueWithoutFollowingInput], { nullable: true })
-  @Type(() => UserUpdateWithWhereUniqueWithoutFollowingInput)
-  update?: Array<UserUpdateWithWhereUniqueWithoutFollowingInput>;
-
-  @Field(() => [UserUpdateManyWithWhereWithoutFollowingInput], { nullable: true })
-  @Type(() => UserUpdateManyWithWhereWithoutFollowingInput)
-  updateMany?: Array<UserUpdateManyWithWhereWithoutFollowingInput>;
-
-  @Field(() => [UserScalarWhereInput], { nullable: true })
-  @Type(() => UserScalarWhereInput)
-  deleteMany?: Array<UserScalarWhereInput>;
+
+    @Field(() => [UserCreateWithoutFollowingInput], {nullable:true})
+    @Type(() => UserCreateWithoutFollowingInput)
+    create?: Array<UserCreateWithoutFollowingInput>;
+
+    @Field(() => [UserCreateOrConnectWithoutFollowingInput], {nullable:true})
+    @Type(() => UserCreateOrConnectWithoutFollowingInput)
+    connectOrCreate?: Array<UserCreateOrConnectWithoutFollowingInput>;
+
+    @Field(() => [UserUpsertWithWhereUniqueWithoutFollowingInput], {nullable:true})
+    @Type(() => UserUpsertWithWhereUniqueWithoutFollowingInput)
+    upsert?: Array<UserUpsertWithWhereUniqueWithoutFollowingInput>;
+
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    set?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
+
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    disconnect?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
+
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    delete?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
+
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
+
+    @Field(() => [UserUpdateWithWhereUniqueWithoutFollowingInput], {nullable:true})
+    @Type(() => UserUpdateWithWhereUniqueWithoutFollowingInput)
+    update?: Array<UserUpdateWithWhereUniqueWithoutFollowingInput>;
+
+    @Field(() => [UserUpdateManyWithWhereWithoutFollowingInput], {nullable:true})
+    @Type(() => UserUpdateManyWithWhereWithoutFollowingInput)
+    updateMany?: Array<UserUpdateManyWithWhereWithoutFollowingInput>;
+
+    @Field(() => [UserScalarWhereInput], {nullable:true})
+    @Type(() => UserScalarWhereInput)
+    deleteMany?: Array<UserScalarWhereInput>;
 }
diff --git a/@generated/user/user-unchecked-update-many-without-following.input.ts b/@generated/user/user-unchecked-update-many-without-following.input.ts
index b7b1512d..b7e5b38d 100644
--- a/@generated/user/user-unchecked-update-many-without-following.input.ts
+++ b/@generated/user/user-unchecked-update-many-without-following.input.ts
@@ -10,34 +10,35 @@ import { NullableEnumRoleFieldUpdateOperationsInput } from '../prisma/nullable-e
 
 @InputType()
 export class UserUncheckedUpdateManyWithoutFollowingInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  email?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  name?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    email?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  password?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    name?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  bio?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    password?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  image?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    bio?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableIntFieldUpdateOperationsInput, { nullable: true })
-  countComments?: NullableIntFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    image?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableFloatFieldUpdateOperationsInput, { nullable: true })
-  rating?: NullableFloatFieldUpdateOperationsInput;
+    @Field(() => NullableIntFieldUpdateOperationsInput, {nullable:true})
+    countComments?: NullableIntFieldUpdateOperationsInput;
 
-  @Field(() => NullableDecimalFieldUpdateOperationsInput, { nullable: true })
-  @Type(() => NullableDecimalFieldUpdateOperationsInput)
-  money?: NullableDecimalFieldUpdateOperationsInput;
+    @Field(() => NullableFloatFieldUpdateOperationsInput, {nullable:true})
+    rating?: NullableFloatFieldUpdateOperationsInput;
 
-  @Field(() => NullableEnumRoleFieldUpdateOperationsInput, { nullable: true })
-  role?: NullableEnumRoleFieldUpdateOperationsInput;
+    @Field(() => NullableDecimalFieldUpdateOperationsInput, {nullable:true})
+    @Type(() => NullableDecimalFieldUpdateOperationsInput)
+    money?: NullableDecimalFieldUpdateOperationsInput;
+
+    @Field(() => NullableEnumRoleFieldUpdateOperationsInput, {nullable:true})
+    role?: NullableEnumRoleFieldUpdateOperationsInput;
 }
diff --git a/@generated/user/user-unchecked-update-many.input.ts b/@generated/user/user-unchecked-update-many.input.ts
index 5b7c28f2..a689cf8d 100644
--- a/@generated/user/user-unchecked-update-many.input.ts
+++ b/@generated/user/user-unchecked-update-many.input.ts
@@ -10,34 +10,35 @@ import { NullableEnumRoleFieldUpdateOperationsInput } from '../prisma/nullable-e
 
 @InputType()
 export class UserUncheckedUpdateManyInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  email?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  name?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    email?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  password?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    name?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  bio?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    password?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  image?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    bio?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableIntFieldUpdateOperationsInput, { nullable: true })
-  countComments?: NullableIntFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    image?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableFloatFieldUpdateOperationsInput, { nullable: true })
-  rating?: NullableFloatFieldUpdateOperationsInput;
+    @Field(() => NullableIntFieldUpdateOperationsInput, {nullable:true})
+    countComments?: NullableIntFieldUpdateOperationsInput;
 
-  @Field(() => NullableDecimalFieldUpdateOperationsInput, { nullable: true })
-  @Type(() => NullableDecimalFieldUpdateOperationsInput)
-  money?: NullableDecimalFieldUpdateOperationsInput;
+    @Field(() => NullableFloatFieldUpdateOperationsInput, {nullable:true})
+    rating?: NullableFloatFieldUpdateOperationsInput;
 
-  @Field(() => NullableEnumRoleFieldUpdateOperationsInput, { nullable: true })
-  role?: NullableEnumRoleFieldUpdateOperationsInput;
+    @Field(() => NullableDecimalFieldUpdateOperationsInput, {nullable:true})
+    @Type(() => NullableDecimalFieldUpdateOperationsInput)
+    money?: NullableDecimalFieldUpdateOperationsInput;
+
+    @Field(() => NullableEnumRoleFieldUpdateOperationsInput, {nullable:true})
+    role?: NullableEnumRoleFieldUpdateOperationsInput;
 }
diff --git a/@generated/user/user-unchecked-update-without-articles.input.ts b/@generated/user/user-unchecked-update-without-articles.input.ts
index 2930225a..d7af5193 100644
--- a/@generated/user/user-unchecked-update-without-articles.input.ts
+++ b/@generated/user/user-unchecked-update-without-articles.input.ts
@@ -15,56 +15,55 @@ import { ProfileUncheckedUpdateOneWithoutUserNestedInput } from '../profile/prof
 
 @InputType()
 export class UserUncheckedUpdateWithoutArticlesInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  email?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  name?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    email?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  password?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    name?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  bio?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    password?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  image?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    bio?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableIntFieldUpdateOperationsInput, { nullable: true })
-  countComments?: NullableIntFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    image?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableFloatFieldUpdateOperationsInput, { nullable: true })
-  rating?: NullableFloatFieldUpdateOperationsInput;
+    @Field(() => NullableIntFieldUpdateOperationsInput, {nullable:true})
+    countComments?: NullableIntFieldUpdateOperationsInput;
 
-  @Field(() => NullableDecimalFieldUpdateOperationsInput, { nullable: true })
-  @Type(() => NullableDecimalFieldUpdateOperationsInput)
-  money?: NullableDecimalFieldUpdateOperationsInput;
+    @Field(() => NullableFloatFieldUpdateOperationsInput, {nullable:true})
+    rating?: NullableFloatFieldUpdateOperationsInput;
 
-  @Field(() => NullableEnumRoleFieldUpdateOperationsInput, { nullable: true })
-  role?: NullableEnumRoleFieldUpdateOperationsInput;
+    @Field(() => NullableDecimalFieldUpdateOperationsInput, {nullable:true})
+    @Type(() => NullableDecimalFieldUpdateOperationsInput)
+    money?: NullableDecimalFieldUpdateOperationsInput;
 
-  @Field(() => UserUncheckedUpdateManyWithoutFollowersNestedInput, { nullable: true })
-  @Type(() => UserUncheckedUpdateManyWithoutFollowersNestedInput)
-  following?: UserUncheckedUpdateManyWithoutFollowersNestedInput;
+    @Field(() => NullableEnumRoleFieldUpdateOperationsInput, {nullable:true})
+    role?: NullableEnumRoleFieldUpdateOperationsInput;
 
-  @Field(() => UserUncheckedUpdateManyWithoutFollowingNestedInput, { nullable: true })
-  @Type(() => UserUncheckedUpdateManyWithoutFollowingNestedInput)
-  followers?: UserUncheckedUpdateManyWithoutFollowingNestedInput;
+    @Field(() => UserUncheckedUpdateManyWithoutFollowersNestedInput, {nullable:true})
+    @Type(() => UserUncheckedUpdateManyWithoutFollowersNestedInput)
+    following?: UserUncheckedUpdateManyWithoutFollowersNestedInput;
 
-  @Field(() => ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput, {
-    nullable: true,
-  })
-  @Type(() => ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput)
-  favoriteArticles?: ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput;
+    @Field(() => UserUncheckedUpdateManyWithoutFollowingNestedInput, {nullable:true})
+    @Type(() => UserUncheckedUpdateManyWithoutFollowingNestedInput)
+    followers?: UserUncheckedUpdateManyWithoutFollowingNestedInput;
 
-  @Field(() => CommentUncheckedUpdateManyWithoutAuthorNestedInput, { nullable: true })
-  @Type(() => CommentUncheckedUpdateManyWithoutAuthorNestedInput)
-  comments?: CommentUncheckedUpdateManyWithoutAuthorNestedInput;
+    @Field(() => ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput, {nullable:true})
+    @Type(() => ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput)
+    favoriteArticles?: ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput;
 
-  @Field(() => ProfileUncheckedUpdateOneWithoutUserNestedInput, { nullable: true })
-  @Type(() => ProfileUncheckedUpdateOneWithoutUserNestedInput)
-  profile?: ProfileUncheckedUpdateOneWithoutUserNestedInput;
+    @Field(() => CommentUncheckedUpdateManyWithoutAuthorNestedInput, {nullable:true})
+    @Type(() => CommentUncheckedUpdateManyWithoutAuthorNestedInput)
+    comments?: CommentUncheckedUpdateManyWithoutAuthorNestedInput;
+
+    @Field(() => ProfileUncheckedUpdateOneWithoutUserNestedInput, {nullable:true})
+    @Type(() => ProfileUncheckedUpdateOneWithoutUserNestedInput)
+    profile?: ProfileUncheckedUpdateOneWithoutUserNestedInput;
 }
diff --git a/@generated/user/user-unchecked-update-without-comments.input.ts b/@generated/user/user-unchecked-update-without-comments.input.ts
index 7fd97a86..c9efb421 100644
--- a/@generated/user/user-unchecked-update-without-comments.input.ts
+++ b/@generated/user/user-unchecked-update-without-comments.input.ts
@@ -15,56 +15,55 @@ import { ProfileUncheckedUpdateOneWithoutUserNestedInput } from '../profile/prof
 
 @InputType()
 export class UserUncheckedUpdateWithoutCommentsInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  email?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  name?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    email?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  password?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    name?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  bio?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    password?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  image?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    bio?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableIntFieldUpdateOperationsInput, { nullable: true })
-  countComments?: NullableIntFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    image?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableFloatFieldUpdateOperationsInput, { nullable: true })
-  rating?: NullableFloatFieldUpdateOperationsInput;
+    @Field(() => NullableIntFieldUpdateOperationsInput, {nullable:true})
+    countComments?: NullableIntFieldUpdateOperationsInput;
 
-  @Field(() => NullableDecimalFieldUpdateOperationsInput, { nullable: true })
-  @Type(() => NullableDecimalFieldUpdateOperationsInput)
-  money?: NullableDecimalFieldUpdateOperationsInput;
+    @Field(() => NullableFloatFieldUpdateOperationsInput, {nullable:true})
+    rating?: NullableFloatFieldUpdateOperationsInput;
 
-  @Field(() => NullableEnumRoleFieldUpdateOperationsInput, { nullable: true })
-  role?: NullableEnumRoleFieldUpdateOperationsInput;
+    @Field(() => NullableDecimalFieldUpdateOperationsInput, {nullable:true})
+    @Type(() => NullableDecimalFieldUpdateOperationsInput)
+    money?: NullableDecimalFieldUpdateOperationsInput;
 
-  @Field(() => UserUncheckedUpdateManyWithoutFollowersNestedInput, { nullable: true })
-  @Type(() => UserUncheckedUpdateManyWithoutFollowersNestedInput)
-  following?: UserUncheckedUpdateManyWithoutFollowersNestedInput;
+    @Field(() => NullableEnumRoleFieldUpdateOperationsInput, {nullable:true})
+    role?: NullableEnumRoleFieldUpdateOperationsInput;
 
-  @Field(() => UserUncheckedUpdateManyWithoutFollowingNestedInput, { nullable: true })
-  @Type(() => UserUncheckedUpdateManyWithoutFollowingNestedInput)
-  followers?: UserUncheckedUpdateManyWithoutFollowingNestedInput;
+    @Field(() => UserUncheckedUpdateManyWithoutFollowersNestedInput, {nullable:true})
+    @Type(() => UserUncheckedUpdateManyWithoutFollowersNestedInput)
+    following?: UserUncheckedUpdateManyWithoutFollowersNestedInput;
 
-  @Field(() => ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput, {
-    nullable: true,
-  })
-  @Type(() => ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput)
-  favoriteArticles?: ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput;
+    @Field(() => UserUncheckedUpdateManyWithoutFollowingNestedInput, {nullable:true})
+    @Type(() => UserUncheckedUpdateManyWithoutFollowingNestedInput)
+    followers?: UserUncheckedUpdateManyWithoutFollowingNestedInput;
 
-  @Field(() => ArticleUncheckedUpdateManyWithoutAuthorNestedInput, { nullable: true })
-  @Type(() => ArticleUncheckedUpdateManyWithoutAuthorNestedInput)
-  articles?: ArticleUncheckedUpdateManyWithoutAuthorNestedInput;
+    @Field(() => ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput, {nullable:true})
+    @Type(() => ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput)
+    favoriteArticles?: ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput;
 
-  @Field(() => ProfileUncheckedUpdateOneWithoutUserNestedInput, { nullable: true })
-  @Type(() => ProfileUncheckedUpdateOneWithoutUserNestedInput)
-  profile?: ProfileUncheckedUpdateOneWithoutUserNestedInput;
+    @Field(() => ArticleUncheckedUpdateManyWithoutAuthorNestedInput, {nullable:true})
+    @Type(() => ArticleUncheckedUpdateManyWithoutAuthorNestedInput)
+    articles?: ArticleUncheckedUpdateManyWithoutAuthorNestedInput;
+
+    @Field(() => ProfileUncheckedUpdateOneWithoutUserNestedInput, {nullable:true})
+    @Type(() => ProfileUncheckedUpdateOneWithoutUserNestedInput)
+    profile?: ProfileUncheckedUpdateOneWithoutUserNestedInput;
 }
diff --git a/@generated/user/user-unchecked-update-without-favorite-articles.input.ts b/@generated/user/user-unchecked-update-without-favorite-articles.input.ts
index 5bf61218..c2113135 100644
--- a/@generated/user/user-unchecked-update-without-favorite-articles.input.ts
+++ b/@generated/user/user-unchecked-update-without-favorite-articles.input.ts
@@ -15,54 +15,55 @@ import { ProfileUncheckedUpdateOneWithoutUserNestedInput } from '../profile/prof
 
 @InputType()
 export class UserUncheckedUpdateWithoutFavoriteArticlesInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  email?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  name?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    email?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  password?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    name?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  bio?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    password?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  image?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    bio?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableIntFieldUpdateOperationsInput, { nullable: true })
-  countComments?: NullableIntFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    image?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableFloatFieldUpdateOperationsInput, { nullable: true })
-  rating?: NullableFloatFieldUpdateOperationsInput;
+    @Field(() => NullableIntFieldUpdateOperationsInput, {nullable:true})
+    countComments?: NullableIntFieldUpdateOperationsInput;
 
-  @Field(() => NullableDecimalFieldUpdateOperationsInput, { nullable: true })
-  @Type(() => NullableDecimalFieldUpdateOperationsInput)
-  money?: NullableDecimalFieldUpdateOperationsInput;
+    @Field(() => NullableFloatFieldUpdateOperationsInput, {nullable:true})
+    rating?: NullableFloatFieldUpdateOperationsInput;
 
-  @Field(() => NullableEnumRoleFieldUpdateOperationsInput, { nullable: true })
-  role?: NullableEnumRoleFieldUpdateOperationsInput;
+    @Field(() => NullableDecimalFieldUpdateOperationsInput, {nullable:true})
+    @Type(() => NullableDecimalFieldUpdateOperationsInput)
+    money?: NullableDecimalFieldUpdateOperationsInput;
 
-  @Field(() => UserUncheckedUpdateManyWithoutFollowersNestedInput, { nullable: true })
-  @Type(() => UserUncheckedUpdateManyWithoutFollowersNestedInput)
-  following?: UserUncheckedUpdateManyWithoutFollowersNestedInput;
+    @Field(() => NullableEnumRoleFieldUpdateOperationsInput, {nullable:true})
+    role?: NullableEnumRoleFieldUpdateOperationsInput;
 
-  @Field(() => UserUncheckedUpdateManyWithoutFollowingNestedInput, { nullable: true })
-  @Type(() => UserUncheckedUpdateManyWithoutFollowingNestedInput)
-  followers?: UserUncheckedUpdateManyWithoutFollowingNestedInput;
+    @Field(() => UserUncheckedUpdateManyWithoutFollowersNestedInput, {nullable:true})
+    @Type(() => UserUncheckedUpdateManyWithoutFollowersNestedInput)
+    following?: UserUncheckedUpdateManyWithoutFollowersNestedInput;
 
-  @Field(() => ArticleUncheckedUpdateManyWithoutAuthorNestedInput, { nullable: true })
-  @Type(() => ArticleUncheckedUpdateManyWithoutAuthorNestedInput)
-  articles?: ArticleUncheckedUpdateManyWithoutAuthorNestedInput;
+    @Field(() => UserUncheckedUpdateManyWithoutFollowingNestedInput, {nullable:true})
+    @Type(() => UserUncheckedUpdateManyWithoutFollowingNestedInput)
+    followers?: UserUncheckedUpdateManyWithoutFollowingNestedInput;
 
-  @Field(() => CommentUncheckedUpdateManyWithoutAuthorNestedInput, { nullable: true })
-  @Type(() => CommentUncheckedUpdateManyWithoutAuthorNestedInput)
-  comments?: CommentUncheckedUpdateManyWithoutAuthorNestedInput;
+    @Field(() => ArticleUncheckedUpdateManyWithoutAuthorNestedInput, {nullable:true})
+    @Type(() => ArticleUncheckedUpdateManyWithoutAuthorNestedInput)
+    articles?: ArticleUncheckedUpdateManyWithoutAuthorNestedInput;
 
-  @Field(() => ProfileUncheckedUpdateOneWithoutUserNestedInput, { nullable: true })
-  @Type(() => ProfileUncheckedUpdateOneWithoutUserNestedInput)
-  profile?: ProfileUncheckedUpdateOneWithoutUserNestedInput;
+    @Field(() => CommentUncheckedUpdateManyWithoutAuthorNestedInput, {nullable:true})
+    @Type(() => CommentUncheckedUpdateManyWithoutAuthorNestedInput)
+    comments?: CommentUncheckedUpdateManyWithoutAuthorNestedInput;
+
+    @Field(() => ProfileUncheckedUpdateOneWithoutUserNestedInput, {nullable:true})
+    @Type(() => ProfileUncheckedUpdateOneWithoutUserNestedInput)
+    profile?: ProfileUncheckedUpdateOneWithoutUserNestedInput;
 }
diff --git a/@generated/user/user-unchecked-update-without-followers.input.ts b/@generated/user/user-unchecked-update-without-followers.input.ts
index ae64c07f..873b4e9c 100644
--- a/@generated/user/user-unchecked-update-without-followers.input.ts
+++ b/@generated/user/user-unchecked-update-without-followers.input.ts
@@ -15,56 +15,55 @@ import { ProfileUncheckedUpdateOneWithoutUserNestedInput } from '../profile/prof
 
 @InputType()
 export class UserUncheckedUpdateWithoutFollowersInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  email?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  name?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    email?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  password?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    name?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  bio?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    password?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  image?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    bio?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableIntFieldUpdateOperationsInput, { nullable: true })
-  countComments?: NullableIntFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    image?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableFloatFieldUpdateOperationsInput, { nullable: true })
-  rating?: NullableFloatFieldUpdateOperationsInput;
+    @Field(() => NullableIntFieldUpdateOperationsInput, {nullable:true})
+    countComments?: NullableIntFieldUpdateOperationsInput;
 
-  @Field(() => NullableDecimalFieldUpdateOperationsInput, { nullable: true })
-  @Type(() => NullableDecimalFieldUpdateOperationsInput)
-  money?: NullableDecimalFieldUpdateOperationsInput;
+    @Field(() => NullableFloatFieldUpdateOperationsInput, {nullable:true})
+    rating?: NullableFloatFieldUpdateOperationsInput;
 
-  @Field(() => NullableEnumRoleFieldUpdateOperationsInput, { nullable: true })
-  role?: NullableEnumRoleFieldUpdateOperationsInput;
+    @Field(() => NullableDecimalFieldUpdateOperationsInput, {nullable:true})
+    @Type(() => NullableDecimalFieldUpdateOperationsInput)
+    money?: NullableDecimalFieldUpdateOperationsInput;
 
-  @Field(() => UserUncheckedUpdateManyWithoutFollowersNestedInput, { nullable: true })
-  @Type(() => UserUncheckedUpdateManyWithoutFollowersNestedInput)
-  following?: UserUncheckedUpdateManyWithoutFollowersNestedInput;
+    @Field(() => NullableEnumRoleFieldUpdateOperationsInput, {nullable:true})
+    role?: NullableEnumRoleFieldUpdateOperationsInput;
 
-  @Field(() => ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput, {
-    nullable: true,
-  })
-  @Type(() => ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput)
-  favoriteArticles?: ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput;
+    @Field(() => UserUncheckedUpdateManyWithoutFollowersNestedInput, {nullable:true})
+    @Type(() => UserUncheckedUpdateManyWithoutFollowersNestedInput)
+    following?: UserUncheckedUpdateManyWithoutFollowersNestedInput;
 
-  @Field(() => ArticleUncheckedUpdateManyWithoutAuthorNestedInput, { nullable: true })
-  @Type(() => ArticleUncheckedUpdateManyWithoutAuthorNestedInput)
-  articles?: ArticleUncheckedUpdateManyWithoutAuthorNestedInput;
+    @Field(() => ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput, {nullable:true})
+    @Type(() => ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput)
+    favoriteArticles?: ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput;
 
-  @Field(() => CommentUncheckedUpdateManyWithoutAuthorNestedInput, { nullable: true })
-  @Type(() => CommentUncheckedUpdateManyWithoutAuthorNestedInput)
-  comments?: CommentUncheckedUpdateManyWithoutAuthorNestedInput;
+    @Field(() => ArticleUncheckedUpdateManyWithoutAuthorNestedInput, {nullable:true})
+    @Type(() => ArticleUncheckedUpdateManyWithoutAuthorNestedInput)
+    articles?: ArticleUncheckedUpdateManyWithoutAuthorNestedInput;
 
-  @Field(() => ProfileUncheckedUpdateOneWithoutUserNestedInput, { nullable: true })
-  @Type(() => ProfileUncheckedUpdateOneWithoutUserNestedInput)
-  profile?: ProfileUncheckedUpdateOneWithoutUserNestedInput;
+    @Field(() => CommentUncheckedUpdateManyWithoutAuthorNestedInput, {nullable:true})
+    @Type(() => CommentUncheckedUpdateManyWithoutAuthorNestedInput)
+    comments?: CommentUncheckedUpdateManyWithoutAuthorNestedInput;
+
+    @Field(() => ProfileUncheckedUpdateOneWithoutUserNestedInput, {nullable:true})
+    @Type(() => ProfileUncheckedUpdateOneWithoutUserNestedInput)
+    profile?: ProfileUncheckedUpdateOneWithoutUserNestedInput;
 }
diff --git a/@generated/user/user-unchecked-update-without-following.input.ts b/@generated/user/user-unchecked-update-without-following.input.ts
index 22854b92..221d6ed9 100644
--- a/@generated/user/user-unchecked-update-without-following.input.ts
+++ b/@generated/user/user-unchecked-update-without-following.input.ts
@@ -15,56 +15,55 @@ import { ProfileUncheckedUpdateOneWithoutUserNestedInput } from '../profile/prof
 
 @InputType()
 export class UserUncheckedUpdateWithoutFollowingInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  email?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  name?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    email?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  password?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    name?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  bio?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    password?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  image?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    bio?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableIntFieldUpdateOperationsInput, { nullable: true })
-  countComments?: NullableIntFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    image?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableFloatFieldUpdateOperationsInput, { nullable: true })
-  rating?: NullableFloatFieldUpdateOperationsInput;
+    @Field(() => NullableIntFieldUpdateOperationsInput, {nullable:true})
+    countComments?: NullableIntFieldUpdateOperationsInput;
 
-  @Field(() => NullableDecimalFieldUpdateOperationsInput, { nullable: true })
-  @Type(() => NullableDecimalFieldUpdateOperationsInput)
-  money?: NullableDecimalFieldUpdateOperationsInput;
+    @Field(() => NullableFloatFieldUpdateOperationsInput, {nullable:true})
+    rating?: NullableFloatFieldUpdateOperationsInput;
 
-  @Field(() => NullableEnumRoleFieldUpdateOperationsInput, { nullable: true })
-  role?: NullableEnumRoleFieldUpdateOperationsInput;
+    @Field(() => NullableDecimalFieldUpdateOperationsInput, {nullable:true})
+    @Type(() => NullableDecimalFieldUpdateOperationsInput)
+    money?: NullableDecimalFieldUpdateOperationsInput;
 
-  @Field(() => UserUncheckedUpdateManyWithoutFollowingNestedInput, { nullable: true })
-  @Type(() => UserUncheckedUpdateManyWithoutFollowingNestedInput)
-  followers?: UserUncheckedUpdateManyWithoutFollowingNestedInput;
+    @Field(() => NullableEnumRoleFieldUpdateOperationsInput, {nullable:true})
+    role?: NullableEnumRoleFieldUpdateOperationsInput;
 
-  @Field(() => ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput, {
-    nullable: true,
-  })
-  @Type(() => ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput)
-  favoriteArticles?: ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput;
+    @Field(() => UserUncheckedUpdateManyWithoutFollowingNestedInput, {nullable:true})
+    @Type(() => UserUncheckedUpdateManyWithoutFollowingNestedInput)
+    followers?: UserUncheckedUpdateManyWithoutFollowingNestedInput;
 
-  @Field(() => ArticleUncheckedUpdateManyWithoutAuthorNestedInput, { nullable: true })
-  @Type(() => ArticleUncheckedUpdateManyWithoutAuthorNestedInput)
-  articles?: ArticleUncheckedUpdateManyWithoutAuthorNestedInput;
+    @Field(() => ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput, {nullable:true})
+    @Type(() => ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput)
+    favoriteArticles?: ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput;
 
-  @Field(() => CommentUncheckedUpdateManyWithoutAuthorNestedInput, { nullable: true })
-  @Type(() => CommentUncheckedUpdateManyWithoutAuthorNestedInput)
-  comments?: CommentUncheckedUpdateManyWithoutAuthorNestedInput;
+    @Field(() => ArticleUncheckedUpdateManyWithoutAuthorNestedInput, {nullable:true})
+    @Type(() => ArticleUncheckedUpdateManyWithoutAuthorNestedInput)
+    articles?: ArticleUncheckedUpdateManyWithoutAuthorNestedInput;
 
-  @Field(() => ProfileUncheckedUpdateOneWithoutUserNestedInput, { nullable: true })
-  @Type(() => ProfileUncheckedUpdateOneWithoutUserNestedInput)
-  profile?: ProfileUncheckedUpdateOneWithoutUserNestedInput;
+    @Field(() => CommentUncheckedUpdateManyWithoutAuthorNestedInput, {nullable:true})
+    @Type(() => CommentUncheckedUpdateManyWithoutAuthorNestedInput)
+    comments?: CommentUncheckedUpdateManyWithoutAuthorNestedInput;
+
+    @Field(() => ProfileUncheckedUpdateOneWithoutUserNestedInput, {nullable:true})
+    @Type(() => ProfileUncheckedUpdateOneWithoutUserNestedInput)
+    profile?: ProfileUncheckedUpdateOneWithoutUserNestedInput;
 }
diff --git a/@generated/user/user-unchecked-update-without-profile.input.ts b/@generated/user/user-unchecked-update-without-profile.input.ts
index e6accea4..e34cd59b 100644
--- a/@generated/user/user-unchecked-update-without-profile.input.ts
+++ b/@generated/user/user-unchecked-update-without-profile.input.ts
@@ -15,56 +15,55 @@ import { CommentUncheckedUpdateManyWithoutAuthorNestedInput } from '../comment/c
 
 @InputType()
 export class UserUncheckedUpdateWithoutProfileInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  email?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  name?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    email?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  password?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    name?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  bio?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    password?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  image?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    bio?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableIntFieldUpdateOperationsInput, { nullable: true })
-  countComments?: NullableIntFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    image?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableFloatFieldUpdateOperationsInput, { nullable: true })
-  rating?: NullableFloatFieldUpdateOperationsInput;
+    @Field(() => NullableIntFieldUpdateOperationsInput, {nullable:true})
+    countComments?: NullableIntFieldUpdateOperationsInput;
 
-  @Field(() => NullableDecimalFieldUpdateOperationsInput, { nullable: true })
-  @Type(() => NullableDecimalFieldUpdateOperationsInput)
-  money?: NullableDecimalFieldUpdateOperationsInput;
+    @Field(() => NullableFloatFieldUpdateOperationsInput, {nullable:true})
+    rating?: NullableFloatFieldUpdateOperationsInput;
 
-  @Field(() => NullableEnumRoleFieldUpdateOperationsInput, { nullable: true })
-  role?: NullableEnumRoleFieldUpdateOperationsInput;
+    @Field(() => NullableDecimalFieldUpdateOperationsInput, {nullable:true})
+    @Type(() => NullableDecimalFieldUpdateOperationsInput)
+    money?: NullableDecimalFieldUpdateOperationsInput;
 
-  @Field(() => UserUncheckedUpdateManyWithoutFollowersNestedInput, { nullable: true })
-  @Type(() => UserUncheckedUpdateManyWithoutFollowersNestedInput)
-  following?: UserUncheckedUpdateManyWithoutFollowersNestedInput;
+    @Field(() => NullableEnumRoleFieldUpdateOperationsInput, {nullable:true})
+    role?: NullableEnumRoleFieldUpdateOperationsInput;
 
-  @Field(() => UserUncheckedUpdateManyWithoutFollowingNestedInput, { nullable: true })
-  @Type(() => UserUncheckedUpdateManyWithoutFollowingNestedInput)
-  followers?: UserUncheckedUpdateManyWithoutFollowingNestedInput;
+    @Field(() => UserUncheckedUpdateManyWithoutFollowersNestedInput, {nullable:true})
+    @Type(() => UserUncheckedUpdateManyWithoutFollowersNestedInput)
+    following?: UserUncheckedUpdateManyWithoutFollowersNestedInput;
 
-  @Field(() => ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput, {
-    nullable: true,
-  })
-  @Type(() => ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput)
-  favoriteArticles?: ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput;
+    @Field(() => UserUncheckedUpdateManyWithoutFollowingNestedInput, {nullable:true})
+    @Type(() => UserUncheckedUpdateManyWithoutFollowingNestedInput)
+    followers?: UserUncheckedUpdateManyWithoutFollowingNestedInput;
 
-  @Field(() => ArticleUncheckedUpdateManyWithoutAuthorNestedInput, { nullable: true })
-  @Type(() => ArticleUncheckedUpdateManyWithoutAuthorNestedInput)
-  articles?: ArticleUncheckedUpdateManyWithoutAuthorNestedInput;
+    @Field(() => ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput, {nullable:true})
+    @Type(() => ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput)
+    favoriteArticles?: ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput;
 
-  @Field(() => CommentUncheckedUpdateManyWithoutAuthorNestedInput, { nullable: true })
-  @Type(() => CommentUncheckedUpdateManyWithoutAuthorNestedInput)
-  comments?: CommentUncheckedUpdateManyWithoutAuthorNestedInput;
+    @Field(() => ArticleUncheckedUpdateManyWithoutAuthorNestedInput, {nullable:true})
+    @Type(() => ArticleUncheckedUpdateManyWithoutAuthorNestedInput)
+    articles?: ArticleUncheckedUpdateManyWithoutAuthorNestedInput;
+
+    @Field(() => CommentUncheckedUpdateManyWithoutAuthorNestedInput, {nullable:true})
+    @Type(() => CommentUncheckedUpdateManyWithoutAuthorNestedInput)
+    comments?: CommentUncheckedUpdateManyWithoutAuthorNestedInput;
 }
diff --git a/@generated/user/user-unchecked-update.input.ts b/@generated/user/user-unchecked-update.input.ts
index 1112156c..1065bf8b 100644
--- a/@generated/user/user-unchecked-update.input.ts
+++ b/@generated/user/user-unchecked-update.input.ts
@@ -16,60 +16,59 @@ import { ProfileUncheckedUpdateOneWithoutUserNestedInput } from '../profile/prof
 
 @InputType()
 export class UserUncheckedUpdateInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  email?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  name?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    email?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  password?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    name?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  bio?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    password?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  image?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    bio?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableIntFieldUpdateOperationsInput, { nullable: true })
-  countComments?: NullableIntFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    image?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableFloatFieldUpdateOperationsInput, { nullable: true })
-  rating?: NullableFloatFieldUpdateOperationsInput;
+    @Field(() => NullableIntFieldUpdateOperationsInput, {nullable:true})
+    countComments?: NullableIntFieldUpdateOperationsInput;
 
-  @Field(() => NullableDecimalFieldUpdateOperationsInput, { nullable: true })
-  @Type(() => NullableDecimalFieldUpdateOperationsInput)
-  money?: NullableDecimalFieldUpdateOperationsInput;
+    @Field(() => NullableFloatFieldUpdateOperationsInput, {nullable:true})
+    rating?: NullableFloatFieldUpdateOperationsInput;
 
-  @Field(() => NullableEnumRoleFieldUpdateOperationsInput, { nullable: true })
-  role?: NullableEnumRoleFieldUpdateOperationsInput;
+    @Field(() => NullableDecimalFieldUpdateOperationsInput, {nullable:true})
+    @Type(() => NullableDecimalFieldUpdateOperationsInput)
+    money?: NullableDecimalFieldUpdateOperationsInput;
 
-  @Field(() => UserUncheckedUpdateManyWithoutFollowersNestedInput, { nullable: true })
-  @Type(() => UserUncheckedUpdateManyWithoutFollowersNestedInput)
-  following?: UserUncheckedUpdateManyWithoutFollowersNestedInput;
+    @Field(() => NullableEnumRoleFieldUpdateOperationsInput, {nullable:true})
+    role?: NullableEnumRoleFieldUpdateOperationsInput;
 
-  @Field(() => UserUncheckedUpdateManyWithoutFollowingNestedInput, { nullable: true })
-  @Type(() => UserUncheckedUpdateManyWithoutFollowingNestedInput)
-  followers?: UserUncheckedUpdateManyWithoutFollowingNestedInput;
+    @Field(() => UserUncheckedUpdateManyWithoutFollowersNestedInput, {nullable:true})
+    @Type(() => UserUncheckedUpdateManyWithoutFollowersNestedInput)
+    following?: UserUncheckedUpdateManyWithoutFollowersNestedInput;
 
-  @Field(() => ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput, {
-    nullable: true,
-  })
-  @Type(() => ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput)
-  favoriteArticles?: ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput;
+    @Field(() => UserUncheckedUpdateManyWithoutFollowingNestedInput, {nullable:true})
+    @Type(() => UserUncheckedUpdateManyWithoutFollowingNestedInput)
+    followers?: UserUncheckedUpdateManyWithoutFollowingNestedInput;
 
-  @Field(() => ArticleUncheckedUpdateManyWithoutAuthorNestedInput, { nullable: true })
-  @Type(() => ArticleUncheckedUpdateManyWithoutAuthorNestedInput)
-  articles?: ArticleUncheckedUpdateManyWithoutAuthorNestedInput;
+    @Field(() => ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput, {nullable:true})
+    @Type(() => ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput)
+    favoriteArticles?: ArticleUncheckedUpdateManyWithoutFavoritedByNestedInput;
 
-  @Field(() => CommentUncheckedUpdateManyWithoutAuthorNestedInput, { nullable: true })
-  @Type(() => CommentUncheckedUpdateManyWithoutAuthorNestedInput)
-  comments?: CommentUncheckedUpdateManyWithoutAuthorNestedInput;
+    @Field(() => ArticleUncheckedUpdateManyWithoutAuthorNestedInput, {nullable:true})
+    @Type(() => ArticleUncheckedUpdateManyWithoutAuthorNestedInput)
+    articles?: ArticleUncheckedUpdateManyWithoutAuthorNestedInput;
 
-  @Field(() => ProfileUncheckedUpdateOneWithoutUserNestedInput, { nullable: true })
-  @Type(() => ProfileUncheckedUpdateOneWithoutUserNestedInput)
-  profile?: ProfileUncheckedUpdateOneWithoutUserNestedInput;
+    @Field(() => CommentUncheckedUpdateManyWithoutAuthorNestedInput, {nullable:true})
+    @Type(() => CommentUncheckedUpdateManyWithoutAuthorNestedInput)
+    comments?: CommentUncheckedUpdateManyWithoutAuthorNestedInput;
+
+    @Field(() => ProfileUncheckedUpdateOneWithoutUserNestedInput, {nullable:true})
+    @Type(() => ProfileUncheckedUpdateOneWithoutUserNestedInput)
+    profile?: ProfileUncheckedUpdateOneWithoutUserNestedInput;
 }
diff --git a/@generated/user/user-update-many-mutation.input.ts b/@generated/user/user-update-many-mutation.input.ts
index 06103661..215137dd 100644
--- a/@generated/user/user-update-many-mutation.input.ts
+++ b/@generated/user/user-update-many-mutation.input.ts
@@ -10,34 +10,35 @@ import { NullableEnumRoleFieldUpdateOperationsInput } from '../prisma/nullable-e
 
 @InputType()
 export class UserUpdateManyMutationInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  email?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  name?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    email?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  password?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    name?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  bio?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    password?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  image?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    bio?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableIntFieldUpdateOperationsInput, { nullable: true })
-  countComments?: NullableIntFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    image?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableFloatFieldUpdateOperationsInput, { nullable: true })
-  rating?: NullableFloatFieldUpdateOperationsInput;
+    @Field(() => NullableIntFieldUpdateOperationsInput, {nullable:true})
+    countComments?: NullableIntFieldUpdateOperationsInput;
 
-  @Field(() => NullableDecimalFieldUpdateOperationsInput, { nullable: true })
-  @Type(() => NullableDecimalFieldUpdateOperationsInput)
-  money?: NullableDecimalFieldUpdateOperationsInput;
+    @Field(() => NullableFloatFieldUpdateOperationsInput, {nullable:true})
+    rating?: NullableFloatFieldUpdateOperationsInput;
 
-  @Field(() => NullableEnumRoleFieldUpdateOperationsInput, { nullable: true })
-  role?: NullableEnumRoleFieldUpdateOperationsInput;
+    @Field(() => NullableDecimalFieldUpdateOperationsInput, {nullable:true})
+    @Type(() => NullableDecimalFieldUpdateOperationsInput)
+    money?: NullableDecimalFieldUpdateOperationsInput;
+
+    @Field(() => NullableEnumRoleFieldUpdateOperationsInput, {nullable:true})
+    role?: NullableEnumRoleFieldUpdateOperationsInput;
 }
diff --git a/@generated/user/user-update-many-with-where-without-favorite-articles.input.ts b/@generated/user/user-update-many-with-where-without-favorite-articles.input.ts
index 6cc0bf96..1d772b80 100644
--- a/@generated/user/user-update-many-with-where-without-favorite-articles.input.ts
+++ b/@generated/user/user-update-many-with-where-without-favorite-articles.input.ts
@@ -6,11 +6,12 @@ import { UserUpdateManyMutationInput } from './user-update-many-mutation.input';
 
 @InputType()
 export class UserUpdateManyWithWhereWithoutFavoriteArticlesInput {
-  @Field(() => UserScalarWhereInput, { nullable: false })
-  @Type(() => UserScalarWhereInput)
-  where!: UserScalarWhereInput;
 
-  @Field(() => UserUpdateManyMutationInput, { nullable: false })
-  @Type(() => UserUpdateManyMutationInput)
-  data!: UserUpdateManyMutationInput;
+    @Field(() => UserScalarWhereInput, {nullable:false})
+    @Type(() => UserScalarWhereInput)
+    where!: UserScalarWhereInput;
+
+    @Field(() => UserUpdateManyMutationInput, {nullable:false})
+    @Type(() => UserUpdateManyMutationInput)
+    data!: UserUpdateManyMutationInput;
 }
diff --git a/@generated/user/user-update-many-with-where-without-followers.input.ts b/@generated/user/user-update-many-with-where-without-followers.input.ts
index 98416b1c..48782a3d 100644
--- a/@generated/user/user-update-many-with-where-without-followers.input.ts
+++ b/@generated/user/user-update-many-with-where-without-followers.input.ts
@@ -6,11 +6,12 @@ import { UserUpdateManyMutationInput } from './user-update-many-mutation.input';
 
 @InputType()
 export class UserUpdateManyWithWhereWithoutFollowersInput {
-  @Field(() => UserScalarWhereInput, { nullable: false })
-  @Type(() => UserScalarWhereInput)
-  where!: UserScalarWhereInput;
 
-  @Field(() => UserUpdateManyMutationInput, { nullable: false })
-  @Type(() => UserUpdateManyMutationInput)
-  data!: UserUpdateManyMutationInput;
+    @Field(() => UserScalarWhereInput, {nullable:false})
+    @Type(() => UserScalarWhereInput)
+    where!: UserScalarWhereInput;
+
+    @Field(() => UserUpdateManyMutationInput, {nullable:false})
+    @Type(() => UserUpdateManyMutationInput)
+    data!: UserUpdateManyMutationInput;
 }
diff --git a/@generated/user/user-update-many-with-where-without-following.input.ts b/@generated/user/user-update-many-with-where-without-following.input.ts
index 01c859ad..e37efab8 100644
--- a/@generated/user/user-update-many-with-where-without-following.input.ts
+++ b/@generated/user/user-update-many-with-where-without-following.input.ts
@@ -6,11 +6,12 @@ import { UserUpdateManyMutationInput } from './user-update-many-mutation.input';
 
 @InputType()
 export class UserUpdateManyWithWhereWithoutFollowingInput {
-  @Field(() => UserScalarWhereInput, { nullable: false })
-  @Type(() => UserScalarWhereInput)
-  where!: UserScalarWhereInput;
 
-  @Field(() => UserUpdateManyMutationInput, { nullable: false })
-  @Type(() => UserUpdateManyMutationInput)
-  data!: UserUpdateManyMutationInput;
+    @Field(() => UserScalarWhereInput, {nullable:false})
+    @Type(() => UserScalarWhereInput)
+    where!: UserScalarWhereInput;
+
+    @Field(() => UserUpdateManyMutationInput, {nullable:false})
+    @Type(() => UserUpdateManyMutationInput)
+    data!: UserUpdateManyMutationInput;
 }
diff --git a/@generated/user/user-update-many-without-favorite-articles-nested.input.ts b/@generated/user/user-update-many-without-favorite-articles-nested.input.ts
index c28108c6..a96b3879 100644
--- a/@generated/user/user-update-many-without-favorite-articles-nested.input.ts
+++ b/@generated/user/user-update-many-without-favorite-articles-nested.input.ts
@@ -4,7 +4,7 @@ import { UserCreateWithoutFavoriteArticlesInput } from './user-create-without-fa
 import { Type } from 'class-transformer';
 import { UserCreateOrConnectWithoutFavoriteArticlesInput } from './user-create-or-connect-without-favorite-articles.input';
 import { UserUpsertWithWhereUniqueWithoutFavoriteArticlesInput } from './user-upsert-with-where-unique-without-favorite-articles.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 import { UserUpdateWithWhereUniqueWithoutFavoriteArticlesInput } from './user-update-with-where-unique-without-favorite-articles.input';
 import { UserUpdateManyWithWhereWithoutFavoriteArticlesInput } from './user-update-many-with-where-without-favorite-articles.input';
@@ -12,57 +12,44 @@ import { UserScalarWhereInput } from './user-scalar-where.input';
 
 @InputType()
 export class UserUpdateManyWithoutFavoriteArticlesNestedInput {
-  @Field(() => [UserCreateWithoutFavoriteArticlesInput], { nullable: true })
-  @Type(() => UserCreateWithoutFavoriteArticlesInput)
-  create?: Array<UserCreateWithoutFavoriteArticlesInput>;
 
-  @Field(() => [UserCreateOrConnectWithoutFavoriteArticlesInput], { nullable: true })
-  @Type(() => UserCreateOrConnectWithoutFavoriteArticlesInput)
-  connectOrCreate?: Array<UserCreateOrConnectWithoutFavoriteArticlesInput>;
+    @Field(() => [UserCreateWithoutFavoriteArticlesInput], {nullable:true})
+    @Type(() => UserCreateWithoutFavoriteArticlesInput)
+    create?: Array<UserCreateWithoutFavoriteArticlesInput>;
 
-  @Field(() => [UserUpsertWithWhereUniqueWithoutFavoriteArticlesInput], {
-    nullable: true,
-  })
-  @Type(() => UserUpsertWithWhereUniqueWithoutFavoriteArticlesInput)
-  upsert?: Array<UserUpsertWithWhereUniqueWithoutFavoriteArticlesInput>;
+    @Field(() => [UserCreateOrConnectWithoutFavoriteArticlesInput], {nullable:true})
+    @Type(() => UserCreateOrConnectWithoutFavoriteArticlesInput)
+    connectOrCreate?: Array<UserCreateOrConnectWithoutFavoriteArticlesInput>;
 
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  set?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
+    @Field(() => [UserUpsertWithWhereUniqueWithoutFavoriteArticlesInput], {nullable:true})
+    @Type(() => UserUpsertWithWhereUniqueWithoutFavoriteArticlesInput)
+    upsert?: Array<UserUpsertWithWhereUniqueWithoutFavoriteArticlesInput>;
 
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  disconnect?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    set?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
 
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  delete?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    disconnect?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
 
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  connect?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    delete?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
 
-  @Field(() => [UserUpdateWithWhereUniqueWithoutFavoriteArticlesInput], {
-    nullable: true,
-  })
-  @Type(() => UserUpdateWithWhereUniqueWithoutFavoriteArticlesInput)
-  update?: Array<UserUpdateWithWhereUniqueWithoutFavoriteArticlesInput>;
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
 
-  @Field(() => [UserUpdateManyWithWhereWithoutFavoriteArticlesInput], {
-    nullable: true,
-  })
-  @Type(() => UserUpdateManyWithWhereWithoutFavoriteArticlesInput)
-  updateMany?: Array<UserUpdateManyWithWhereWithoutFavoriteArticlesInput>;
+    @Field(() => [UserUpdateWithWhereUniqueWithoutFavoriteArticlesInput], {nullable:true})
+    @Type(() => UserUpdateWithWhereUniqueWithoutFavoriteArticlesInput)
+    update?: Array<UserUpdateWithWhereUniqueWithoutFavoriteArticlesInput>;
 
-  @Field(() => [UserScalarWhereInput], { nullable: true })
-  @Type(() => UserScalarWhereInput)
-  deleteMany?: Array<UserScalarWhereInput>;
+    @Field(() => [UserUpdateManyWithWhereWithoutFavoriteArticlesInput], {nullable:true})
+    @Type(() => UserUpdateManyWithWhereWithoutFavoriteArticlesInput)
+    updateMany?: Array<UserUpdateManyWithWhereWithoutFavoriteArticlesInput>;
+
+    @Field(() => [UserScalarWhereInput], {nullable:true})
+    @Type(() => UserScalarWhereInput)
+    deleteMany?: Array<UserScalarWhereInput>;
 }
diff --git a/@generated/user/user-update-many-without-followers-nested.input.ts b/@generated/user/user-update-many-without-followers-nested.input.ts
index f172ffad..88006e35 100644
--- a/@generated/user/user-update-many-without-followers-nested.input.ts
+++ b/@generated/user/user-update-many-without-followers-nested.input.ts
@@ -4,7 +4,7 @@ import { UserCreateWithoutFollowersInput } from './user-create-without-followers
 import { Type } from 'class-transformer';
 import { UserCreateOrConnectWithoutFollowersInput } from './user-create-or-connect-without-followers.input';
 import { UserUpsertWithWhereUniqueWithoutFollowersInput } from './user-upsert-with-where-unique-without-followers.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 import { UserUpdateWithWhereUniqueWithoutFollowersInput } from './user-update-with-where-unique-without-followers.input';
 import { UserUpdateManyWithWhereWithoutFollowersInput } from './user-update-many-with-where-without-followers.input';
@@ -12,51 +12,44 @@ import { UserScalarWhereInput } from './user-scalar-where.input';
 
 @InputType()
 export class UserUpdateManyWithoutFollowersNestedInput {
-  @Field(() => [UserCreateWithoutFollowersInput], { nullable: true })
-  @Type(() => UserCreateWithoutFollowersInput)
-  create?: Array<UserCreateWithoutFollowersInput>;
-
-  @Field(() => [UserCreateOrConnectWithoutFollowersInput], { nullable: true })
-  @Type(() => UserCreateOrConnectWithoutFollowersInput)
-  connectOrCreate?: Array<UserCreateOrConnectWithoutFollowersInput>;
-
-  @Field(() => [UserUpsertWithWhereUniqueWithoutFollowersInput], { nullable: true })
-  @Type(() => UserUpsertWithWhereUniqueWithoutFollowersInput)
-  upsert?: Array<UserUpsertWithWhereUniqueWithoutFollowersInput>;
-
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  set?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
-
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  disconnect?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
-
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  delete?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
-
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  connect?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
-
-  @Field(() => [UserUpdateWithWhereUniqueWithoutFollowersInput], { nullable: true })
-  @Type(() => UserUpdateWithWhereUniqueWithoutFollowersInput)
-  update?: Array<UserUpdateWithWhereUniqueWithoutFollowersInput>;
-
-  @Field(() => [UserUpdateManyWithWhereWithoutFollowersInput], { nullable: true })
-  @Type(() => UserUpdateManyWithWhereWithoutFollowersInput)
-  updateMany?: Array<UserUpdateManyWithWhereWithoutFollowersInput>;
-
-  @Field(() => [UserScalarWhereInput], { nullable: true })
-  @Type(() => UserScalarWhereInput)
-  deleteMany?: Array<UserScalarWhereInput>;
+
+    @Field(() => [UserCreateWithoutFollowersInput], {nullable:true})
+    @Type(() => UserCreateWithoutFollowersInput)
+    create?: Array<UserCreateWithoutFollowersInput>;
+
+    @Field(() => [UserCreateOrConnectWithoutFollowersInput], {nullable:true})
+    @Type(() => UserCreateOrConnectWithoutFollowersInput)
+    connectOrCreate?: Array<UserCreateOrConnectWithoutFollowersInput>;
+
+    @Field(() => [UserUpsertWithWhereUniqueWithoutFollowersInput], {nullable:true})
+    @Type(() => UserUpsertWithWhereUniqueWithoutFollowersInput)
+    upsert?: Array<UserUpsertWithWhereUniqueWithoutFollowersInput>;
+
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    set?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
+
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    disconnect?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
+
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    delete?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
+
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
+
+    @Field(() => [UserUpdateWithWhereUniqueWithoutFollowersInput], {nullable:true})
+    @Type(() => UserUpdateWithWhereUniqueWithoutFollowersInput)
+    update?: Array<UserUpdateWithWhereUniqueWithoutFollowersInput>;
+
+    @Field(() => [UserUpdateManyWithWhereWithoutFollowersInput], {nullable:true})
+    @Type(() => UserUpdateManyWithWhereWithoutFollowersInput)
+    updateMany?: Array<UserUpdateManyWithWhereWithoutFollowersInput>;
+
+    @Field(() => [UserScalarWhereInput], {nullable:true})
+    @Type(() => UserScalarWhereInput)
+    deleteMany?: Array<UserScalarWhereInput>;
 }
diff --git a/@generated/user/user-update-many-without-following-nested.input.ts b/@generated/user/user-update-many-without-following-nested.input.ts
index 040a324b..69d09a48 100644
--- a/@generated/user/user-update-many-without-following-nested.input.ts
+++ b/@generated/user/user-update-many-without-following-nested.input.ts
@@ -4,7 +4,7 @@ import { UserCreateWithoutFollowingInput } from './user-create-without-following
 import { Type } from 'class-transformer';
 import { UserCreateOrConnectWithoutFollowingInput } from './user-create-or-connect-without-following.input';
 import { UserUpsertWithWhereUniqueWithoutFollowingInput } from './user-upsert-with-where-unique-without-following.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 import { UserUpdateWithWhereUniqueWithoutFollowingInput } from './user-update-with-where-unique-without-following.input';
 import { UserUpdateManyWithWhereWithoutFollowingInput } from './user-update-many-with-where-without-following.input';
@@ -12,51 +12,44 @@ import { UserScalarWhereInput } from './user-scalar-where.input';
 
 @InputType()
 export class UserUpdateManyWithoutFollowingNestedInput {
-  @Field(() => [UserCreateWithoutFollowingInput], { nullable: true })
-  @Type(() => UserCreateWithoutFollowingInput)
-  create?: Array<UserCreateWithoutFollowingInput>;
-
-  @Field(() => [UserCreateOrConnectWithoutFollowingInput], { nullable: true })
-  @Type(() => UserCreateOrConnectWithoutFollowingInput)
-  connectOrCreate?: Array<UserCreateOrConnectWithoutFollowingInput>;
-
-  @Field(() => [UserUpsertWithWhereUniqueWithoutFollowingInput], { nullable: true })
-  @Type(() => UserUpsertWithWhereUniqueWithoutFollowingInput)
-  upsert?: Array<UserUpsertWithWhereUniqueWithoutFollowingInput>;
-
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  set?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
-
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  disconnect?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
-
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  delete?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
-
-  @Field(() => [UserWhereUniqueInput], { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  connect?: Array<
-    Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>
-  >;
-
-  @Field(() => [UserUpdateWithWhereUniqueWithoutFollowingInput], { nullable: true })
-  @Type(() => UserUpdateWithWhereUniqueWithoutFollowingInput)
-  update?: Array<UserUpdateWithWhereUniqueWithoutFollowingInput>;
-
-  @Field(() => [UserUpdateManyWithWhereWithoutFollowingInput], { nullable: true })
-  @Type(() => UserUpdateManyWithWhereWithoutFollowingInput)
-  updateMany?: Array<UserUpdateManyWithWhereWithoutFollowingInput>;
-
-  @Field(() => [UserScalarWhereInput], { nullable: true })
-  @Type(() => UserScalarWhereInput)
-  deleteMany?: Array<UserScalarWhereInput>;
+
+    @Field(() => [UserCreateWithoutFollowingInput], {nullable:true})
+    @Type(() => UserCreateWithoutFollowingInput)
+    create?: Array<UserCreateWithoutFollowingInput>;
+
+    @Field(() => [UserCreateOrConnectWithoutFollowingInput], {nullable:true})
+    @Type(() => UserCreateOrConnectWithoutFollowingInput)
+    connectOrCreate?: Array<UserCreateOrConnectWithoutFollowingInput>;
+
+    @Field(() => [UserUpsertWithWhereUniqueWithoutFollowingInput], {nullable:true})
+    @Type(() => UserUpsertWithWhereUniqueWithoutFollowingInput)
+    upsert?: Array<UserUpsertWithWhereUniqueWithoutFollowingInput>;
+
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    set?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
+
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    disconnect?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
+
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    delete?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
+
+    @Field(() => [UserWhereUniqueInput], {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    connect?: Array<Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>>;
+
+    @Field(() => [UserUpdateWithWhereUniqueWithoutFollowingInput], {nullable:true})
+    @Type(() => UserUpdateWithWhereUniqueWithoutFollowingInput)
+    update?: Array<UserUpdateWithWhereUniqueWithoutFollowingInput>;
+
+    @Field(() => [UserUpdateManyWithWhereWithoutFollowingInput], {nullable:true})
+    @Type(() => UserUpdateManyWithWhereWithoutFollowingInput)
+    updateMany?: Array<UserUpdateManyWithWhereWithoutFollowingInput>;
+
+    @Field(() => [UserScalarWhereInput], {nullable:true})
+    @Type(() => UserScalarWhereInput)
+    deleteMany?: Array<UserScalarWhereInput>;
 }
diff --git a/@generated/user/user-update-one-required-without-articles-nested.input.ts b/@generated/user/user-update-one-required-without-articles-nested.input.ts
index 7d99231f..195deb32 100644
--- a/@generated/user/user-update-one-required-without-articles-nested.input.ts
+++ b/@generated/user/user-update-one-required-without-articles-nested.input.ts
@@ -4,32 +4,30 @@ import { UserCreateWithoutArticlesInput } from './user-create-without-articles.i
 import { Type } from 'class-transformer';
 import { UserCreateOrConnectWithoutArticlesInput } from './user-create-or-connect-without-articles.input';
 import { UserUpsertWithoutArticlesInput } from './user-upsert-without-articles.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 import { UserUpdateToOneWithWhereWithoutArticlesInput } from './user-update-to-one-with-where-without-articles.input';
 
 @InputType()
 export class UserUpdateOneRequiredWithoutArticlesNestedInput {
-  @Field(() => UserCreateWithoutArticlesInput, { nullable: true })
-  @Type(() => UserCreateWithoutArticlesInput)
-  create?: UserCreateWithoutArticlesInput;
 
-  @Field(() => UserCreateOrConnectWithoutArticlesInput, { nullable: true })
-  @Type(() => UserCreateOrConnectWithoutArticlesInput)
-  connectOrCreate?: UserCreateOrConnectWithoutArticlesInput;
+    @Field(() => UserCreateWithoutArticlesInput, {nullable:true})
+    @Type(() => UserCreateWithoutArticlesInput)
+    create?: UserCreateWithoutArticlesInput;
 
-  @Field(() => UserUpsertWithoutArticlesInput, { nullable: true })
-  @Type(() => UserUpsertWithoutArticlesInput)
-  upsert?: UserUpsertWithoutArticlesInput;
+    @Field(() => UserCreateOrConnectWithoutArticlesInput, {nullable:true})
+    @Type(() => UserCreateOrConnectWithoutArticlesInput)
+    connectOrCreate?: UserCreateOrConnectWithoutArticlesInput;
 
-  @Field(() => UserWhereUniqueInput, { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  connect?: Prisma.AtLeast<
-    UserWhereUniqueInput,
-    'id' | 'email' | 'name' | 'email_name'
-  >;
+    @Field(() => UserUpsertWithoutArticlesInput, {nullable:true})
+    @Type(() => UserUpsertWithoutArticlesInput)
+    upsert?: UserUpsertWithoutArticlesInput;
 
-  @Field(() => UserUpdateToOneWithWhereWithoutArticlesInput, { nullable: true })
-  @Type(() => UserUpdateToOneWithWhereWithoutArticlesInput)
-  update?: UserUpdateToOneWithWhereWithoutArticlesInput;
+    @Field(() => UserWhereUniqueInput, {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    connect?: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
+
+    @Field(() => UserUpdateToOneWithWhereWithoutArticlesInput, {nullable:true})
+    @Type(() => UserUpdateToOneWithWhereWithoutArticlesInput)
+    update?: UserUpdateToOneWithWhereWithoutArticlesInput;
 }
diff --git a/@generated/user/user-update-one-required-without-comments-nested.input.ts b/@generated/user/user-update-one-required-without-comments-nested.input.ts
index 6673c4ac..046547da 100644
--- a/@generated/user/user-update-one-required-without-comments-nested.input.ts
+++ b/@generated/user/user-update-one-required-without-comments-nested.input.ts
@@ -4,32 +4,30 @@ import { UserCreateWithoutCommentsInput } from './user-create-without-comments.i
 import { Type } from 'class-transformer';
 import { UserCreateOrConnectWithoutCommentsInput } from './user-create-or-connect-without-comments.input';
 import { UserUpsertWithoutCommentsInput } from './user-upsert-without-comments.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 import { UserUpdateToOneWithWhereWithoutCommentsInput } from './user-update-to-one-with-where-without-comments.input';
 
 @InputType()
 export class UserUpdateOneRequiredWithoutCommentsNestedInput {
-  @Field(() => UserCreateWithoutCommentsInput, { nullable: true })
-  @Type(() => UserCreateWithoutCommentsInput)
-  create?: UserCreateWithoutCommentsInput;
 
-  @Field(() => UserCreateOrConnectWithoutCommentsInput, { nullable: true })
-  @Type(() => UserCreateOrConnectWithoutCommentsInput)
-  connectOrCreate?: UserCreateOrConnectWithoutCommentsInput;
+    @Field(() => UserCreateWithoutCommentsInput, {nullable:true})
+    @Type(() => UserCreateWithoutCommentsInput)
+    create?: UserCreateWithoutCommentsInput;
 
-  @Field(() => UserUpsertWithoutCommentsInput, { nullable: true })
-  @Type(() => UserUpsertWithoutCommentsInput)
-  upsert?: UserUpsertWithoutCommentsInput;
+    @Field(() => UserCreateOrConnectWithoutCommentsInput, {nullable:true})
+    @Type(() => UserCreateOrConnectWithoutCommentsInput)
+    connectOrCreate?: UserCreateOrConnectWithoutCommentsInput;
 
-  @Field(() => UserWhereUniqueInput, { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  connect?: Prisma.AtLeast<
-    UserWhereUniqueInput,
-    'id' | 'email' | 'name' | 'email_name'
-  >;
+    @Field(() => UserUpsertWithoutCommentsInput, {nullable:true})
+    @Type(() => UserUpsertWithoutCommentsInput)
+    upsert?: UserUpsertWithoutCommentsInput;
 
-  @Field(() => UserUpdateToOneWithWhereWithoutCommentsInput, { nullable: true })
-  @Type(() => UserUpdateToOneWithWhereWithoutCommentsInput)
-  update?: UserUpdateToOneWithWhereWithoutCommentsInput;
+    @Field(() => UserWhereUniqueInput, {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    connect?: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
+
+    @Field(() => UserUpdateToOneWithWhereWithoutCommentsInput, {nullable:true})
+    @Type(() => UserUpdateToOneWithWhereWithoutCommentsInput)
+    update?: UserUpdateToOneWithWhereWithoutCommentsInput;
 }
diff --git a/@generated/user/user-update-one-required-without-profile-nested.input.ts b/@generated/user/user-update-one-required-without-profile-nested.input.ts
index e3fe49ae..218449ec 100644
--- a/@generated/user/user-update-one-required-without-profile-nested.input.ts
+++ b/@generated/user/user-update-one-required-without-profile-nested.input.ts
@@ -4,32 +4,30 @@ import { UserCreateWithoutProfileInput } from './user-create-without-profile.inp
 import { Type } from 'class-transformer';
 import { UserCreateOrConnectWithoutProfileInput } from './user-create-or-connect-without-profile.input';
 import { UserUpsertWithoutProfileInput } from './user-upsert-without-profile.input';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 import { UserUpdateToOneWithWhereWithoutProfileInput } from './user-update-to-one-with-where-without-profile.input';
 
 @InputType()
 export class UserUpdateOneRequiredWithoutProfileNestedInput {
-  @Field(() => UserCreateWithoutProfileInput, { nullable: true })
-  @Type(() => UserCreateWithoutProfileInput)
-  create?: UserCreateWithoutProfileInput;
 
-  @Field(() => UserCreateOrConnectWithoutProfileInput, { nullable: true })
-  @Type(() => UserCreateOrConnectWithoutProfileInput)
-  connectOrCreate?: UserCreateOrConnectWithoutProfileInput;
+    @Field(() => UserCreateWithoutProfileInput, {nullable:true})
+    @Type(() => UserCreateWithoutProfileInput)
+    create?: UserCreateWithoutProfileInput;
 
-  @Field(() => UserUpsertWithoutProfileInput, { nullable: true })
-  @Type(() => UserUpsertWithoutProfileInput)
-  upsert?: UserUpsertWithoutProfileInput;
+    @Field(() => UserCreateOrConnectWithoutProfileInput, {nullable:true})
+    @Type(() => UserCreateOrConnectWithoutProfileInput)
+    connectOrCreate?: UserCreateOrConnectWithoutProfileInput;
 
-  @Field(() => UserWhereUniqueInput, { nullable: true })
-  @Type(() => UserWhereUniqueInput)
-  connect?: Prisma.AtLeast<
-    UserWhereUniqueInput,
-    'id' | 'email' | 'name' | 'email_name'
-  >;
+    @Field(() => UserUpsertWithoutProfileInput, {nullable:true})
+    @Type(() => UserUpsertWithoutProfileInput)
+    upsert?: UserUpsertWithoutProfileInput;
 
-  @Field(() => UserUpdateToOneWithWhereWithoutProfileInput, { nullable: true })
-  @Type(() => UserUpdateToOneWithWhereWithoutProfileInput)
-  update?: UserUpdateToOneWithWhereWithoutProfileInput;
+    @Field(() => UserWhereUniqueInput, {nullable:true})
+    @Type(() => UserWhereUniqueInput)
+    connect?: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
+
+    @Field(() => UserUpdateToOneWithWhereWithoutProfileInput, {nullable:true})
+    @Type(() => UserUpdateToOneWithWhereWithoutProfileInput)
+    update?: UserUpdateToOneWithWhereWithoutProfileInput;
 }
diff --git a/@generated/user/user-update-to-one-with-where-without-articles.input.ts b/@generated/user/user-update-to-one-with-where-without-articles.input.ts
index 32032d8b..e07505b2 100644
--- a/@generated/user/user-update-to-one-with-where-without-articles.input.ts
+++ b/@generated/user/user-update-to-one-with-where-without-articles.input.ts
@@ -6,11 +6,12 @@ import { UserUpdateWithoutArticlesInput } from './user-update-without-articles.i
 
 @InputType()
 export class UserUpdateToOneWithWhereWithoutArticlesInput {
-  @Field(() => UserWhereInput, { nullable: true })
-  @Type(() => UserWhereInput)
-  where?: UserWhereInput;
 
-  @Field(() => UserUpdateWithoutArticlesInput, { nullable: false })
-  @Type(() => UserUpdateWithoutArticlesInput)
-  data!: UserUpdateWithoutArticlesInput;
+    @Field(() => UserWhereInput, {nullable:true})
+    @Type(() => UserWhereInput)
+    where?: UserWhereInput;
+
+    @Field(() => UserUpdateWithoutArticlesInput, {nullable:false})
+    @Type(() => UserUpdateWithoutArticlesInput)
+    data!: UserUpdateWithoutArticlesInput;
 }
diff --git a/@generated/user/user-update-to-one-with-where-without-comments.input.ts b/@generated/user/user-update-to-one-with-where-without-comments.input.ts
index b6213aca..23321d6c 100644
--- a/@generated/user/user-update-to-one-with-where-without-comments.input.ts
+++ b/@generated/user/user-update-to-one-with-where-without-comments.input.ts
@@ -6,11 +6,12 @@ import { UserUpdateWithoutCommentsInput } from './user-update-without-comments.i
 
 @InputType()
 export class UserUpdateToOneWithWhereWithoutCommentsInput {
-  @Field(() => UserWhereInput, { nullable: true })
-  @Type(() => UserWhereInput)
-  where?: UserWhereInput;
 
-  @Field(() => UserUpdateWithoutCommentsInput, { nullable: false })
-  @Type(() => UserUpdateWithoutCommentsInput)
-  data!: UserUpdateWithoutCommentsInput;
+    @Field(() => UserWhereInput, {nullable:true})
+    @Type(() => UserWhereInput)
+    where?: UserWhereInput;
+
+    @Field(() => UserUpdateWithoutCommentsInput, {nullable:false})
+    @Type(() => UserUpdateWithoutCommentsInput)
+    data!: UserUpdateWithoutCommentsInput;
 }
diff --git a/@generated/user/user-update-to-one-with-where-without-profile.input.ts b/@generated/user/user-update-to-one-with-where-without-profile.input.ts
index 6aaf94e8..52ded66a 100644
--- a/@generated/user/user-update-to-one-with-where-without-profile.input.ts
+++ b/@generated/user/user-update-to-one-with-where-without-profile.input.ts
@@ -6,11 +6,12 @@ import { UserUpdateWithoutProfileInput } from './user-update-without-profile.inp
 
 @InputType()
 export class UserUpdateToOneWithWhereWithoutProfileInput {
-  @Field(() => UserWhereInput, { nullable: true })
-  @Type(() => UserWhereInput)
-  where?: UserWhereInput;
 
-  @Field(() => UserUpdateWithoutProfileInput, { nullable: false })
-  @Type(() => UserUpdateWithoutProfileInput)
-  data!: UserUpdateWithoutProfileInput;
+    @Field(() => UserWhereInput, {nullable:true})
+    @Type(() => UserWhereInput)
+    where?: UserWhereInput;
+
+    @Field(() => UserUpdateWithoutProfileInput, {nullable:false})
+    @Type(() => UserUpdateWithoutProfileInput)
+    data!: UserUpdateWithoutProfileInput;
 }
diff --git a/@generated/user/user-update-with-where-unique-without-favorite-articles.input.ts b/@generated/user/user-update-with-where-unique-without-favorite-articles.input.ts
index fb2e8cdf..2ea717a4 100644
--- a/@generated/user/user-update-with-where-unique-without-favorite-articles.input.ts
+++ b/@generated/user/user-update-with-where-unique-without-favorite-articles.input.ts
@@ -1,17 +1,18 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 import { Type } from 'class-transformer';
 import { UserUpdateWithoutFavoriteArticlesInput } from './user-update-without-favorite-articles.input';
 
 @InputType()
 export class UserUpdateWithWhereUniqueWithoutFavoriteArticlesInput {
-  @Field(() => UserWhereUniqueInput, { nullable: false })
-  @Type(() => UserWhereUniqueInput)
-  where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
 
-  @Field(() => UserUpdateWithoutFavoriteArticlesInput, { nullable: false })
-  @Type(() => UserUpdateWithoutFavoriteArticlesInput)
-  data!: UserUpdateWithoutFavoriteArticlesInput;
+    @Field(() => UserWhereUniqueInput, {nullable:false})
+    @Type(() => UserWhereUniqueInput)
+    where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
+
+    @Field(() => UserUpdateWithoutFavoriteArticlesInput, {nullable:false})
+    @Type(() => UserUpdateWithoutFavoriteArticlesInput)
+    data!: UserUpdateWithoutFavoriteArticlesInput;
 }
diff --git a/@generated/user/user-update-with-where-unique-without-followers.input.ts b/@generated/user/user-update-with-where-unique-without-followers.input.ts
index bb63ca5b..952b335e 100644
--- a/@generated/user/user-update-with-where-unique-without-followers.input.ts
+++ b/@generated/user/user-update-with-where-unique-without-followers.input.ts
@@ -1,17 +1,18 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 import { Type } from 'class-transformer';
 import { UserUpdateWithoutFollowersInput } from './user-update-without-followers.input';
 
 @InputType()
 export class UserUpdateWithWhereUniqueWithoutFollowersInput {
-  @Field(() => UserWhereUniqueInput, { nullable: false })
-  @Type(() => UserWhereUniqueInput)
-  where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
 
-  @Field(() => UserUpdateWithoutFollowersInput, { nullable: false })
-  @Type(() => UserUpdateWithoutFollowersInput)
-  data!: UserUpdateWithoutFollowersInput;
+    @Field(() => UserWhereUniqueInput, {nullable:false})
+    @Type(() => UserWhereUniqueInput)
+    where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
+
+    @Field(() => UserUpdateWithoutFollowersInput, {nullable:false})
+    @Type(() => UserUpdateWithoutFollowersInput)
+    data!: UserUpdateWithoutFollowersInput;
 }
diff --git a/@generated/user/user-update-with-where-unique-without-following.input.ts b/@generated/user/user-update-with-where-unique-without-following.input.ts
index d349ce22..cd6059c9 100644
--- a/@generated/user/user-update-with-where-unique-without-following.input.ts
+++ b/@generated/user/user-update-with-where-unique-without-following.input.ts
@@ -1,17 +1,18 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 import { Type } from 'class-transformer';
 import { UserUpdateWithoutFollowingInput } from './user-update-without-following.input';
 
 @InputType()
 export class UserUpdateWithWhereUniqueWithoutFollowingInput {
-  @Field(() => UserWhereUniqueInput, { nullable: false })
-  @Type(() => UserWhereUniqueInput)
-  where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
 
-  @Field(() => UserUpdateWithoutFollowingInput, { nullable: false })
-  @Type(() => UserUpdateWithoutFollowingInput)
-  data!: UserUpdateWithoutFollowingInput;
+    @Field(() => UserWhereUniqueInput, {nullable:false})
+    @Type(() => UserWhereUniqueInput)
+    where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
+
+    @Field(() => UserUpdateWithoutFollowingInput, {nullable:false})
+    @Type(() => UserUpdateWithoutFollowingInput)
+    data!: UserUpdateWithoutFollowingInput;
 }
diff --git a/@generated/user/user-update-without-articles.input.ts b/@generated/user/user-update-without-articles.input.ts
index db2b9835..f1a1ab43 100644
--- a/@generated/user/user-update-without-articles.input.ts
+++ b/@generated/user/user-update-without-articles.input.ts
@@ -15,54 +15,55 @@ import { ProfileUpdateOneWithoutUserNestedInput } from '../profile/profile-updat
 
 @InputType()
 export class UserUpdateWithoutArticlesInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  email?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  name?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    email?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  password?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    name?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  bio?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    password?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  image?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    bio?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableIntFieldUpdateOperationsInput, { nullable: true })
-  countComments?: NullableIntFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    image?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableFloatFieldUpdateOperationsInput, { nullable: true })
-  rating?: NullableFloatFieldUpdateOperationsInput;
+    @Field(() => NullableIntFieldUpdateOperationsInput, {nullable:true})
+    countComments?: NullableIntFieldUpdateOperationsInput;
 
-  @Field(() => NullableDecimalFieldUpdateOperationsInput, { nullable: true })
-  @Type(() => NullableDecimalFieldUpdateOperationsInput)
-  money?: NullableDecimalFieldUpdateOperationsInput;
+    @Field(() => NullableFloatFieldUpdateOperationsInput, {nullable:true})
+    rating?: NullableFloatFieldUpdateOperationsInput;
 
-  @Field(() => NullableEnumRoleFieldUpdateOperationsInput, { nullable: true })
-  role?: NullableEnumRoleFieldUpdateOperationsInput;
+    @Field(() => NullableDecimalFieldUpdateOperationsInput, {nullable:true})
+    @Type(() => NullableDecimalFieldUpdateOperationsInput)
+    money?: NullableDecimalFieldUpdateOperationsInput;
 
-  @Field(() => UserUpdateManyWithoutFollowersNestedInput, { nullable: true })
-  @Type(() => UserUpdateManyWithoutFollowersNestedInput)
-  following?: UserUpdateManyWithoutFollowersNestedInput;
+    @Field(() => NullableEnumRoleFieldUpdateOperationsInput, {nullable:true})
+    role?: NullableEnumRoleFieldUpdateOperationsInput;
 
-  @Field(() => UserUpdateManyWithoutFollowingNestedInput, { nullable: true })
-  @Type(() => UserUpdateManyWithoutFollowingNestedInput)
-  followers?: UserUpdateManyWithoutFollowingNestedInput;
+    @Field(() => UserUpdateManyWithoutFollowersNestedInput, {nullable:true})
+    @Type(() => UserUpdateManyWithoutFollowersNestedInput)
+    following?: UserUpdateManyWithoutFollowersNestedInput;
 
-  @Field(() => ArticleUpdateManyWithoutFavoritedByNestedInput, { nullable: true })
-  @Type(() => ArticleUpdateManyWithoutFavoritedByNestedInput)
-  favoriteArticles?: ArticleUpdateManyWithoutFavoritedByNestedInput;
+    @Field(() => UserUpdateManyWithoutFollowingNestedInput, {nullable:true})
+    @Type(() => UserUpdateManyWithoutFollowingNestedInput)
+    followers?: UserUpdateManyWithoutFollowingNestedInput;
 
-  @Field(() => CommentUpdateManyWithoutAuthorNestedInput, { nullable: true })
-  @Type(() => CommentUpdateManyWithoutAuthorNestedInput)
-  comments?: CommentUpdateManyWithoutAuthorNestedInput;
+    @Field(() => ArticleUpdateManyWithoutFavoritedByNestedInput, {nullable:true})
+    @Type(() => ArticleUpdateManyWithoutFavoritedByNestedInput)
+    favoriteArticles?: ArticleUpdateManyWithoutFavoritedByNestedInput;
 
-  @Field(() => ProfileUpdateOneWithoutUserNestedInput, { nullable: true })
-  @Type(() => ProfileUpdateOneWithoutUserNestedInput)
-  profile?: ProfileUpdateOneWithoutUserNestedInput;
+    @Field(() => CommentUpdateManyWithoutAuthorNestedInput, {nullable:true})
+    @Type(() => CommentUpdateManyWithoutAuthorNestedInput)
+    comments?: CommentUpdateManyWithoutAuthorNestedInput;
+
+    @Field(() => ProfileUpdateOneWithoutUserNestedInput, {nullable:true})
+    @Type(() => ProfileUpdateOneWithoutUserNestedInput)
+    profile?: ProfileUpdateOneWithoutUserNestedInput;
 }
diff --git a/@generated/user/user-update-without-comments.input.ts b/@generated/user/user-update-without-comments.input.ts
index f68ca659..56a61796 100644
--- a/@generated/user/user-update-without-comments.input.ts
+++ b/@generated/user/user-update-without-comments.input.ts
@@ -15,54 +15,55 @@ import { ProfileUpdateOneWithoutUserNestedInput } from '../profile/profile-updat
 
 @InputType()
 export class UserUpdateWithoutCommentsInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  email?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  name?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    email?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  password?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    name?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  bio?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    password?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  image?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    bio?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableIntFieldUpdateOperationsInput, { nullable: true })
-  countComments?: NullableIntFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    image?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableFloatFieldUpdateOperationsInput, { nullable: true })
-  rating?: NullableFloatFieldUpdateOperationsInput;
+    @Field(() => NullableIntFieldUpdateOperationsInput, {nullable:true})
+    countComments?: NullableIntFieldUpdateOperationsInput;
 
-  @Field(() => NullableDecimalFieldUpdateOperationsInput, { nullable: true })
-  @Type(() => NullableDecimalFieldUpdateOperationsInput)
-  money?: NullableDecimalFieldUpdateOperationsInput;
+    @Field(() => NullableFloatFieldUpdateOperationsInput, {nullable:true})
+    rating?: NullableFloatFieldUpdateOperationsInput;
 
-  @Field(() => NullableEnumRoleFieldUpdateOperationsInput, { nullable: true })
-  role?: NullableEnumRoleFieldUpdateOperationsInput;
+    @Field(() => NullableDecimalFieldUpdateOperationsInput, {nullable:true})
+    @Type(() => NullableDecimalFieldUpdateOperationsInput)
+    money?: NullableDecimalFieldUpdateOperationsInput;
 
-  @Field(() => UserUpdateManyWithoutFollowersNestedInput, { nullable: true })
-  @Type(() => UserUpdateManyWithoutFollowersNestedInput)
-  following?: UserUpdateManyWithoutFollowersNestedInput;
+    @Field(() => NullableEnumRoleFieldUpdateOperationsInput, {nullable:true})
+    role?: NullableEnumRoleFieldUpdateOperationsInput;
 
-  @Field(() => UserUpdateManyWithoutFollowingNestedInput, { nullable: true })
-  @Type(() => UserUpdateManyWithoutFollowingNestedInput)
-  followers?: UserUpdateManyWithoutFollowingNestedInput;
+    @Field(() => UserUpdateManyWithoutFollowersNestedInput, {nullable:true})
+    @Type(() => UserUpdateManyWithoutFollowersNestedInput)
+    following?: UserUpdateManyWithoutFollowersNestedInput;
 
-  @Field(() => ArticleUpdateManyWithoutFavoritedByNestedInput, { nullable: true })
-  @Type(() => ArticleUpdateManyWithoutFavoritedByNestedInput)
-  favoriteArticles?: ArticleUpdateManyWithoutFavoritedByNestedInput;
+    @Field(() => UserUpdateManyWithoutFollowingNestedInput, {nullable:true})
+    @Type(() => UserUpdateManyWithoutFollowingNestedInput)
+    followers?: UserUpdateManyWithoutFollowingNestedInput;
 
-  @Field(() => ArticleUpdateManyWithoutAuthorNestedInput, { nullable: true })
-  @Type(() => ArticleUpdateManyWithoutAuthorNestedInput)
-  articles?: ArticleUpdateManyWithoutAuthorNestedInput;
+    @Field(() => ArticleUpdateManyWithoutFavoritedByNestedInput, {nullable:true})
+    @Type(() => ArticleUpdateManyWithoutFavoritedByNestedInput)
+    favoriteArticles?: ArticleUpdateManyWithoutFavoritedByNestedInput;
 
-  @Field(() => ProfileUpdateOneWithoutUserNestedInput, { nullable: true })
-  @Type(() => ProfileUpdateOneWithoutUserNestedInput)
-  profile?: ProfileUpdateOneWithoutUserNestedInput;
+    @Field(() => ArticleUpdateManyWithoutAuthorNestedInput, {nullable:true})
+    @Type(() => ArticleUpdateManyWithoutAuthorNestedInput)
+    articles?: ArticleUpdateManyWithoutAuthorNestedInput;
+
+    @Field(() => ProfileUpdateOneWithoutUserNestedInput, {nullable:true})
+    @Type(() => ProfileUpdateOneWithoutUserNestedInput)
+    profile?: ProfileUpdateOneWithoutUserNestedInput;
 }
diff --git a/@generated/user/user-update-without-favorite-articles.input.ts b/@generated/user/user-update-without-favorite-articles.input.ts
index 12cf924c..5e19c785 100644
--- a/@generated/user/user-update-without-favorite-articles.input.ts
+++ b/@generated/user/user-update-without-favorite-articles.input.ts
@@ -15,54 +15,55 @@ import { ProfileUpdateOneWithoutUserNestedInput } from '../profile/profile-updat
 
 @InputType()
 export class UserUpdateWithoutFavoriteArticlesInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  email?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  name?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    email?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  password?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    name?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  bio?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    password?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  image?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    bio?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableIntFieldUpdateOperationsInput, { nullable: true })
-  countComments?: NullableIntFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    image?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableFloatFieldUpdateOperationsInput, { nullable: true })
-  rating?: NullableFloatFieldUpdateOperationsInput;
+    @Field(() => NullableIntFieldUpdateOperationsInput, {nullable:true})
+    countComments?: NullableIntFieldUpdateOperationsInput;
 
-  @Field(() => NullableDecimalFieldUpdateOperationsInput, { nullable: true })
-  @Type(() => NullableDecimalFieldUpdateOperationsInput)
-  money?: NullableDecimalFieldUpdateOperationsInput;
+    @Field(() => NullableFloatFieldUpdateOperationsInput, {nullable:true})
+    rating?: NullableFloatFieldUpdateOperationsInput;
 
-  @Field(() => NullableEnumRoleFieldUpdateOperationsInput, { nullable: true })
-  role?: NullableEnumRoleFieldUpdateOperationsInput;
+    @Field(() => NullableDecimalFieldUpdateOperationsInput, {nullable:true})
+    @Type(() => NullableDecimalFieldUpdateOperationsInput)
+    money?: NullableDecimalFieldUpdateOperationsInput;
 
-  @Field(() => UserUpdateManyWithoutFollowersNestedInput, { nullable: true })
-  @Type(() => UserUpdateManyWithoutFollowersNestedInput)
-  following?: UserUpdateManyWithoutFollowersNestedInput;
+    @Field(() => NullableEnumRoleFieldUpdateOperationsInput, {nullable:true})
+    role?: NullableEnumRoleFieldUpdateOperationsInput;
 
-  @Field(() => UserUpdateManyWithoutFollowingNestedInput, { nullable: true })
-  @Type(() => UserUpdateManyWithoutFollowingNestedInput)
-  followers?: UserUpdateManyWithoutFollowingNestedInput;
+    @Field(() => UserUpdateManyWithoutFollowersNestedInput, {nullable:true})
+    @Type(() => UserUpdateManyWithoutFollowersNestedInput)
+    following?: UserUpdateManyWithoutFollowersNestedInput;
 
-  @Field(() => ArticleUpdateManyWithoutAuthorNestedInput, { nullable: true })
-  @Type(() => ArticleUpdateManyWithoutAuthorNestedInput)
-  articles?: ArticleUpdateManyWithoutAuthorNestedInput;
+    @Field(() => UserUpdateManyWithoutFollowingNestedInput, {nullable:true})
+    @Type(() => UserUpdateManyWithoutFollowingNestedInput)
+    followers?: UserUpdateManyWithoutFollowingNestedInput;
 
-  @Field(() => CommentUpdateManyWithoutAuthorNestedInput, { nullable: true })
-  @Type(() => CommentUpdateManyWithoutAuthorNestedInput)
-  comments?: CommentUpdateManyWithoutAuthorNestedInput;
+    @Field(() => ArticleUpdateManyWithoutAuthorNestedInput, {nullable:true})
+    @Type(() => ArticleUpdateManyWithoutAuthorNestedInput)
+    articles?: ArticleUpdateManyWithoutAuthorNestedInput;
 
-  @Field(() => ProfileUpdateOneWithoutUserNestedInput, { nullable: true })
-  @Type(() => ProfileUpdateOneWithoutUserNestedInput)
-  profile?: ProfileUpdateOneWithoutUserNestedInput;
+    @Field(() => CommentUpdateManyWithoutAuthorNestedInput, {nullable:true})
+    @Type(() => CommentUpdateManyWithoutAuthorNestedInput)
+    comments?: CommentUpdateManyWithoutAuthorNestedInput;
+
+    @Field(() => ProfileUpdateOneWithoutUserNestedInput, {nullable:true})
+    @Type(() => ProfileUpdateOneWithoutUserNestedInput)
+    profile?: ProfileUpdateOneWithoutUserNestedInput;
 }
diff --git a/@generated/user/user-update-without-followers.input.ts b/@generated/user/user-update-without-followers.input.ts
index 17fbc572..c5555273 100644
--- a/@generated/user/user-update-without-followers.input.ts
+++ b/@generated/user/user-update-without-followers.input.ts
@@ -15,54 +15,55 @@ import { ProfileUpdateOneWithoutUserNestedInput } from '../profile/profile-updat
 
 @InputType()
 export class UserUpdateWithoutFollowersInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  email?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  name?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    email?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  password?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    name?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  bio?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    password?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  image?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    bio?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableIntFieldUpdateOperationsInput, { nullable: true })
-  countComments?: NullableIntFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    image?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableFloatFieldUpdateOperationsInput, { nullable: true })
-  rating?: NullableFloatFieldUpdateOperationsInput;
+    @Field(() => NullableIntFieldUpdateOperationsInput, {nullable:true})
+    countComments?: NullableIntFieldUpdateOperationsInput;
 
-  @Field(() => NullableDecimalFieldUpdateOperationsInput, { nullable: true })
-  @Type(() => NullableDecimalFieldUpdateOperationsInput)
-  money?: NullableDecimalFieldUpdateOperationsInput;
+    @Field(() => NullableFloatFieldUpdateOperationsInput, {nullable:true})
+    rating?: NullableFloatFieldUpdateOperationsInput;
 
-  @Field(() => NullableEnumRoleFieldUpdateOperationsInput, { nullable: true })
-  role?: NullableEnumRoleFieldUpdateOperationsInput;
+    @Field(() => NullableDecimalFieldUpdateOperationsInput, {nullable:true})
+    @Type(() => NullableDecimalFieldUpdateOperationsInput)
+    money?: NullableDecimalFieldUpdateOperationsInput;
 
-  @Field(() => UserUpdateManyWithoutFollowersNestedInput, { nullable: true })
-  @Type(() => UserUpdateManyWithoutFollowersNestedInput)
-  following?: UserUpdateManyWithoutFollowersNestedInput;
+    @Field(() => NullableEnumRoleFieldUpdateOperationsInput, {nullable:true})
+    role?: NullableEnumRoleFieldUpdateOperationsInput;
 
-  @Field(() => ArticleUpdateManyWithoutFavoritedByNestedInput, { nullable: true })
-  @Type(() => ArticleUpdateManyWithoutFavoritedByNestedInput)
-  favoriteArticles?: ArticleUpdateManyWithoutFavoritedByNestedInput;
+    @Field(() => UserUpdateManyWithoutFollowersNestedInput, {nullable:true})
+    @Type(() => UserUpdateManyWithoutFollowersNestedInput)
+    following?: UserUpdateManyWithoutFollowersNestedInput;
 
-  @Field(() => ArticleUpdateManyWithoutAuthorNestedInput, { nullable: true })
-  @Type(() => ArticleUpdateManyWithoutAuthorNestedInput)
-  articles?: ArticleUpdateManyWithoutAuthorNestedInput;
+    @Field(() => ArticleUpdateManyWithoutFavoritedByNestedInput, {nullable:true})
+    @Type(() => ArticleUpdateManyWithoutFavoritedByNestedInput)
+    favoriteArticles?: ArticleUpdateManyWithoutFavoritedByNestedInput;
 
-  @Field(() => CommentUpdateManyWithoutAuthorNestedInput, { nullable: true })
-  @Type(() => CommentUpdateManyWithoutAuthorNestedInput)
-  comments?: CommentUpdateManyWithoutAuthorNestedInput;
+    @Field(() => ArticleUpdateManyWithoutAuthorNestedInput, {nullable:true})
+    @Type(() => ArticleUpdateManyWithoutAuthorNestedInput)
+    articles?: ArticleUpdateManyWithoutAuthorNestedInput;
 
-  @Field(() => ProfileUpdateOneWithoutUserNestedInput, { nullable: true })
-  @Type(() => ProfileUpdateOneWithoutUserNestedInput)
-  profile?: ProfileUpdateOneWithoutUserNestedInput;
+    @Field(() => CommentUpdateManyWithoutAuthorNestedInput, {nullable:true})
+    @Type(() => CommentUpdateManyWithoutAuthorNestedInput)
+    comments?: CommentUpdateManyWithoutAuthorNestedInput;
+
+    @Field(() => ProfileUpdateOneWithoutUserNestedInput, {nullable:true})
+    @Type(() => ProfileUpdateOneWithoutUserNestedInput)
+    profile?: ProfileUpdateOneWithoutUserNestedInput;
 }
diff --git a/@generated/user/user-update-without-following.input.ts b/@generated/user/user-update-without-following.input.ts
index 52d34a4c..b9462bf1 100644
--- a/@generated/user/user-update-without-following.input.ts
+++ b/@generated/user/user-update-without-following.input.ts
@@ -15,54 +15,55 @@ import { ProfileUpdateOneWithoutUserNestedInput } from '../profile/profile-updat
 
 @InputType()
 export class UserUpdateWithoutFollowingInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  email?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  name?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    email?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  password?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    name?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  bio?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    password?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  image?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    bio?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableIntFieldUpdateOperationsInput, { nullable: true })
-  countComments?: NullableIntFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    image?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableFloatFieldUpdateOperationsInput, { nullable: true })
-  rating?: NullableFloatFieldUpdateOperationsInput;
+    @Field(() => NullableIntFieldUpdateOperationsInput, {nullable:true})
+    countComments?: NullableIntFieldUpdateOperationsInput;
 
-  @Field(() => NullableDecimalFieldUpdateOperationsInput, { nullable: true })
-  @Type(() => NullableDecimalFieldUpdateOperationsInput)
-  money?: NullableDecimalFieldUpdateOperationsInput;
+    @Field(() => NullableFloatFieldUpdateOperationsInput, {nullable:true})
+    rating?: NullableFloatFieldUpdateOperationsInput;
 
-  @Field(() => NullableEnumRoleFieldUpdateOperationsInput, { nullable: true })
-  role?: NullableEnumRoleFieldUpdateOperationsInput;
+    @Field(() => NullableDecimalFieldUpdateOperationsInput, {nullable:true})
+    @Type(() => NullableDecimalFieldUpdateOperationsInput)
+    money?: NullableDecimalFieldUpdateOperationsInput;
 
-  @Field(() => UserUpdateManyWithoutFollowingNestedInput, { nullable: true })
-  @Type(() => UserUpdateManyWithoutFollowingNestedInput)
-  followers?: UserUpdateManyWithoutFollowingNestedInput;
+    @Field(() => NullableEnumRoleFieldUpdateOperationsInput, {nullable:true})
+    role?: NullableEnumRoleFieldUpdateOperationsInput;
 
-  @Field(() => ArticleUpdateManyWithoutFavoritedByNestedInput, { nullable: true })
-  @Type(() => ArticleUpdateManyWithoutFavoritedByNestedInput)
-  favoriteArticles?: ArticleUpdateManyWithoutFavoritedByNestedInput;
+    @Field(() => UserUpdateManyWithoutFollowingNestedInput, {nullable:true})
+    @Type(() => UserUpdateManyWithoutFollowingNestedInput)
+    followers?: UserUpdateManyWithoutFollowingNestedInput;
 
-  @Field(() => ArticleUpdateManyWithoutAuthorNestedInput, { nullable: true })
-  @Type(() => ArticleUpdateManyWithoutAuthorNestedInput)
-  articles?: ArticleUpdateManyWithoutAuthorNestedInput;
+    @Field(() => ArticleUpdateManyWithoutFavoritedByNestedInput, {nullable:true})
+    @Type(() => ArticleUpdateManyWithoutFavoritedByNestedInput)
+    favoriteArticles?: ArticleUpdateManyWithoutFavoritedByNestedInput;
 
-  @Field(() => CommentUpdateManyWithoutAuthorNestedInput, { nullable: true })
-  @Type(() => CommentUpdateManyWithoutAuthorNestedInput)
-  comments?: CommentUpdateManyWithoutAuthorNestedInput;
+    @Field(() => ArticleUpdateManyWithoutAuthorNestedInput, {nullable:true})
+    @Type(() => ArticleUpdateManyWithoutAuthorNestedInput)
+    articles?: ArticleUpdateManyWithoutAuthorNestedInput;
 
-  @Field(() => ProfileUpdateOneWithoutUserNestedInput, { nullable: true })
-  @Type(() => ProfileUpdateOneWithoutUserNestedInput)
-  profile?: ProfileUpdateOneWithoutUserNestedInput;
+    @Field(() => CommentUpdateManyWithoutAuthorNestedInput, {nullable:true})
+    @Type(() => CommentUpdateManyWithoutAuthorNestedInput)
+    comments?: CommentUpdateManyWithoutAuthorNestedInput;
+
+    @Field(() => ProfileUpdateOneWithoutUserNestedInput, {nullable:true})
+    @Type(() => ProfileUpdateOneWithoutUserNestedInput)
+    profile?: ProfileUpdateOneWithoutUserNestedInput;
 }
diff --git a/@generated/user/user-update-without-profile.input.ts b/@generated/user/user-update-without-profile.input.ts
index e3d69fb6..930e57cd 100644
--- a/@generated/user/user-update-without-profile.input.ts
+++ b/@generated/user/user-update-without-profile.input.ts
@@ -15,54 +15,55 @@ import { CommentUpdateManyWithoutAuthorNestedInput } from '../comment/comment-up
 
 @InputType()
 export class UserUpdateWithoutProfileInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  email?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  name?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    email?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  password?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    name?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  bio?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    password?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  image?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    bio?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableIntFieldUpdateOperationsInput, { nullable: true })
-  countComments?: NullableIntFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    image?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableFloatFieldUpdateOperationsInput, { nullable: true })
-  rating?: NullableFloatFieldUpdateOperationsInput;
+    @Field(() => NullableIntFieldUpdateOperationsInput, {nullable:true})
+    countComments?: NullableIntFieldUpdateOperationsInput;
 
-  @Field(() => NullableDecimalFieldUpdateOperationsInput, { nullable: true })
-  @Type(() => NullableDecimalFieldUpdateOperationsInput)
-  money?: NullableDecimalFieldUpdateOperationsInput;
+    @Field(() => NullableFloatFieldUpdateOperationsInput, {nullable:true})
+    rating?: NullableFloatFieldUpdateOperationsInput;
 
-  @Field(() => NullableEnumRoleFieldUpdateOperationsInput, { nullable: true })
-  role?: NullableEnumRoleFieldUpdateOperationsInput;
+    @Field(() => NullableDecimalFieldUpdateOperationsInput, {nullable:true})
+    @Type(() => NullableDecimalFieldUpdateOperationsInput)
+    money?: NullableDecimalFieldUpdateOperationsInput;
 
-  @Field(() => UserUpdateManyWithoutFollowersNestedInput, { nullable: true })
-  @Type(() => UserUpdateManyWithoutFollowersNestedInput)
-  following?: UserUpdateManyWithoutFollowersNestedInput;
+    @Field(() => NullableEnumRoleFieldUpdateOperationsInput, {nullable:true})
+    role?: NullableEnumRoleFieldUpdateOperationsInput;
 
-  @Field(() => UserUpdateManyWithoutFollowingNestedInput, { nullable: true })
-  @Type(() => UserUpdateManyWithoutFollowingNestedInput)
-  followers?: UserUpdateManyWithoutFollowingNestedInput;
+    @Field(() => UserUpdateManyWithoutFollowersNestedInput, {nullable:true})
+    @Type(() => UserUpdateManyWithoutFollowersNestedInput)
+    following?: UserUpdateManyWithoutFollowersNestedInput;
 
-  @Field(() => ArticleUpdateManyWithoutFavoritedByNestedInput, { nullable: true })
-  @Type(() => ArticleUpdateManyWithoutFavoritedByNestedInput)
-  favoriteArticles?: ArticleUpdateManyWithoutFavoritedByNestedInput;
+    @Field(() => UserUpdateManyWithoutFollowingNestedInput, {nullable:true})
+    @Type(() => UserUpdateManyWithoutFollowingNestedInput)
+    followers?: UserUpdateManyWithoutFollowingNestedInput;
 
-  @Field(() => ArticleUpdateManyWithoutAuthorNestedInput, { nullable: true })
-  @Type(() => ArticleUpdateManyWithoutAuthorNestedInput)
-  articles?: ArticleUpdateManyWithoutAuthorNestedInput;
+    @Field(() => ArticleUpdateManyWithoutFavoritedByNestedInput, {nullable:true})
+    @Type(() => ArticleUpdateManyWithoutFavoritedByNestedInput)
+    favoriteArticles?: ArticleUpdateManyWithoutFavoritedByNestedInput;
 
-  @Field(() => CommentUpdateManyWithoutAuthorNestedInput, { nullable: true })
-  @Type(() => CommentUpdateManyWithoutAuthorNestedInput)
-  comments?: CommentUpdateManyWithoutAuthorNestedInput;
+    @Field(() => ArticleUpdateManyWithoutAuthorNestedInput, {nullable:true})
+    @Type(() => ArticleUpdateManyWithoutAuthorNestedInput)
+    articles?: ArticleUpdateManyWithoutAuthorNestedInput;
+
+    @Field(() => CommentUpdateManyWithoutAuthorNestedInput, {nullable:true})
+    @Type(() => CommentUpdateManyWithoutAuthorNestedInput)
+    comments?: CommentUpdateManyWithoutAuthorNestedInput;
 }
diff --git a/@generated/user/user-update.input.ts b/@generated/user/user-update.input.ts
index d0aa12f3..8102fcdf 100644
--- a/@generated/user/user-update.input.ts
+++ b/@generated/user/user-update.input.ts
@@ -16,58 +16,59 @@ import { ProfileUpdateOneWithoutUserNestedInput } from '../profile/profile-updat
 
 @InputType()
 export class UserUpdateInput {
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  email?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    id?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  name?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    email?: StringFieldUpdateOperationsInput;
 
-  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
-  password?: StringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    name?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  bio?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
+    password?: StringFieldUpdateOperationsInput;
 
-  @Field(() => NullableStringFieldUpdateOperationsInput, { nullable: true })
-  image?: NullableStringFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    bio?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableIntFieldUpdateOperationsInput, { nullable: true })
-  countComments?: NullableIntFieldUpdateOperationsInput;
+    @Field(() => NullableStringFieldUpdateOperationsInput, {nullable:true})
+    image?: NullableStringFieldUpdateOperationsInput;
 
-  @Field(() => NullableFloatFieldUpdateOperationsInput, { nullable: true })
-  rating?: NullableFloatFieldUpdateOperationsInput;
+    @Field(() => NullableIntFieldUpdateOperationsInput, {nullable:true})
+    countComments?: NullableIntFieldUpdateOperationsInput;
 
-  @Field(() => NullableDecimalFieldUpdateOperationsInput, { nullable: true })
-  @Type(() => NullableDecimalFieldUpdateOperationsInput)
-  money?: NullableDecimalFieldUpdateOperationsInput;
+    @Field(() => NullableFloatFieldUpdateOperationsInput, {nullable:true})
+    rating?: NullableFloatFieldUpdateOperationsInput;
 
-  @Field(() => NullableEnumRoleFieldUpdateOperationsInput, { nullable: true })
-  role?: NullableEnumRoleFieldUpdateOperationsInput;
+    @Field(() => NullableDecimalFieldUpdateOperationsInput, {nullable:true})
+    @Type(() => NullableDecimalFieldUpdateOperationsInput)
+    money?: NullableDecimalFieldUpdateOperationsInput;
 
-  @Field(() => UserUpdateManyWithoutFollowersNestedInput, { nullable: true })
-  @Type(() => UserUpdateManyWithoutFollowersNestedInput)
-  following?: UserUpdateManyWithoutFollowersNestedInput;
+    @Field(() => NullableEnumRoleFieldUpdateOperationsInput, {nullable:true})
+    role?: NullableEnumRoleFieldUpdateOperationsInput;
 
-  @Field(() => UserUpdateManyWithoutFollowingNestedInput, { nullable: true })
-  @Type(() => UserUpdateManyWithoutFollowingNestedInput)
-  followers?: UserUpdateManyWithoutFollowingNestedInput;
+    @Field(() => UserUpdateManyWithoutFollowersNestedInput, {nullable:true})
+    @Type(() => UserUpdateManyWithoutFollowersNestedInput)
+    following?: UserUpdateManyWithoutFollowersNestedInput;
 
-  @Field(() => ArticleUpdateManyWithoutFavoritedByNestedInput, { nullable: true })
-  @Type(() => ArticleUpdateManyWithoutFavoritedByNestedInput)
-  favoriteArticles?: ArticleUpdateManyWithoutFavoritedByNestedInput;
+    @Field(() => UserUpdateManyWithoutFollowingNestedInput, {nullable:true})
+    @Type(() => UserUpdateManyWithoutFollowingNestedInput)
+    followers?: UserUpdateManyWithoutFollowingNestedInput;
 
-  @Field(() => ArticleUpdateManyWithoutAuthorNestedInput, { nullable: true })
-  @Type(() => ArticleUpdateManyWithoutAuthorNestedInput)
-  articles?: ArticleUpdateManyWithoutAuthorNestedInput;
+    @Field(() => ArticleUpdateManyWithoutFavoritedByNestedInput, {nullable:true})
+    @Type(() => ArticleUpdateManyWithoutFavoritedByNestedInput)
+    favoriteArticles?: ArticleUpdateManyWithoutFavoritedByNestedInput;
 
-  @Field(() => CommentUpdateManyWithoutAuthorNestedInput, { nullable: true })
-  @Type(() => CommentUpdateManyWithoutAuthorNestedInput)
-  comments?: CommentUpdateManyWithoutAuthorNestedInput;
+    @Field(() => ArticleUpdateManyWithoutAuthorNestedInput, {nullable:true})
+    @Type(() => ArticleUpdateManyWithoutAuthorNestedInput)
+    articles?: ArticleUpdateManyWithoutAuthorNestedInput;
 
-  @Field(() => ProfileUpdateOneWithoutUserNestedInput, { nullable: true })
-  @Type(() => ProfileUpdateOneWithoutUserNestedInput)
-  profile?: ProfileUpdateOneWithoutUserNestedInput;
+    @Field(() => CommentUpdateManyWithoutAuthorNestedInput, {nullable:true})
+    @Type(() => CommentUpdateManyWithoutAuthorNestedInput)
+    comments?: CommentUpdateManyWithoutAuthorNestedInput;
+
+    @Field(() => ProfileUpdateOneWithoutUserNestedInput, {nullable:true})
+    @Type(() => ProfileUpdateOneWithoutUserNestedInput)
+    profile?: ProfileUpdateOneWithoutUserNestedInput;
 }
diff --git a/@generated/user/user-upsert-with-where-unique-without-favorite-articles.input.ts b/@generated/user/user-upsert-with-where-unique-without-favorite-articles.input.ts
index 62e266eb..f6272626 100644
--- a/@generated/user/user-upsert-with-where-unique-without-favorite-articles.input.ts
+++ b/@generated/user/user-upsert-with-where-unique-without-favorite-articles.input.ts
@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 import { Type } from 'class-transformer';
 import { UserUpdateWithoutFavoriteArticlesInput } from './user-update-without-favorite-articles.input';
@@ -8,15 +8,16 @@ import { UserCreateWithoutFavoriteArticlesInput } from './user-create-without-fa
 
 @InputType()
 export class UserUpsertWithWhereUniqueWithoutFavoriteArticlesInput {
-  @Field(() => UserWhereUniqueInput, { nullable: false })
-  @Type(() => UserWhereUniqueInput)
-  where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
 
-  @Field(() => UserUpdateWithoutFavoriteArticlesInput, { nullable: false })
-  @Type(() => UserUpdateWithoutFavoriteArticlesInput)
-  update!: UserUpdateWithoutFavoriteArticlesInput;
+    @Field(() => UserWhereUniqueInput, {nullable:false})
+    @Type(() => UserWhereUniqueInput)
+    where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
 
-  @Field(() => UserCreateWithoutFavoriteArticlesInput, { nullable: false })
-  @Type(() => UserCreateWithoutFavoriteArticlesInput)
-  create!: UserCreateWithoutFavoriteArticlesInput;
+    @Field(() => UserUpdateWithoutFavoriteArticlesInput, {nullable:false})
+    @Type(() => UserUpdateWithoutFavoriteArticlesInput)
+    update!: UserUpdateWithoutFavoriteArticlesInput;
+
+    @Field(() => UserCreateWithoutFavoriteArticlesInput, {nullable:false})
+    @Type(() => UserCreateWithoutFavoriteArticlesInput)
+    create!: UserCreateWithoutFavoriteArticlesInput;
 }
diff --git a/@generated/user/user-upsert-with-where-unique-without-followers.input.ts b/@generated/user/user-upsert-with-where-unique-without-followers.input.ts
index 011350ab..45778b0a 100644
--- a/@generated/user/user-upsert-with-where-unique-without-followers.input.ts
+++ b/@generated/user/user-upsert-with-where-unique-without-followers.input.ts
@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 import { Type } from 'class-transformer';
 import { UserUpdateWithoutFollowersInput } from './user-update-without-followers.input';
@@ -8,15 +8,16 @@ import { UserCreateWithoutFollowersInput } from './user-create-without-followers
 
 @InputType()
 export class UserUpsertWithWhereUniqueWithoutFollowersInput {
-  @Field(() => UserWhereUniqueInput, { nullable: false })
-  @Type(() => UserWhereUniqueInput)
-  where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
 
-  @Field(() => UserUpdateWithoutFollowersInput, { nullable: false })
-  @Type(() => UserUpdateWithoutFollowersInput)
-  update!: UserUpdateWithoutFollowersInput;
+    @Field(() => UserWhereUniqueInput, {nullable:false})
+    @Type(() => UserWhereUniqueInput)
+    where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
 
-  @Field(() => UserCreateWithoutFollowersInput, { nullable: false })
-  @Type(() => UserCreateWithoutFollowersInput)
-  create!: UserCreateWithoutFollowersInput;
+    @Field(() => UserUpdateWithoutFollowersInput, {nullable:false})
+    @Type(() => UserUpdateWithoutFollowersInput)
+    update!: UserUpdateWithoutFollowersInput;
+
+    @Field(() => UserCreateWithoutFollowersInput, {nullable:false})
+    @Type(() => UserCreateWithoutFollowersInput)
+    create!: UserCreateWithoutFollowersInput;
 }
diff --git a/@generated/user/user-upsert-with-where-unique-without-following.input.ts b/@generated/user/user-upsert-with-where-unique-without-following.input.ts
index 818b2767..1b26e810 100644
--- a/@generated/user/user-upsert-with-where-unique-without-following.input.ts
+++ b/@generated/user/user-upsert-with-where-unique-without-following.input.ts
@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { Prisma } from '@prisma/client';
+import { Prisma } from '../../prisma-client';
 import { UserWhereUniqueInput } from './user-where-unique.input';
 import { Type } from 'class-transformer';
 import { UserUpdateWithoutFollowingInput } from './user-update-without-following.input';
@@ -8,15 +8,16 @@ import { UserCreateWithoutFollowingInput } from './user-create-without-following
 
 @InputType()
 export class UserUpsertWithWhereUniqueWithoutFollowingInput {
-  @Field(() => UserWhereUniqueInput, { nullable: false })
-  @Type(() => UserWhereUniqueInput)
-  where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
 
-  @Field(() => UserUpdateWithoutFollowingInput, { nullable: false })
-  @Type(() => UserUpdateWithoutFollowingInput)
-  update!: UserUpdateWithoutFollowingInput;
+    @Field(() => UserWhereUniqueInput, {nullable:false})
+    @Type(() => UserWhereUniqueInput)
+    where!: Prisma.AtLeast<UserWhereUniqueInput, 'id' | 'email' | 'name' | 'email_name'>;
 
-  @Field(() => UserCreateWithoutFollowingInput, { nullable: false })
-  @Type(() => UserCreateWithoutFollowingInput)
-  create!: UserCreateWithoutFollowingInput;
+    @Field(() => UserUpdateWithoutFollowingInput, {nullable:false})
+    @Type(() => UserUpdateWithoutFollowingInput)
+    update!: UserUpdateWithoutFollowingInput;
+
+    @Field(() => UserCreateWithoutFollowingInput, {nullable:false})
+    @Type(() => UserCreateWithoutFollowingInput)
+    create!: UserCreateWithoutFollowingInput;
 }
diff --git a/@generated/user/user-upsert-without-articles.input.ts b/@generated/user/user-upsert-without-articles.input.ts
index c28cfd91..bc4362dc 100644
--- a/@generated/user/user-upsert-without-articles.input.ts
+++ b/@generated/user/user-upsert-without-articles.input.ts
@@ -7,15 +7,16 @@ import { UserWhereInput } from './user-where.input';
 
 @InputType()
 export class UserUpsertWithoutArticlesInput {
-  @Field(() => UserUpdateWithoutArticlesInput, { nullable: false })
-  @Type(() => UserUpdateWithoutArticlesInput)
-  update!: UserUpdateWithoutArticlesInput;
 
-  @Field(() => UserCreateWithoutArticlesInput, { nullable: false })
-  @Type(() => UserCreateWithoutArticlesInput)
-  create!: UserCreateWithoutArticlesInput;
+    @Field(() => UserUpdateWithoutArticlesInput, {nullable:false})
+    @Type(() => UserUpdateWithoutArticlesInput)
+    update!: UserUpdateWithoutArticlesInput;
 
-  @Field(() => UserWhereInput, { nullable: true })
-  @Type(() => UserWhereInput)
-  where?: UserWhereInput;
+    @Field(() => UserCreateWithoutArticlesInput, {nullable:false})
+    @Type(() => UserCreateWithoutArticlesInput)
+    create!: UserCreateWithoutArticlesInput;
+
+    @Field(() => UserWhereInput, {nullable:true})
+    @Type(() => UserWhereInput)
+    where?: UserWhereInput;
 }
diff --git a/@generated/user/user-upsert-without-comments.input.ts b/@generated/user/user-upsert-without-comments.input.ts
index c2308934..b0708655 100644
--- a/@generated/user/user-upsert-without-comments.input.ts
+++ b/@generated/user/user-upsert-without-comments.input.ts
@@ -7,15 +7,16 @@ import { UserWhereInput } from './user-where.input';
 
 @InputType()
 export class UserUpsertWithoutCommentsInput {
-  @Field(() => UserUpdateWithoutCommentsInput, { nullable: false })
-  @Type(() => UserUpdateWithoutCommentsInput)
-  update!: UserUpdateWithoutCommentsInput;
 
-  @Field(() => UserCreateWithoutCommentsInput, { nullable: false })
-  @Type(() => UserCreateWithoutCommentsInput)
-  create!: UserCreateWithoutCommentsInput;
+    @Field(() => UserUpdateWithoutCommentsInput, {nullable:false})
+    @Type(() => UserUpdateWithoutCommentsInput)
+    update!: UserUpdateWithoutCommentsInput;
 
-  @Field(() => UserWhereInput, { nullable: true })
-  @Type(() => UserWhereInput)
-  where?: UserWhereInput;
+    @Field(() => UserCreateWithoutCommentsInput, {nullable:false})
+    @Type(() => UserCreateWithoutCommentsInput)
+    create!: UserCreateWithoutCommentsInput;
+
+    @Field(() => UserWhereInput, {nullable:true})
+    @Type(() => UserWhereInput)
+    where?: UserWhereInput;
 }
diff --git a/@generated/user/user-upsert-without-profile.input.ts b/@generated/user/user-upsert-without-profile.input.ts
index 481e750e..3a8a30f4 100644
--- a/@generated/user/user-upsert-without-profile.input.ts
+++ b/@generated/user/user-upsert-without-profile.input.ts
@@ -7,15 +7,16 @@ import { UserWhereInput } from './user-where.input';
 
 @InputType()
 export class UserUpsertWithoutProfileInput {
-  @Field(() => UserUpdateWithoutProfileInput, { nullable: false })
-  @Type(() => UserUpdateWithoutProfileInput)
-  update!: UserUpdateWithoutProfileInput;
 
-  @Field(() => UserCreateWithoutProfileInput, { nullable: false })
-  @Type(() => UserCreateWithoutProfileInput)
-  create!: UserCreateWithoutProfileInput;
+    @Field(() => UserUpdateWithoutProfileInput, {nullable:false})
+    @Type(() => UserUpdateWithoutProfileInput)
+    update!: UserUpdateWithoutProfileInput;
 
-  @Field(() => UserWhereInput, { nullable: true })
-  @Type(() => UserWhereInput)
-  where?: UserWhereInput;
+    @Field(() => UserCreateWithoutProfileInput, {nullable:false})
+    @Type(() => UserCreateWithoutProfileInput)
+    create!: UserCreateWithoutProfileInput;
+
+    @Field(() => UserWhereInput, {nullable:true})
+    @Type(() => UserWhereInput)
+    where?: UserWhereInput;
 }
diff --git a/@generated/user/user-where-unique.input.ts b/@generated/user/user-where-unique.input.ts
index a644df77..cde70dbe 100644
--- a/@generated/user/user-where-unique.input.ts
+++ b/@generated/user/user-where-unique.input.ts
@@ -18,76 +18,77 @@ import { ProfileNullableRelationFilter } from '../profile/profile-nullable-relat
 
 @InputType()
 export class UserWhereUniqueInput {
-  @Field(() => String, { nullable: true })
-  id?: string;
 
-  @Field(() => Scalars.GraphQLEmailAddress, { nullable: true })
-  email?: string;
+    @Field(() => String, {nullable:true})
+    id?: string;
 
-  @Field(() => String, { nullable: true })
-  @Validator.MinLength(3)
-  @Validator.MaxLength(50)
-  name?: string;
+    @Field(() => Scalars.GraphQLEmailAddress, {nullable:true})
+    email?: string;
 
-  @Field(() => UserEmailNameCompoundUniqueInput, { nullable: true })
-  @Type(() => UserEmailNameCompoundUniqueInput)
-  email_name?: UserEmailNameCompoundUniqueInput;
+    @Field(() => String, {nullable:true})
+    @Validator.MinLength(3)
+    @Validator.MaxLength(50)
+    name?: string;
 
-  @Field(() => [UserWhereInput], { nullable: true })
-  @Type(() => UserWhereInput)
-  AND?: Array<UserWhereInput>;
+    @Field(() => UserEmailNameCompoundUniqueInput, {nullable:true})
+    @Type(() => UserEmailNameCompoundUniqueInput)
+    email_name?: UserEmailNameCompoundUniqueInput;
 
-  @Field(() => [UserWhereInput], { nullable: true })
-  @Type(() => UserWhereInput)
-  OR?: Array<UserWhereInput>;
+    @Field(() => [UserWhereInput], {nullable:true})
+    @Type(() => UserWhereInput)
+    AND?: Array<UserWhereInput>;
 
-  @Field(() => [UserWhereInput], { nullable: true })
-  @Type(() => UserWhereInput)
-  NOT?: Array<UserWhereInput>;
+    @Field(() => [UserWhereInput], {nullable:true})
+    @Type(() => UserWhereInput)
+    OR?: Array<UserWhereInput>;
 
-  @Field(() => StringFilter, { nullable: true })
-  password?: StringFilter;
+    @Field(() => [UserWhereInput], {nullable:true})
+    @Type(() => UserWhereInput)
+    NOT?: Array<UserWhereInput>;
 
-  @Field(() => StringNullableFilter, { nullable: true })
-  bio?: StringNullableFilter;
+    @Field(() => StringFilter, {nullable:true})
+    password?: StringFilter;
 
-  @Field(() => StringNullableFilter, { nullable: true })
-  image?: StringNullableFilter;
+    @Field(() => StringNullableFilter, {nullable:true})
+    bio?: StringNullableFilter;
 
-  @Field(() => IntNullableFilter, { nullable: true })
-  countComments?: IntNullableFilter;
+    @Field(() => StringNullableFilter, {nullable:true})
+    image?: StringNullableFilter;
 
-  @Field(() => FloatNullableFilter, { nullable: true })
-  rating?: FloatNullableFilter;
+    @Field(() => IntNullableFilter, {nullable:true})
+    countComments?: IntNullableFilter;
 
-  @Field(() => DecimalNullableFilter, { nullable: true })
-  @Type(() => DecimalNullableFilter)
-  money?: DecimalNullableFilter;
+    @Field(() => FloatNullableFilter, {nullable:true})
+    rating?: FloatNullableFilter;
 
-  @Field(() => EnumRoleNullableFilter, { nullable: true })
-  role?: EnumRoleNullableFilter;
+    @Field(() => DecimalNullableFilter, {nullable:true})
+    @Type(() => DecimalNullableFilter)
+    money?: DecimalNullableFilter;
 
-  @Field(() => UserListRelationFilter, { nullable: true })
-  @Type(() => UserListRelationFilter)
-  following?: UserListRelationFilter;
+    @Field(() => EnumRoleNullableFilter, {nullable:true})
+    role?: EnumRoleNullableFilter;
 
-  @Field(() => UserListRelationFilter, { nullable: true })
-  @Type(() => UserListRelationFilter)
-  followers?: UserListRelationFilter;
+    @Field(() => UserListRelationFilter, {nullable:true})
+    @Type(() => UserListRelationFilter)
+    following?: UserListRelationFilter;
 
-  @Field(() => ArticleListRelationFilter, { nullable: true })
-  @Type(() => ArticleListRelationFilter)
-  favoriteArticles?: ArticleListRelationFilter;
+    @Field(() => UserListRelationFilter, {nullable:true})
+    @Type(() => UserListRelationFilter)
+    followers?: UserListRelationFilter;
 
-  @Field(() => ArticleListRelationFilter, { nullable: true })
-  @Type(() => ArticleListRelationFilter)
-  articles?: ArticleListRelationFilter;
+    @Field(() => ArticleListRelationFilter, {nullable:true})
+    @Type(() => ArticleListRelationFilter)
+    favoriteArticles?: ArticleListRelationFilter;
 
-  @Field(() => CommentListRelationFilter, { nullable: true })
-  @Type(() => CommentListRelationFilter)
-  comments?: CommentListRelationFilter;
+    @Field(() => ArticleListRelationFilter, {nullable:true})
+    @Type(() => ArticleListRelationFilter)
+    articles?: ArticleListRelationFilter;
 
-  @Field(() => ProfileNullableRelationFilter, { nullable: true })
-  @Type(() => ProfileNullableRelationFilter)
-  profile?: ProfileNullableRelationFilter;
+    @Field(() => CommentListRelationFilter, {nullable:true})
+    @Type(() => CommentListRelationFilter)
+    comments?: CommentListRelationFilter;
+
+    @Field(() => ProfileNullableRelationFilter, {nullable:true})
+    @Type(() => ProfileNullableRelationFilter)
+    profile?: ProfileNullableRelationFilter;
 }
diff --git a/@generated/user/user-where.input.ts b/@generated/user/user-where.input.ts
index 3713786d..1679091b 100644
--- a/@generated/user/user-where.input.ts
+++ b/@generated/user/user-where.input.ts
@@ -14,70 +14,71 @@ import { ProfileWhereInput } from '../profile/profile-where.input';
 
 @InputType()
 export class UserWhereInput {
-  @Field(() => [UserWhereInput], { nullable: true })
-  @Type(() => UserWhereInput)
-  AND?: Array<UserWhereInput>;
 
-  @Field(() => [UserWhereInput], { nullable: true })
-  @Type(() => UserWhereInput)
-  OR?: Array<UserWhereInput>;
+    @Field(() => [UserWhereInput], {nullable:true})
+    @Type(() => UserWhereInput)
+    AND?: Array<UserWhereInput>;
 
-  @Field(() => [UserWhereInput], { nullable: true })
-  @Type(() => UserWhereInput)
-  NOT?: Array<UserWhereInput>;
+    @Field(() => [UserWhereInput], {nullable:true})
+    @Type(() => UserWhereInput)
+    OR?: Array<UserWhereInput>;
 
-  @Field(() => StringFilter, { nullable: true })
-  id?: StringFilter;
+    @Field(() => [UserWhereInput], {nullable:true})
+    @Type(() => UserWhereInput)
+    NOT?: Array<UserWhereInput>;
 
-  @Field(() => StringFilter, { nullable: true })
-  email?: StringFilter;
+    @Field(() => StringFilter, {nullable:true})
+    id?: StringFilter;
 
-  @Field(() => StringFilter, { nullable: true })
-  name?: StringFilter;
+    @Field(() => StringFilter, {nullable:true})
+    email?: StringFilter;
 
-  @Field(() => StringFilter, { nullable: true })
-  password?: StringFilter;
+    @Field(() => StringFilter, {nullable:true})
+    name?: StringFilter;
 
-  @Field(() => StringNullableFilter, { nullable: true })
-  bio?: StringNullableFilter;
+    @Field(() => StringFilter, {nullable:true})
+    password?: StringFilter;
 
-  @Field(() => StringNullableFilter, { nullable: true })
-  image?: StringNullableFilter;
+    @Field(() => StringNullableFilter, {nullable:true})
+    bio?: StringNullableFilter;
 
-  @Field(() => IntNullableFilter, { nullable: true })
-  countComments?: IntNullableFilter;
+    @Field(() => StringNullableFilter, {nullable:true})
+    image?: StringNullableFilter;
 
-  @Field(() => FloatNullableFilter, { nullable: true })
-  rating?: FloatNullableFilter;
+    @Field(() => IntNullableFilter, {nullable:true})
+    countComments?: IntNullableFilter;
 
-  @Field(() => DecimalNullableFilter, { nullable: true })
-  @Type(() => DecimalNullableFilter)
-  money?: DecimalNullableFilter;
+    @Field(() => FloatNullableFilter, {nullable:true})
+    rating?: FloatNullableFilter;
 
-  @Field(() => EnumRoleNullableFilter, { nullable: true })
-  role?: EnumRoleNullableFilter;
+    @Field(() => DecimalNullableFilter, {nullable:true})
+    @Type(() => DecimalNullableFilter)
+    money?: DecimalNullableFilter;
 
-  @Field(() => UserListRelationFilter, { nullable: true })
-  @Type(() => UserListRelationFilter)
-  following?: UserListRelationFilter;
+    @Field(() => EnumRoleNullableFilter, {nullable:true})
+    role?: EnumRoleNullableFilter;
 
-  @Field(() => UserListRelationFilter, { nullable: true })
-  @Type(() => UserListRelationFilter)
-  followers?: UserListRelationFilter;
+    @Field(() => UserListRelationFilter, {nullable:true})
+    @Type(() => UserListRelationFilter)
+    following?: UserListRelationFilter;
 
-  @Field(() => ArticleListRelationFilter, { nullable: true })
-  @Type(() => ArticleListRelationFilter)
-  favoriteArticles?: ArticleListRelationFilter;
+    @Field(() => UserListRelationFilter, {nullable:true})
+    @Type(() => UserListRelationFilter)
+    followers?: UserListRelationFilter;
 
-  @Field(() => ArticleListRelationFilter, { nullable: true })
-  @Type(() => ArticleListRelationFilter)
-  articles?: ArticleListRelationFilter;
+    @Field(() => ArticleListRelationFilter, {nullable:true})
+    @Type(() => ArticleListRelationFilter)
+    favoriteArticles?: ArticleListRelationFilter;
 
-  @Field(() => CommentListRelationFilter, { nullable: true })
-  @Type(() => CommentListRelationFilter)
-  comments?: CommentListRelationFilter;
+    @Field(() => ArticleListRelationFilter, {nullable:true})
+    @Type(() => ArticleListRelationFilter)
+    articles?: ArticleListRelationFilter;
 
-  @Field(() => ProfileWhereInput, { nullable: true })
-  @Type(() => ProfileWhereInput)
-  profile?: ProfileWhereInput;
+    @Field(() => CommentListRelationFilter, {nullable:true})
+    @Type(() => CommentListRelationFilter)
+    comments?: CommentListRelationFilter;
+
+    @Field(() => ProfileWhereInput, {nullable:true})
+    @Type(() => ProfileWhereInput)
+    profile?: ProfileWhereInput;
 }
diff --git a/@generated/user/user.model.ts b/@generated/user/user.model.ts
index 71ff4eb4..af73b94a 100644
--- a/@generated/user/user.model.ts
+++ b/@generated/user/user.model.ts
@@ -5,7 +5,7 @@ import { HideField } from '@nestjs/graphql';
 import { Int } from '@nestjs/graphql';
 import { Float } from '@nestjs/graphql';
 import { GraphQLDecimal } from 'prisma-graphql-type-decimal';
-import { Decimal } from '@prisma/client/runtime/library';
+import { Decimal } from '../../prisma-client/runtime/library';
 import { Role } from '../prisma/role.enum';
 import { Article } from '../article/article.model';
 import { Comment } from '../comment/comment.model';
@@ -15,59 +15,60 @@ import { UserCount } from './user-count.output';
 /**
  * User really
  */
-@ObjectType({ description: 'User really' })
+@ObjectType({description:'User really'})
 export class User {
-  @Field(() => ID, { nullable: false })
-  id!: string;
 
-  @Field(() => String, { nullable: false })
-  email!: string;
+    @Field(() => ID, {nullable:false})
+    id!: string;
 
-  /**
-   * User's name
-   */
-  @Field(() => String, { nullable: false, description: "User's name" })
-  name!: string;
+    @Field(() => String, {nullable:false})
+    email!: string;
 
-  @HideField()
-  password!: string;
+    /**
+     * User's name
+     */
+    @Field(() => String, {nullable:false,description:"User's name"})
+    name!: string;
 
-  @Field(() => String, { nullable: true })
-  bio!: string | null;
+    @HideField()
+    password!: string;
 
-  @Field(() => String, { nullable: true })
-  image!: string | null;
+    @Field(() => String, {nullable:true})
+    bio!: string | null;
 
-  @Field(() => Int, { nullable: true })
-  countComments!: number | null;
+    @Field(() => String, {nullable:true})
+    image!: string | null;
 
-  @Field(() => Float, { nullable: true })
-  rating!: number | null;
+    @Field(() => Int, {nullable:true})
+    countComments!: number | null;
 
-  @Field(() => GraphQLDecimal, { nullable: true })
-  money!: Decimal | null;
+    @Field(() => Float, {nullable:true})
+    rating!: number | null;
 
-  @Field(() => Role, { nullable: true })
-  role!: keyof typeof Role | null;
+    @Field(() => GraphQLDecimal, {nullable:true})
+    money!: Decimal | null;
 
-  @Field(() => [User], { nullable: true })
-  following?: Array<User>;
+    @Field(() => Role, {nullable:true})
+    role!: keyof typeof Role | null;
 
-  @Field(() => [User], { nullable: true })
-  followers?: Array<User>;
+    @Field(() => [User], {nullable:true})
+    following?: Array<User>;
 
-  @Field(() => [Article], { nullable: true })
-  favoriteArticles?: Array<Article>;
+    @Field(() => [User], {nullable:true})
+    followers?: Array<User>;
 
-  @Field(() => [Article], { nullable: true })
-  articles?: Array<Article>;
+    @Field(() => [Article], {nullable:true})
+    favoriteArticles?: Array<Article>;
 
-  @Field(() => [Comment], { nullable: true })
-  comments?: Array<Comment>;
+    @Field(() => [Article], {nullable:true})
+    articles?: Array<Article>;
 
-  @Field(() => Profile, { nullable: true })
-  profile?: Profile | null;
+    @Field(() => [Comment], {nullable:true})
+    comments?: Array<Comment>;
 
-  @Field(() => UserCount, { nullable: false })
-  _count?: UserCount;
+    @Field(() => Profile, {nullable:true})
+    profile?: Profile | null;
+
+    @Field(() => UserCount, {nullable:false})
+    _count?: UserCount;
 }
diff --git a/src/handlers/input-type.ts b/src/handlers/input-type.ts
index fafab96a..f6948bce 100644
--- a/src/handlers/input-type.ts
+++ b/src/handlers/input-type.ts
@@ -136,7 +136,7 @@ export function inputType(
       importDeclarations.create({ ...propertySettings });
     } else if (propertyType.includes('Decimal')) {
       // TODO: Deprecated and should be removed
-      importDeclarations.add('Decimal', '@prisma/client/runtime/library');
+      importDeclarations.add('Decimal', `${config.prismaClientImport}/runtime/library`);
     } else if (propertyType.some(p => p.startsWith('Prisma.'))) {
       importDeclarations.add('Prisma', config.prismaClientImport);
     }
diff --git a/src/handlers/model-output-type.ts b/src/handlers/model-output-type.ts
index 538666b7..e871e4a4 100644
--- a/src/handlers/model-output-type.ts
+++ b/src/handlers/model-output-type.ts
@@ -158,7 +158,7 @@ export function modelOutputType(outputType: OutputType, args: EventArguments) {
     if (propertySettings) {
       importDeclarations.create({ ...propertySettings });
     } else if (propertyType.includes('Decimal')) {
-      importDeclarations.add('Decimal', '@prisma/client/runtime/library');
+      importDeclarations.add('Decimal', `${config.prismaClientImport}/runtime/library`);
     }
 
     ok(property.decorators, 'property.decorators is undefined');
diff --git a/src/handlers/output-type.ts b/src/handlers/output-type.ts
index 9d7f54ab..dabda9e7 100644
--- a/src/handlers/output-type.ts
+++ b/src/handlers/output-type.ts
@@ -93,7 +93,7 @@ export function outputType(outputType: OutputType, args: EventArguments) {
     if (propertySettings) {
       importDeclarations.create({ ...propertySettings });
     } else if (propertyType.includes('Decimal')) {
-      importDeclarations.add('Decimal', '@prisma/client/runtime/library');
+      importDeclarations.add('Decimal', `${config.prismaClientImport}/runtime/library`);
     }
 
     // Get graphql type