chore: refacto NestJS in modules (#308)

* chore: wip refacto in modules

* fix: rollback port

* fix: jwt guard in wrong folder

* chore: rename folder exception-filter in filters

* fix: tests are running

* fix: excessive stack depth comparing types

* fix: auth issue

* chore: move createUser in UserService

* fix: test

* fix: guards

* fix: jwt guard don't handle falsy user

server/src/core/@generated/refresh-token/aggregate-refresh-token.output.ts

@@ -0,0 +1,17 @@
+import { Field } from '@nestjs/graphql';
+import { ObjectType } from '@nestjs/graphql';
+import { RefreshTokenCountAggregate } from './refresh-token-count-aggregate.output';
+import { RefreshTokenMinAggregate } from './refresh-token-min-aggregate.output';
+import { RefreshTokenMaxAggregate } from './refresh-token-max-aggregate.output';
+
+@ObjectType()
+export class AggregateRefreshToken {
+  @Field(() => RefreshTokenCountAggregate, { nullable: true })
+  _count?: RefreshTokenCountAggregate;
+
+  @Field(() => RefreshTokenMinAggregate, { nullable: true })
+  _min?: RefreshTokenMinAggregate;
+
+  @Field(() => RefreshTokenMaxAggregate, { nullable: true })
+  _max?: RefreshTokenMaxAggregate;
+}

server/src/core/@generated/refresh-token/create-many-refresh-token.args.ts

@@ -0,0 +1,14 @@
+import { Field } from '@nestjs/graphql';
+import { ArgsType } from '@nestjs/graphql';
+import { RefreshTokenCreateManyInput } from './refresh-token-create-many.input';
+import { Type } from 'class-transformer';
+
+@ArgsType()
+export class CreateManyRefreshTokenArgs {
+  @Field(() => [RefreshTokenCreateManyInput], { nullable: false })
+  @Type(() => RefreshTokenCreateManyInput)
+  data!: Array<RefreshTokenCreateManyInput>;
+
+  @Field(() => Boolean, { nullable: true })
+  skipDuplicates?: boolean;
+}

server/src/core/@generated/refresh-token/create-one-refresh-token.args.ts

@@ -0,0 +1,11 @@
+import { Field } from '@nestjs/graphql';
+import { ArgsType } from '@nestjs/graphql';
+import { RefreshTokenCreateInput } from './refresh-token-create.input';
+import { Type } from 'class-transformer';
+
+@ArgsType()
+export class CreateOneRefreshTokenArgs {
+  @Field(() => RefreshTokenCreateInput, { nullable: false })
+  @Type(() => RefreshTokenCreateInput)
+  data!: RefreshTokenCreateInput;
+}

server/src/core/@generated/refresh-token/delete-many-refresh-token.args.ts

@@ -0,0 +1,11 @@
+import { Field } from '@nestjs/graphql';
+import { ArgsType } from '@nestjs/graphql';
+import { RefreshTokenWhereInput } from './refresh-token-where.input';
+import { Type } from 'class-transformer';
+
+@ArgsType()
+export class DeleteManyRefreshTokenArgs {
+  @Field(() => RefreshTokenWhereInput, { nullable: true })
+  @Type(() => RefreshTokenWhereInput)
+  where?: RefreshTokenWhereInput;
+}

server/src/core/@generated/refresh-token/delete-one-refresh-token.args.ts

@@ -0,0 +1,11 @@
+import { Field } from '@nestjs/graphql';
+import { ArgsType } from '@nestjs/graphql';
+import { RefreshTokenWhereUniqueInput } from './refresh-token-where-unique.input';
+import { Type } from 'class-transformer';
+
+@ArgsType()
+export class DeleteOneRefreshTokenArgs {
+  @Field(() => RefreshTokenWhereUniqueInput, { nullable: false })
+  @Type(() => RefreshTokenWhereUniqueInput)
+  where!: RefreshTokenWhereUniqueInput;
+}

server/src/core/@generated/refresh-token/find-first-refresh-token-or-throw.args.ts

@@ -0,0 +1,30 @@
+import { Field } from '@nestjs/graphql';
+import { ArgsType } from '@nestjs/graphql';
+import { RefreshTokenWhereInput } from './refresh-token-where.input';
+import { Type } from 'class-transformer';
+import { RefreshTokenOrderByWithRelationInput } from './refresh-token-order-by-with-relation.input';
+import { RefreshTokenWhereUniqueInput } from './refresh-token-where-unique.input';
+import { Int } from '@nestjs/graphql';
+import { RefreshTokenScalarFieldEnum } from './refresh-token-scalar-field.enum';
+
+@ArgsType()
+export class FindFirstRefreshTokenOrThrowArgs {
+  @Field(() => RefreshTokenWhereInput, { nullable: true })
+  @Type(() => RefreshTokenWhereInput)
+  where?: RefreshTokenWhereInput;
+
+  @Field(() => [RefreshTokenOrderByWithRelationInput], { nullable: true })
+  orderBy?: Array<RefreshTokenOrderByWithRelationInput>;
+
+  @Field(() => RefreshTokenWhereUniqueInput, { nullable: true })
+  cursor?: RefreshTokenWhereUniqueInput;
+
+  @Field(() => Int, { nullable: true })
+  take?: number;
+
+  @Field(() => Int, { nullable: true })
+  skip?: number;
+
+  @Field(() => [RefreshTokenScalarFieldEnum], { nullable: true })
+  distinct?: Array<keyof typeof RefreshTokenScalarFieldEnum>;
+}

server/src/core/@generated/refresh-token/find-first-refresh-token.args.ts

@@ -0,0 +1,30 @@
+import { Field } from '@nestjs/graphql';
+import { ArgsType } from '@nestjs/graphql';
+import { RefreshTokenWhereInput } from './refresh-token-where.input';
+import { Type } from 'class-transformer';
+import { RefreshTokenOrderByWithRelationInput } from './refresh-token-order-by-with-relation.input';
+import { RefreshTokenWhereUniqueInput } from './refresh-token-where-unique.input';
+import { Int } from '@nestjs/graphql';
+import { RefreshTokenScalarFieldEnum } from './refresh-token-scalar-field.enum';
+
+@ArgsType()
+export class FindFirstRefreshTokenArgs {
+  @Field(() => RefreshTokenWhereInput, { nullable: true })
+  @Type(() => RefreshTokenWhereInput)
+  where?: RefreshTokenWhereInput;
+
+  @Field(() => [RefreshTokenOrderByWithRelationInput], { nullable: true })
+  orderBy?: Array<RefreshTokenOrderByWithRelationInput>;
+
+  @Field(() => RefreshTokenWhereUniqueInput, { nullable: true })
+  cursor?: RefreshTokenWhereUniqueInput;
+
+  @Field(() => Int, { nullable: true })
+  take?: number;
+
+  @Field(() => Int, { nullable: true })
+  skip?: number;
+
+  @Field(() => [RefreshTokenScalarFieldEnum], { nullable: true })
+  distinct?: Array<keyof typeof RefreshTokenScalarFieldEnum>;
+}

server/src/core/@generated/refresh-token/find-many-refresh-token.args.ts

@@ -0,0 +1,30 @@
+import { Field } from '@nestjs/graphql';
+import { ArgsType } from '@nestjs/graphql';
+import { RefreshTokenWhereInput } from './refresh-token-where.input';
+import { Type } from 'class-transformer';
+import { RefreshTokenOrderByWithRelationInput } from './refresh-token-order-by-with-relation.input';
+import { RefreshTokenWhereUniqueInput } from './refresh-token-where-unique.input';
+import { Int } from '@nestjs/graphql';
+import { RefreshTokenScalarFieldEnum } from './refresh-token-scalar-field.enum';
+
+@ArgsType()
+export class FindManyRefreshTokenArgs {
+  @Field(() => RefreshTokenWhereInput, { nullable: true })
+  @Type(() => RefreshTokenWhereInput)
+  where?: RefreshTokenWhereInput;
+
+  @Field(() => [RefreshTokenOrderByWithRelationInput], { nullable: true })
+  orderBy?: Array<RefreshTokenOrderByWithRelationInput>;
+
+  @Field(() => RefreshTokenWhereUniqueInput, { nullable: true })
+  cursor?: RefreshTokenWhereUniqueInput;
+
+  @Field(() => Int, { nullable: true })
+  take?: number;
+
+  @Field(() => Int, { nullable: true })
+  skip?: number;
+
+  @Field(() => [RefreshTokenScalarFieldEnum], { nullable: true })
+  distinct?: Array<keyof typeof RefreshTokenScalarFieldEnum>;
+}

server/src/core/@generated/refresh-token/find-unique-refresh-token-or-throw.args.ts

@@ -0,0 +1,11 @@
+import { Field } from '@nestjs/graphql';
+import { ArgsType } from '@nestjs/graphql';
+import { RefreshTokenWhereUniqueInput } from './refresh-token-where-unique.input';
+import { Type } from 'class-transformer';
+
+@ArgsType()
+export class FindUniqueRefreshTokenOrThrowArgs {
+  @Field(() => RefreshTokenWhereUniqueInput, { nullable: false })
+  @Type(() => RefreshTokenWhereUniqueInput)
+  where!: RefreshTokenWhereUniqueInput;
+}

server/src/core/@generated/refresh-token/find-unique-refresh-token.args.ts

@@ -0,0 +1,11 @@
+import { Field } from '@nestjs/graphql';
+import { ArgsType } from '@nestjs/graphql';
+import { RefreshTokenWhereUniqueInput } from './refresh-token-where-unique.input';
+import { Type } from 'class-transformer';
+
+@ArgsType()
+export class FindUniqueRefreshTokenArgs {
+  @Field(() => RefreshTokenWhereUniqueInput, { nullable: false })
+  @Type(() => RefreshTokenWhereUniqueInput)
+  where!: RefreshTokenWhereUniqueInput;
+}

server/src/core/@generated/refresh-token/refresh-token-aggregate.args.ts

@@ -0,0 +1,38 @@
+import { Field } from '@nestjs/graphql';
+import { ArgsType } from '@nestjs/graphql';
+import { RefreshTokenWhereInput } from './refresh-token-where.input';
+import { Type } from 'class-transformer';
+import { RefreshTokenOrderByWithRelationInput } from './refresh-token-order-by-with-relation.input';
+import { RefreshTokenWhereUniqueInput } from './refresh-token-where-unique.input';
+import { Int } from '@nestjs/graphql';
+import { RefreshTokenCountAggregateInput } from './refresh-token-count-aggregate.input';
+import { RefreshTokenMinAggregateInput } from './refresh-token-min-aggregate.input';
+import { RefreshTokenMaxAggregateInput } from './refresh-token-max-aggregate.input';
+
+@ArgsType()
+export class RefreshTokenAggregateArgs {
+  @Field(() => RefreshTokenWhereInput, { nullable: true })
+  @Type(() => RefreshTokenWhereInput)
+  where?: RefreshTokenWhereInput;
+
+  @Field(() => [RefreshTokenOrderByWithRelationInput], { nullable: true })
+  orderBy?: Array<RefreshTokenOrderByWithRelationInput>;
+
+  @Field(() => RefreshTokenWhereUniqueInput, { nullable: true })
+  cursor?: RefreshTokenWhereUniqueInput;
+
+  @Field(() => Int, { nullable: true })
+  take?: number;
+
+  @Field(() => Int, { nullable: true })
+  skip?: number;
+
+  @Field(() => RefreshTokenCountAggregateInput, { nullable: true })
+  _count?: RefreshTokenCountAggregateInput;
+
+  @Field(() => RefreshTokenMinAggregateInput, { nullable: true })
+  _min?: RefreshTokenMinAggregateInput;
+
+  @Field(() => RefreshTokenMaxAggregateInput, { nullable: true })
+  _max?: RefreshTokenMaxAggregateInput;
+}

server/src/core/@generated/refresh-token/refresh-token-count-aggregate.input.ts

@@ -0,0 +1,26 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+
+@InputType()
+export class RefreshTokenCountAggregateInput {
+  @Field(() => Boolean, { nullable: true })
+  id?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  createdAt?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  updatedAt?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  deletedAt?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  refreshToken?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  userId?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  _all?: true;
+}

server/src/core/@generated/refresh-token/refresh-token-count-aggregate.output.ts

@@ -0,0 +1,27 @@
+import { Field } from '@nestjs/graphql';
+import { ObjectType } from '@nestjs/graphql';
+import { Int } from '@nestjs/graphql';
+
+@ObjectType()
+export class RefreshTokenCountAggregate {
+  @Field(() => Int, { nullable: false })
+  id!: number;
+
+  @Field(() => Int, { nullable: false })
+  createdAt!: number;
+
+  @Field(() => Int, { nullable: false })
+  updatedAt!: number;
+
+  @Field(() => Int, { nullable: false })
+  deletedAt!: number;
+
+  @Field(() => Int, { nullable: false })
+  refreshToken!: number;
+
+  @Field(() => Int, { nullable: false })
+  userId!: number;
+
+  @Field(() => Int, { nullable: false })
+  _all!: number;
+}

server/src/core/@generated/refresh-token/refresh-token-count-order-by-aggregate.input.ts

@@ -0,0 +1,24 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { SortOrder } from '../prisma/sort-order.enum';
+
+@InputType()
+export class RefreshTokenCountOrderByAggregateInput {
+  @Field(() => SortOrder, { nullable: true })
+  id?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  createdAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  updatedAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  deletedAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  refreshToken?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  userId?: keyof typeof SortOrder;
+}

server/src/core/@generated/refresh-token/refresh-token-create-many-user-input-envelope.input.ts

@@ -0,0 +1,14 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { RefreshTokenCreateManyUserInput } from './refresh-token-create-many-user.input';
+import { Type } from 'class-transformer';
+
+@InputType()
+export class RefreshTokenCreateManyUserInputEnvelope {
+  @Field(() => [RefreshTokenCreateManyUserInput], { nullable: false })
+  @Type(() => RefreshTokenCreateManyUserInput)
+  data!: Array<RefreshTokenCreateManyUserInput>;
+
+  @Field(() => Boolean, { nullable: true })
+  skipDuplicates?: boolean;
+}

server/src/core/@generated/refresh-token/refresh-token-create-many-user.input.ts

@@ -0,0 +1,20 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+
+@InputType()
+export class RefreshTokenCreateManyUserInput {
+  @Field(() => String, { nullable: false })
+  id!: string;
+
+  @Field(() => Date, { nullable: true })
+  createdAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  updatedAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt?: Date | string;
+
+  @Field(() => String, { nullable: false })
+  refreshToken!: string;
+}

server/src/core/@generated/refresh-token/refresh-token-create-many.input.ts

@@ -0,0 +1,23 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+
+@InputType()
+export class RefreshTokenCreateManyInput {
+  @Field(() => String, { nullable: false })
+  id!: string;
+
+  @Field(() => Date, { nullable: true })
+  createdAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  updatedAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt?: Date | string;
+
+  @Field(() => String, { nullable: false })
+  refreshToken!: string;
+
+  @Field(() => String, { nullable: false })
+  userId!: string;
+}

server/src/core/@generated/refresh-token/refresh-token-create-nested-many-without-user.input.ts

@@ -0,0 +1,28 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { RefreshTokenCreateWithoutUserInput } from './refresh-token-create-without-user.input';
+import { Type } from 'class-transformer';
+import { RefreshTokenCreateOrConnectWithoutUserInput } from './refresh-token-create-or-connect-without-user.input';
+import { RefreshTokenCreateManyUserInputEnvelope } from './refresh-token-create-many-user-input-envelope.input';
+import { RefreshTokenWhereUniqueInput } from './refresh-token-where-unique.input';
+
+@InputType()
+export class RefreshTokenCreateNestedManyWithoutUserInput {
+  @Field(() => [RefreshTokenCreateWithoutUserInput], { nullable: true })
+  @Type(() => RefreshTokenCreateWithoutUserInput)
+  create?: Array<RefreshTokenCreateWithoutUserInput>;
+
+  @Field(() => [RefreshTokenCreateOrConnectWithoutUserInput], {
+    nullable: true,
+  })
+  @Type(() => RefreshTokenCreateOrConnectWithoutUserInput)
+  connectOrCreate?: Array<RefreshTokenCreateOrConnectWithoutUserInput>;
+
+  @Field(() => RefreshTokenCreateManyUserInputEnvelope, { nullable: true })
+  @Type(() => RefreshTokenCreateManyUserInputEnvelope)
+  createMany?: RefreshTokenCreateManyUserInputEnvelope;
+
+  @Field(() => [RefreshTokenWhereUniqueInput], { nullable: true })
+  @Type(() => RefreshTokenWhereUniqueInput)
+  connect?: Array<RefreshTokenWhereUniqueInput>;
+}

server/src/core/@generated/refresh-token/refresh-token-create-or-connect-without-user.input.ts

@@ -0,0 +1,16 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { RefreshTokenWhereUniqueInput } from './refresh-token-where-unique.input';
+import { Type } from 'class-transformer';
+import { RefreshTokenCreateWithoutUserInput } from './refresh-token-create-without-user.input';
+
+@InputType()
+export class RefreshTokenCreateOrConnectWithoutUserInput {
+  @Field(() => RefreshTokenWhereUniqueInput, { nullable: false })
+  @Type(() => RefreshTokenWhereUniqueInput)
+  where!: RefreshTokenWhereUniqueInput;
+
+  @Field(() => RefreshTokenCreateWithoutUserInput, { nullable: false })
+  @Type(() => RefreshTokenCreateWithoutUserInput)
+  create!: RefreshTokenCreateWithoutUserInput;
+}

server/src/core/@generated/refresh-token/refresh-token-create-without-user.input.ts

@@ -0,0 +1,20 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+
+@InputType()
+export class RefreshTokenCreateWithoutUserInput {
+  @Field(() => String, { nullable: false })
+  id!: string;
+
+  @Field(() => Date, { nullable: true })
+  createdAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  updatedAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt?: Date | string;
+
+  @Field(() => String, { nullable: false })
+  refreshToken!: string;
+}

server/src/core/@generated/refresh-token/refresh-token-create.input.ts

@@ -0,0 +1,26 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { UserCreateNestedOneWithoutRefreshTokensInput } from '../user/user-create-nested-one-without-refresh-tokens.input';
+
+@InputType()
+export class RefreshTokenCreateInput {
+  @Field(() => String, { nullable: false })
+  id!: string;
+
+  @Field(() => Date, { nullable: true })
+  createdAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  updatedAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt?: Date | string;
+
+  @Field(() => String, { nullable: false })
+  refreshToken!: string;
+
+  @Field(() => UserCreateNestedOneWithoutRefreshTokensInput, {
+    nullable: false,
+  })
+  user!: UserCreateNestedOneWithoutRefreshTokensInput;
+}

server/src/core/@generated/refresh-token/refresh-token-group-by.args.ts

@@ -0,0 +1,42 @@
+import { Field } from '@nestjs/graphql';
+import { ArgsType } from '@nestjs/graphql';
+import { RefreshTokenWhereInput } from './refresh-token-where.input';
+import { Type } from 'class-transformer';
+import { RefreshTokenOrderByWithAggregationInput } from './refresh-token-order-by-with-aggregation.input';
+import { RefreshTokenScalarFieldEnum } from './refresh-token-scalar-field.enum';
+import { RefreshTokenScalarWhereWithAggregatesInput } from './refresh-token-scalar-where-with-aggregates.input';
+import { Int } from '@nestjs/graphql';
+import { RefreshTokenCountAggregateInput } from './refresh-token-count-aggregate.input';
+import { RefreshTokenMinAggregateInput } from './refresh-token-min-aggregate.input';
+import { RefreshTokenMaxAggregateInput } from './refresh-token-max-aggregate.input';
+
+@ArgsType()
+export class RefreshTokenGroupByArgs {
+  @Field(() => RefreshTokenWhereInput, { nullable: true })
+  @Type(() => RefreshTokenWhereInput)
+  where?: RefreshTokenWhereInput;
+
+  @Field(() => [RefreshTokenOrderByWithAggregationInput], { nullable: true })
+  orderBy?: Array<RefreshTokenOrderByWithAggregationInput>;
+
+  @Field(() => [RefreshTokenScalarFieldEnum], { nullable: false })
+  by!: Array<keyof typeof RefreshTokenScalarFieldEnum>;
+
+  @Field(() => RefreshTokenScalarWhereWithAggregatesInput, { nullable: true })
+  having?: RefreshTokenScalarWhereWithAggregatesInput;
+
+  @Field(() => Int, { nullable: true })
+  take?: number;
+
+  @Field(() => Int, { nullable: true })
+  skip?: number;
+
+  @Field(() => RefreshTokenCountAggregateInput, { nullable: true })
+  _count?: RefreshTokenCountAggregateInput;
+
+  @Field(() => RefreshTokenMinAggregateInput, { nullable: true })
+  _min?: RefreshTokenMinAggregateInput;
+
+  @Field(() => RefreshTokenMaxAggregateInput, { nullable: true })
+  _max?: RefreshTokenMaxAggregateInput;
+}

server/src/core/@generated/refresh-token/refresh-token-group-by.output.ts

@@ -0,0 +1,35 @@
+import { Field } from '@nestjs/graphql';
+import { ObjectType } from '@nestjs/graphql';
+import { RefreshTokenCountAggregate } from './refresh-token-count-aggregate.output';
+import { RefreshTokenMinAggregate } from './refresh-token-min-aggregate.output';
+import { RefreshTokenMaxAggregate } from './refresh-token-max-aggregate.output';
+
+@ObjectType()
+export class RefreshTokenGroupBy {
+  @Field(() => String, { nullable: false })
+  id!: string;
+
+  @Field(() => Date, { nullable: false })
+  createdAt!: Date | string;
+
+  @Field(() => Date, { nullable: false })
+  updatedAt!: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt?: Date | string;
+
+  @Field(() => String, { nullable: false })
+  refreshToken!: string;
+
+  @Field(() => String, { nullable: false })
+  userId!: string;
+
+  @Field(() => RefreshTokenCountAggregate, { nullable: true })
+  _count?: RefreshTokenCountAggregate;
+
+  @Field(() => RefreshTokenMinAggregate, { nullable: true })
+  _min?: RefreshTokenMinAggregate;
+
+  @Field(() => RefreshTokenMaxAggregate, { nullable: true })
+  _max?: RefreshTokenMaxAggregate;
+}

server/src/core/@generated/refresh-token/refresh-token-list-relation-filter.input.ts

@@ -0,0 +1,15 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { RefreshTokenWhereInput } from './refresh-token-where.input';
+
+@InputType()
+export class RefreshTokenListRelationFilter {
+  @Field(() => RefreshTokenWhereInput, { nullable: true })
+  every?: RefreshTokenWhereInput;
+
+  @Field(() => RefreshTokenWhereInput, { nullable: true })
+  some?: RefreshTokenWhereInput;
+
+  @Field(() => RefreshTokenWhereInput, { nullable: true })
+  none?: RefreshTokenWhereInput;
+}

server/src/core/@generated/refresh-token/refresh-token-max-aggregate.input.ts

@@ -0,0 +1,23 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+
+@InputType()
+export class RefreshTokenMaxAggregateInput {
+  @Field(() => Boolean, { nullable: true })
+  id?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  createdAt?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  updatedAt?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  deletedAt?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  refreshToken?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  userId?: true;
+}

server/src/core/@generated/refresh-token/refresh-token-max-aggregate.output.ts

@@ -0,0 +1,23 @@
+import { Field } from '@nestjs/graphql';
+import { ObjectType } from '@nestjs/graphql';
+
+@ObjectType()
+export class RefreshTokenMaxAggregate {
+  @Field(() => String, { nullable: true })
+  id?: string;
+
+  @Field(() => Date, { nullable: true })
+  createdAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  updatedAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt?: Date | string;
+
+  @Field(() => String, { nullable: true })
+  refreshToken?: string;
+
+  @Field(() => String, { nullable: true })
+  userId?: string;
+}

server/src/core/@generated/refresh-token/refresh-token-max-order-by-aggregate.input.ts

@@ -0,0 +1,24 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { SortOrder } from '../prisma/sort-order.enum';
+
+@InputType()
+export class RefreshTokenMaxOrderByAggregateInput {
+  @Field(() => SortOrder, { nullable: true })
+  id?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  createdAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  updatedAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  deletedAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  refreshToken?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  userId?: keyof typeof SortOrder;
+}

server/src/core/@generated/refresh-token/refresh-token-min-aggregate.input.ts

@@ -0,0 +1,23 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+
+@InputType()
+export class RefreshTokenMinAggregateInput {
+  @Field(() => Boolean, { nullable: true })
+  id?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  createdAt?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  updatedAt?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  deletedAt?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  refreshToken?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  userId?: true;
+}

server/src/core/@generated/refresh-token/refresh-token-min-aggregate.output.ts

@@ -0,0 +1,23 @@
+import { Field } from '@nestjs/graphql';
+import { ObjectType } from '@nestjs/graphql';
+
+@ObjectType()
+export class RefreshTokenMinAggregate {
+  @Field(() => String, { nullable: true })
+  id?: string;
+
+  @Field(() => Date, { nullable: true })
+  createdAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  updatedAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt?: Date | string;
+
+  @Field(() => String, { nullable: true })
+  refreshToken?: string;
+
+  @Field(() => String, { nullable: true })
+  userId?: string;
+}

server/src/core/@generated/refresh-token/refresh-token-min-order-by-aggregate.input.ts

@@ -0,0 +1,24 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { SortOrder } from '../prisma/sort-order.enum';
+
+@InputType()
+export class RefreshTokenMinOrderByAggregateInput {
+  @Field(() => SortOrder, { nullable: true })
+  id?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  createdAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  updatedAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  deletedAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  refreshToken?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  userId?: keyof typeof SortOrder;
+}

server/src/core/@generated/refresh-token/refresh-token-order-by-relation-aggregate.input.ts

@@ -0,0 +1,9 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { SortOrder } from '../prisma/sort-order.enum';
+
+@InputType()
+export class RefreshTokenOrderByRelationAggregateInput {
+  @Field(() => SortOrder, { nullable: true })
+  _count?: keyof typeof SortOrder;
+}

server/src/core/@generated/refresh-token/refresh-token-order-by-with-aggregation.input.ts

@@ -0,0 +1,36 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { SortOrder } from '../prisma/sort-order.enum';
+import { RefreshTokenCountOrderByAggregateInput } from './refresh-token-count-order-by-aggregate.input';
+import { RefreshTokenMaxOrderByAggregateInput } from './refresh-token-max-order-by-aggregate.input';
+import { RefreshTokenMinOrderByAggregateInput } from './refresh-token-min-order-by-aggregate.input';
+
+@InputType()
+export class RefreshTokenOrderByWithAggregationInput {
+  @Field(() => SortOrder, { nullable: true })
+  id?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  createdAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  updatedAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  deletedAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  refreshToken?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  userId?: keyof typeof SortOrder;
+
+  @Field(() => RefreshTokenCountOrderByAggregateInput, { nullable: true })
+  _count?: RefreshTokenCountOrderByAggregateInput;
+
+  @Field(() => RefreshTokenMaxOrderByAggregateInput, { nullable: true })
+  _max?: RefreshTokenMaxOrderByAggregateInput;
+
+  @Field(() => RefreshTokenMinOrderByAggregateInput, { nullable: true })
+  _min?: RefreshTokenMinOrderByAggregateInput;
+}

server/src/core/@generated/refresh-token/refresh-token-order-by-with-relation.input.ts

@@ -0,0 +1,28 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { SortOrder } from '../prisma/sort-order.enum';
+import { UserOrderByWithRelationInput } from '../user/user-order-by-with-relation.input';
+
+@InputType()
+export class RefreshTokenOrderByWithRelationInput {
+  @Field(() => SortOrder, { nullable: true })
+  id?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  createdAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  updatedAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  deletedAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  refreshToken?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  userId?: keyof typeof SortOrder;
+
+  @Field(() => UserOrderByWithRelationInput, { nullable: true })
+  user?: UserOrderByWithRelationInput;
+}

server/src/core/@generated/refresh-token/refresh-token-scalar-field.enum.ts

@@ -0,0 +1,15 @@
+import { registerEnumType } from '@nestjs/graphql';
+
+export enum RefreshTokenScalarFieldEnum {
+  id = 'id',
+  createdAt = 'createdAt',
+  updatedAt = 'updatedAt',
+  deletedAt = 'deletedAt',
+  refreshToken = 'refreshToken',
+  userId = 'userId',
+}
+
+registerEnumType(RefreshTokenScalarFieldEnum, {
+  name: 'RefreshTokenScalarFieldEnum',
+  description: undefined,
+});

server/src/core/@generated/refresh-token/refresh-token-scalar-where-with-aggregates.input.ts

@@ -0,0 +1,35 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { StringWithAggregatesFilter } from '../prisma/string-with-aggregates-filter.input';
+import { DateTimeWithAggregatesFilter } from '../prisma/date-time-with-aggregates-filter.input';
+import { DateTimeNullableWithAggregatesFilter } from '../prisma/date-time-nullable-with-aggregates-filter.input';
+
+@InputType()
+export class RefreshTokenScalarWhereWithAggregatesInput {
+  @Field(() => [RefreshTokenScalarWhereWithAggregatesInput], { nullable: true })
+  AND?: Array<RefreshTokenScalarWhereWithAggregatesInput>;
+
+  @Field(() => [RefreshTokenScalarWhereWithAggregatesInput], { nullable: true })
+  OR?: Array<RefreshTokenScalarWhereWithAggregatesInput>;
+
+  @Field(() => [RefreshTokenScalarWhereWithAggregatesInput], { nullable: true })
+  NOT?: Array<RefreshTokenScalarWhereWithAggregatesInput>;
+
+  @Field(() => StringWithAggregatesFilter, { nullable: true })
+  id?: StringWithAggregatesFilter;
+
+  @Field(() => DateTimeWithAggregatesFilter, { nullable: true })
+  createdAt?: DateTimeWithAggregatesFilter;
+
+  @Field(() => DateTimeWithAggregatesFilter, { nullable: true })
+  updatedAt?: DateTimeWithAggregatesFilter;
+
+  @Field(() => DateTimeNullableWithAggregatesFilter, { nullable: true })
+  deletedAt?: DateTimeNullableWithAggregatesFilter;
+
+  @Field(() => StringWithAggregatesFilter, { nullable: true })
+  refreshToken?: StringWithAggregatesFilter;
+
+  @Field(() => StringWithAggregatesFilter, { nullable: true })
+  userId?: StringWithAggregatesFilter;
+}

server/src/core/@generated/refresh-token/refresh-token-scalar-where.input.ts

@@ -0,0 +1,35 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { StringFilter } from '../prisma/string-filter.input';
+import { DateTimeFilter } from '../prisma/date-time-filter.input';
+import { DateTimeNullableFilter } from '../prisma/date-time-nullable-filter.input';
+
+@InputType()
+export class RefreshTokenScalarWhereInput {
+  @Field(() => [RefreshTokenScalarWhereInput], { nullable: true })
+  AND?: Array<RefreshTokenScalarWhereInput>;
+
+  @Field(() => [RefreshTokenScalarWhereInput], { nullable: true })
+  OR?: Array<RefreshTokenScalarWhereInput>;
+
+  @Field(() => [RefreshTokenScalarWhereInput], { nullable: true })
+  NOT?: Array<RefreshTokenScalarWhereInput>;
+
+  @Field(() => StringFilter, { nullable: true })
+  id?: StringFilter;
+
+  @Field(() => DateTimeFilter, { nullable: true })
+  createdAt?: DateTimeFilter;
+
+  @Field(() => DateTimeFilter, { nullable: true })
+  updatedAt?: DateTimeFilter;
+
+  @Field(() => DateTimeNullableFilter, { nullable: true })
+  deletedAt?: DateTimeNullableFilter;
+
+  @Field(() => StringFilter, { nullable: true })
+  refreshToken?: StringFilter;
+
+  @Field(() => StringFilter, { nullable: true })
+  userId?: StringFilter;
+}

server/src/core/@generated/refresh-token/refresh-token-unchecked-create-nested-many-without-user.input.ts

@@ -0,0 +1,28 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { RefreshTokenCreateWithoutUserInput } from './refresh-token-create-without-user.input';
+import { Type } from 'class-transformer';
+import { RefreshTokenCreateOrConnectWithoutUserInput } from './refresh-token-create-or-connect-without-user.input';
+import { RefreshTokenCreateManyUserInputEnvelope } from './refresh-token-create-many-user-input-envelope.input';
+import { RefreshTokenWhereUniqueInput } from './refresh-token-where-unique.input';
+
+@InputType()
+export class RefreshTokenUncheckedCreateNestedManyWithoutUserInput {
+  @Field(() => [RefreshTokenCreateWithoutUserInput], { nullable: true })
+  @Type(() => RefreshTokenCreateWithoutUserInput)
+  create?: Array<RefreshTokenCreateWithoutUserInput>;
+
+  @Field(() => [RefreshTokenCreateOrConnectWithoutUserInput], {
+    nullable: true,
+  })
+  @Type(() => RefreshTokenCreateOrConnectWithoutUserInput)
+  connectOrCreate?: Array<RefreshTokenCreateOrConnectWithoutUserInput>;
+
+  @Field(() => RefreshTokenCreateManyUserInputEnvelope, { nullable: true })
+  @Type(() => RefreshTokenCreateManyUserInputEnvelope)
+  createMany?: RefreshTokenCreateManyUserInputEnvelope;
+
+  @Field(() => [RefreshTokenWhereUniqueInput], { nullable: true })
+  @Type(() => RefreshTokenWhereUniqueInput)
+  connect?: Array<RefreshTokenWhereUniqueInput>;
+}

server/src/core/@generated/refresh-token/refresh-token-unchecked-create-without-user.input.ts

@@ -0,0 +1,20 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+
+@InputType()
+export class RefreshTokenUncheckedCreateWithoutUserInput {
+  @Field(() => String, { nullable: false })
+  id!: string;
+
+  @Field(() => Date, { nullable: true })
+  createdAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  updatedAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt?: Date | string;
+
+  @Field(() => String, { nullable: false })
+  refreshToken!: string;
+}

server/src/core/@generated/refresh-token/refresh-token-unchecked-create.input.ts

@@ -0,0 +1,23 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+
+@InputType()
+export class RefreshTokenUncheckedCreateInput {
+  @Field(() => String, { nullable: false })
+  id!: string;
+
+  @Field(() => Date, { nullable: true })
+  createdAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  updatedAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt?: Date | string;
+
+  @Field(() => String, { nullable: false })
+  refreshToken!: string;
+
+  @Field(() => String, { nullable: false })
+  userId!: string;
+}

server/src/core/@generated/refresh-token/refresh-token-unchecked-update-many-without-refresh-tokens.input.ts

@@ -0,0 +1,23 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-operations.input';
+import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
+import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
+
+@InputType()
+export class RefreshTokenUncheckedUpdateManyWithoutRefreshTokensInput {
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  id?: StringFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  createdAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  updatedAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true })
+  deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  refreshToken?: StringFieldUpdateOperationsInput;
+}

server/src/core/@generated/refresh-token/refresh-token-unchecked-update-many-without-user-nested.input.ts

@@ -0,0 +1,66 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { RefreshTokenCreateWithoutUserInput } from './refresh-token-create-without-user.input';
+import { Type } from 'class-transformer';
+import { RefreshTokenCreateOrConnectWithoutUserInput } from './refresh-token-create-or-connect-without-user.input';
+import { RefreshTokenUpsertWithWhereUniqueWithoutUserInput } from './refresh-token-upsert-with-where-unique-without-user.input';
+import { RefreshTokenCreateManyUserInputEnvelope } from './refresh-token-create-many-user-input-envelope.input';
+import { RefreshTokenWhereUniqueInput } from './refresh-token-where-unique.input';
+import { RefreshTokenUpdateWithWhereUniqueWithoutUserInput } from './refresh-token-update-with-where-unique-without-user.input';
+import { RefreshTokenUpdateManyWithWhereWithoutUserInput } from './refresh-token-update-many-with-where-without-user.input';
+import { RefreshTokenScalarWhereInput } from './refresh-token-scalar-where.input';
+
+@InputType()
+export class RefreshTokenUncheckedUpdateManyWithoutUserNestedInput {
+  @Field(() => [RefreshTokenCreateWithoutUserInput], { nullable: true })
+  @Type(() => RefreshTokenCreateWithoutUserInput)
+  create?: Array<RefreshTokenCreateWithoutUserInput>;
+
+  @Field(() => [RefreshTokenCreateOrConnectWithoutUserInput], {
+    nullable: true,
+  })
+  @Type(() => RefreshTokenCreateOrConnectWithoutUserInput)
+  connectOrCreate?: Array<RefreshTokenCreateOrConnectWithoutUserInput>;
+
+  @Field(() => [RefreshTokenUpsertWithWhereUniqueWithoutUserInput], {
+    nullable: true,
+  })
+  @Type(() => RefreshTokenUpsertWithWhereUniqueWithoutUserInput)
+  upsert?: Array<RefreshTokenUpsertWithWhereUniqueWithoutUserInput>;
+
+  @Field(() => RefreshTokenCreateManyUserInputEnvelope, { nullable: true })
+  @Type(() => RefreshTokenCreateManyUserInputEnvelope)
+  createMany?: RefreshTokenCreateManyUserInputEnvelope;
+
+  @Field(() => [RefreshTokenWhereUniqueInput], { nullable: true })
+  @Type(() => RefreshTokenWhereUniqueInput)
+  set?: Array<RefreshTokenWhereUniqueInput>;
+
+  @Field(() => [RefreshTokenWhereUniqueInput], { nullable: true })
+  @Type(() => RefreshTokenWhereUniqueInput)
+  disconnect?: Array<RefreshTokenWhereUniqueInput>;
+
+  @Field(() => [RefreshTokenWhereUniqueInput], { nullable: true })
+  @Type(() => RefreshTokenWhereUniqueInput)
+  delete?: Array<RefreshTokenWhereUniqueInput>;
+
+  @Field(() => [RefreshTokenWhereUniqueInput], { nullable: true })
+  @Type(() => RefreshTokenWhereUniqueInput)
+  connect?: Array<RefreshTokenWhereUniqueInput>;
+
+  @Field(() => [RefreshTokenUpdateWithWhereUniqueWithoutUserInput], {
+    nullable: true,
+  })
+  @Type(() => RefreshTokenUpdateWithWhereUniqueWithoutUserInput)
+  update?: Array<RefreshTokenUpdateWithWhereUniqueWithoutUserInput>;
+
+  @Field(() => [RefreshTokenUpdateManyWithWhereWithoutUserInput], {
+    nullable: true,
+  })
+  @Type(() => RefreshTokenUpdateManyWithWhereWithoutUserInput)
+  updateMany?: Array<RefreshTokenUpdateManyWithWhereWithoutUserInput>;
+
+  @Field(() => [RefreshTokenScalarWhereInput], { nullable: true })
+  @Type(() => RefreshTokenScalarWhereInput)
+  deleteMany?: Array<RefreshTokenScalarWhereInput>;
+}

server/src/core/@generated/refresh-token/refresh-token-unchecked-update-many.input.ts

@@ -0,0 +1,26 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-operations.input';
+import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
+import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
+
+@InputType()
+export class RefreshTokenUncheckedUpdateManyInput {
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  id?: StringFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  createdAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  updatedAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true })
+  deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  refreshToken?: StringFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  userId?: StringFieldUpdateOperationsInput;
+}

server/src/core/@generated/refresh-token/refresh-token-unchecked-update-without-user.input.ts

@@ -0,0 +1,23 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-operations.input';
+import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
+import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
+
+@InputType()
+export class RefreshTokenUncheckedUpdateWithoutUserInput {
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  id?: StringFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  createdAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  updatedAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true })
+  deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  refreshToken?: StringFieldUpdateOperationsInput;
+}

server/src/core/@generated/refresh-token/refresh-token-unchecked-update.input.ts

@@ -0,0 +1,26 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-operations.input';
+import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
+import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
+
+@InputType()
+export class RefreshTokenUncheckedUpdateInput {
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  id?: StringFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  createdAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  updatedAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true })
+  deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  refreshToken?: StringFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  userId?: StringFieldUpdateOperationsInput;
+}

server/src/core/@generated/refresh-token/refresh-token-update-many-mutation.input.ts

@@ -0,0 +1,23 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-operations.input';
+import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
+import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
+
+@InputType()
+export class RefreshTokenUpdateManyMutationInput {
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  id?: StringFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  createdAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  updatedAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true })
+  deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  refreshToken?: StringFieldUpdateOperationsInput;
+}

server/src/core/@generated/refresh-token/refresh-token-update-many-with-where-without-user.input.ts

@@ -0,0 +1,16 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { RefreshTokenScalarWhereInput } from './refresh-token-scalar-where.input';
+import { Type } from 'class-transformer';
+import { RefreshTokenUpdateManyMutationInput } from './refresh-token-update-many-mutation.input';
+
+@InputType()
+export class RefreshTokenUpdateManyWithWhereWithoutUserInput {
+  @Field(() => RefreshTokenScalarWhereInput, { nullable: false })
+  @Type(() => RefreshTokenScalarWhereInput)
+  where!: RefreshTokenScalarWhereInput;
+
+  @Field(() => RefreshTokenUpdateManyMutationInput, { nullable: false })
+  @Type(() => RefreshTokenUpdateManyMutationInput)
+  data!: RefreshTokenUpdateManyMutationInput;
+}

server/src/core/@generated/refresh-token/refresh-token-update-many-without-user-nested.input.ts

@@ -0,0 +1,66 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { RefreshTokenCreateWithoutUserInput } from './refresh-token-create-without-user.input';
+import { Type } from 'class-transformer';
+import { RefreshTokenCreateOrConnectWithoutUserInput } from './refresh-token-create-or-connect-without-user.input';
+import { RefreshTokenUpsertWithWhereUniqueWithoutUserInput } from './refresh-token-upsert-with-where-unique-without-user.input';
+import { RefreshTokenCreateManyUserInputEnvelope } from './refresh-token-create-many-user-input-envelope.input';
+import { RefreshTokenWhereUniqueInput } from './refresh-token-where-unique.input';
+import { RefreshTokenUpdateWithWhereUniqueWithoutUserInput } from './refresh-token-update-with-where-unique-without-user.input';
+import { RefreshTokenUpdateManyWithWhereWithoutUserInput } from './refresh-token-update-many-with-where-without-user.input';
+import { RefreshTokenScalarWhereInput } from './refresh-token-scalar-where.input';
+
+@InputType()
+export class RefreshTokenUpdateManyWithoutUserNestedInput {
+  @Field(() => [RefreshTokenCreateWithoutUserInput], { nullable: true })
+  @Type(() => RefreshTokenCreateWithoutUserInput)
+  create?: Array<RefreshTokenCreateWithoutUserInput>;
+
+  @Field(() => [RefreshTokenCreateOrConnectWithoutUserInput], {
+    nullable: true,
+  })
+  @Type(() => RefreshTokenCreateOrConnectWithoutUserInput)
+  connectOrCreate?: Array<RefreshTokenCreateOrConnectWithoutUserInput>;
+
+  @Field(() => [RefreshTokenUpsertWithWhereUniqueWithoutUserInput], {
+    nullable: true,
+  })
+  @Type(() => RefreshTokenUpsertWithWhereUniqueWithoutUserInput)
+  upsert?: Array<RefreshTokenUpsertWithWhereUniqueWithoutUserInput>;
+
+  @Field(() => RefreshTokenCreateManyUserInputEnvelope, { nullable: true })
+  @Type(() => RefreshTokenCreateManyUserInputEnvelope)
+  createMany?: RefreshTokenCreateManyUserInputEnvelope;
+
+  @Field(() => [RefreshTokenWhereUniqueInput], { nullable: true })
+  @Type(() => RefreshTokenWhereUniqueInput)
+  set?: Array<RefreshTokenWhereUniqueInput>;
+
+  @Field(() => [RefreshTokenWhereUniqueInput], { nullable: true })
+  @Type(() => RefreshTokenWhereUniqueInput)
+  disconnect?: Array<RefreshTokenWhereUniqueInput>;
+
+  @Field(() => [RefreshTokenWhereUniqueInput], { nullable: true })
+  @Type(() => RefreshTokenWhereUniqueInput)
+  delete?: Array<RefreshTokenWhereUniqueInput>;
+
+  @Field(() => [RefreshTokenWhereUniqueInput], { nullable: true })
+  @Type(() => RefreshTokenWhereUniqueInput)
+  connect?: Array<RefreshTokenWhereUniqueInput>;
+
+  @Field(() => [RefreshTokenUpdateWithWhereUniqueWithoutUserInput], {
+    nullable: true,
+  })
+  @Type(() => RefreshTokenUpdateWithWhereUniqueWithoutUserInput)
+  update?: Array<RefreshTokenUpdateWithWhereUniqueWithoutUserInput>;
+
+  @Field(() => [RefreshTokenUpdateManyWithWhereWithoutUserInput], {
+    nullable: true,
+  })
+  @Type(() => RefreshTokenUpdateManyWithWhereWithoutUserInput)
+  updateMany?: Array<RefreshTokenUpdateManyWithWhereWithoutUserInput>;
+
+  @Field(() => [RefreshTokenScalarWhereInput], { nullable: true })
+  @Type(() => RefreshTokenScalarWhereInput)
+  deleteMany?: Array<RefreshTokenScalarWhereInput>;
+}

server/src/core/@generated/refresh-token/refresh-token-update-with-where-unique-without-user.input.ts

@@ -0,0 +1,16 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { RefreshTokenWhereUniqueInput } from './refresh-token-where-unique.input';
+import { Type } from 'class-transformer';
+import { RefreshTokenUpdateWithoutUserInput } from './refresh-token-update-without-user.input';
+
+@InputType()
+export class RefreshTokenUpdateWithWhereUniqueWithoutUserInput {
+  @Field(() => RefreshTokenWhereUniqueInput, { nullable: false })
+  @Type(() => RefreshTokenWhereUniqueInput)
+  where!: RefreshTokenWhereUniqueInput;
+
+  @Field(() => RefreshTokenUpdateWithoutUserInput, { nullable: false })
+  @Type(() => RefreshTokenUpdateWithoutUserInput)
+  data!: RefreshTokenUpdateWithoutUserInput;
+}

server/src/core/@generated/refresh-token/refresh-token-update-without-user.input.ts

@@ -0,0 +1,23 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-operations.input';
+import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
+import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
+
+@InputType()
+export class RefreshTokenUpdateWithoutUserInput {
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  id?: StringFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  createdAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  updatedAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true })
+  deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  refreshToken?: StringFieldUpdateOperationsInput;
+}

server/src/core/@generated/refresh-token/refresh-token-update.input.ts

@@ -0,0 +1,29 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-operations.input';
+import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
+import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
+import { UserUpdateOneRequiredWithoutRefreshTokensNestedInput } from '../user/user-update-one-required-without-refresh-tokens-nested.input';
+
+@InputType()
+export class RefreshTokenUpdateInput {
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  id?: StringFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  createdAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  updatedAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true })
+  deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  refreshToken?: StringFieldUpdateOperationsInput;
+
+  @Field(() => UserUpdateOneRequiredWithoutRefreshTokensNestedInput, {
+    nullable: true,
+  })
+  user?: UserUpdateOneRequiredWithoutRefreshTokensNestedInput;
+}

server/src/core/@generated/refresh-token/refresh-token-upsert-with-where-unique-without-user.input.ts

@@ -0,0 +1,21 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { RefreshTokenWhereUniqueInput } from './refresh-token-where-unique.input';
+import { Type } from 'class-transformer';
+import { RefreshTokenUpdateWithoutUserInput } from './refresh-token-update-without-user.input';
+import { RefreshTokenCreateWithoutUserInput } from './refresh-token-create-without-user.input';
+
+@InputType()
+export class RefreshTokenUpsertWithWhereUniqueWithoutUserInput {
+  @Field(() => RefreshTokenWhereUniqueInput, { nullable: false })
+  @Type(() => RefreshTokenWhereUniqueInput)
+  where!: RefreshTokenWhereUniqueInput;
+
+  @Field(() => RefreshTokenUpdateWithoutUserInput, { nullable: false })
+  @Type(() => RefreshTokenUpdateWithoutUserInput)
+  update!: RefreshTokenUpdateWithoutUserInput;
+
+  @Field(() => RefreshTokenCreateWithoutUserInput, { nullable: false })
+  @Type(() => RefreshTokenCreateWithoutUserInput)
+  create!: RefreshTokenCreateWithoutUserInput;
+}

server/src/core/@generated/refresh-token/refresh-token-where-unique.input.ts

@@ -0,0 +1,8 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+
+@InputType()
+export class RefreshTokenWhereUniqueInput {
+  @Field(() => String, { nullable: true })
+  id?: string;
+}

server/src/core/@generated/refresh-token/refresh-token-where.input.ts

@@ -0,0 +1,39 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { StringFilter } from '../prisma/string-filter.input';
+import { DateTimeFilter } from '../prisma/date-time-filter.input';
+import { DateTimeNullableFilter } from '../prisma/date-time-nullable-filter.input';
+import { UserRelationFilter } from '../user/user-relation-filter.input';
+
+@InputType()
+export class RefreshTokenWhereInput {
+  @Field(() => [RefreshTokenWhereInput], { nullable: true })
+  AND?: Array<RefreshTokenWhereInput>;
+
+  @Field(() => [RefreshTokenWhereInput], { nullable: true })
+  OR?: Array<RefreshTokenWhereInput>;
+
+  @Field(() => [RefreshTokenWhereInput], { nullable: true })
+  NOT?: Array<RefreshTokenWhereInput>;
+
+  @Field(() => StringFilter, { nullable: true })
+  id?: StringFilter;
+
+  @Field(() => DateTimeFilter, { nullable: true })
+  createdAt?: DateTimeFilter;
+
+  @Field(() => DateTimeFilter, { nullable: true })
+  updatedAt?: DateTimeFilter;
+
+  @Field(() => DateTimeNullableFilter, { nullable: true })
+  deletedAt?: DateTimeNullableFilter;
+
+  @Field(() => StringFilter, { nullable: true })
+  refreshToken?: StringFilter;
+
+  @Field(() => StringFilter, { nullable: true })
+  userId?: StringFilter;
+
+  @Field(() => UserRelationFilter, { nullable: true })
+  user?: UserRelationFilter;
+}

server/src/core/@generated/refresh-token/refresh-token.model.ts

@@ -0,0 +1,28 @@
+import { Field } from '@nestjs/graphql';
+import { ObjectType } from '@nestjs/graphql';
+import { ID } from '@nestjs/graphql';
+import { User } from '../user/user.model';
+
+@ObjectType()
+export class RefreshToken {
+  @Field(() => ID, { nullable: false })
+  id!: string;
+
+  @Field(() => Date, { nullable: false })
+  createdAt!: Date;
+
+  @Field(() => Date, { nullable: false })
+  updatedAt!: Date;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt!: Date | null;
+
+  @Field(() => String, { nullable: false })
+  refreshToken!: string;
+
+  @Field(() => String, { nullable: false })
+  userId!: string;
+
+  @Field(() => User, { nullable: false })
+  user?: User;
+}

server/src/core/@generated/refresh-token/update-many-refresh-token.args.ts

@@ -0,0 +1,16 @@
+import { Field } from '@nestjs/graphql';
+import { ArgsType } from '@nestjs/graphql';
+import { RefreshTokenUpdateManyMutationInput } from './refresh-token-update-many-mutation.input';
+import { Type } from 'class-transformer';
+import { RefreshTokenWhereInput } from './refresh-token-where.input';
+
+@ArgsType()
+export class UpdateManyRefreshTokenArgs {
+  @Field(() => RefreshTokenUpdateManyMutationInput, { nullable: false })
+  @Type(() => RefreshTokenUpdateManyMutationInput)
+  data!: RefreshTokenUpdateManyMutationInput;
+
+  @Field(() => RefreshTokenWhereInput, { nullable: true })
+  @Type(() => RefreshTokenWhereInput)
+  where?: RefreshTokenWhereInput;
+}

server/src/core/@generated/refresh-token/update-one-refresh-token.args.ts

@@ -0,0 +1,16 @@
+import { Field } from '@nestjs/graphql';
+import { ArgsType } from '@nestjs/graphql';
+import { RefreshTokenUpdateInput } from './refresh-token-update.input';
+import { Type } from 'class-transformer';
+import { RefreshTokenWhereUniqueInput } from './refresh-token-where-unique.input';
+
+@ArgsType()
+export class UpdateOneRefreshTokenArgs {
+  @Field(() => RefreshTokenUpdateInput, { nullable: false })
+  @Type(() => RefreshTokenUpdateInput)
+  data!: RefreshTokenUpdateInput;
+
+  @Field(() => RefreshTokenWhereUniqueInput, { nullable: false })
+  @Type(() => RefreshTokenWhereUniqueInput)
+  where!: RefreshTokenWhereUniqueInput;
+}

server/src/core/@generated/refresh-token/upsert-one-refresh-token.args.ts

@@ -0,0 +1,21 @@
+import { Field } from '@nestjs/graphql';
+import { ArgsType } from '@nestjs/graphql';
+import { RefreshTokenWhereUniqueInput } from './refresh-token-where-unique.input';
+import { Type } from 'class-transformer';
+import { RefreshTokenCreateInput } from './refresh-token-create.input';
+import { RefreshTokenUpdateInput } from './refresh-token-update.input';
+
+@ArgsType()
+export class UpsertOneRefreshTokenArgs {
+  @Field(() => RefreshTokenWhereUniqueInput, { nullable: false })
+  @Type(() => RefreshTokenWhereUniqueInput)
+  where!: RefreshTokenWhereUniqueInput;
+
+  @Field(() => RefreshTokenCreateInput, { nullable: false })
+  @Type(() => RefreshTokenCreateInput)
+  create!: RefreshTokenCreateInput;
+
+  @Field(() => RefreshTokenUpdateInput, { nullable: false })
+  @Type(() => RefreshTokenUpdateInput)
+  update!: RefreshTokenUpdateInput;
+}