Fix graphql queries

server/src/api/resolvers/company.resolver.ts

@@ -0,0 +1,60 @@
+import { PrismaClient } from '@prisma/client';
+import { Company } from '../generated-graphql/models';
+import { Resolver, Query, Args, Mutation } from '@nestjs/graphql';
+import { FindManyCompanyArgs } from '../generated-graphql/resolvers/crud/Company/args/FindManyCompanyArgs';
+import { DeleteOneCompanyArgs } from '../generated-graphql/resolvers/crud/Company/args/DeleteOneCompanyArgs';
+import { UpdateOneCompanyArgs } from '../generated-graphql/resolvers/crud/Company/args/UpdateOneCompanyArgs';
+import { CreateOneCompanyArgs } from '../generated-graphql/resolvers/crud/Company/args/CreateOneCompanyArgs';
+import {
+  AffectedRowsOutput,
+  DeleteManyCompanyArgs,
+} from '../generated-graphql';
+
+@Resolver(() => Company)
+export class CompanyResolver {
+  constructor(private readonly prismaClient: PrismaClient) {}
+  @Query(() => [Company])
+  async companies(@Args() args: FindManyCompanyArgs) {
+    return this.prismaClient.company.findMany(args);
+  }
+
+  @Mutation(() => Company, {
+    nullable: true,
+  })
+  async deleteOneCompany(
+    @Args() args: DeleteOneCompanyArgs,
+  ): Promise<Company | null> {
+    return this.prismaClient.company.delete(args);
+  }
+
+  @Mutation(() => Company, {
+    nullable: true,
+  })
+  async updateOneCompany(
+    @Args() args: UpdateOneCompanyArgs,
+  ): Promise<Company | null> {
+    return this.prismaClient.company.update({
+      ...args,
+    });
+  }
+
+  @Mutation(() => Company, {
+    nullable: false,
+  })
+  async createOneCompany(@Args() args: CreateOneCompanyArgs): Promise<Company> {
+    return this.prismaClient.company.create({
+      ...args,
+    });
+  }
+
+  @Mutation(() => AffectedRowsOutput, {
+    nullable: false,
+  })
+  async deleteManyCompany(
+    @Args() args: DeleteManyCompanyArgs,
+  ): Promise<AffectedRowsOutput> {
+    return this.prismaClient.company.deleteMany({
+      ...args,
+    });
+  }
+}

server/src/api/resolvers/people.resolver.ts

@@ -0,0 +1,53 @@
+import { PrismaClient } from '@prisma/client';
+import { Person } from '../generated-graphql/models';
+import { Resolver, Query, Args, Mutation } from '@nestjs/graphql';
+import { FindManyPersonArgs } from '../generated-graphql/resolvers/crud/Person/args/FindManyPersonArgs';
+import { UpdateOnePersonArgs } from '../generated-graphql/resolvers/crud/Person/args/UpdateOnePersonArgs';
+import { CreateOnePersonArgs } from '../generated-graphql/resolvers/crud/Person/args/CreateOnePersonArgs';
+import { DeleteManyPersonArgs } from '../generated-graphql/resolvers/crud/Person/args/DeleteManyPersonArgs';
+import { AffectedRowsOutput } from '../generated-graphql/resolvers/outputs/AffectedRowsOutput';
+
+@Resolver(() => Person)
+export class PeopleResolver {
+  constructor(private readonly prismaClient: PrismaClient) {}
+
+  @Query(() => [Person], {
+    nullable: false,
+  })
+  async people(@Args() args: FindManyPersonArgs): Promise<Person[]> {
+    return this.prismaClient.person.findMany({
+      ...args,
+    });
+  }
+
+  @Mutation(() => Person, {
+    nullable: true,
+  })
+  async updateOnePerson(
+    @Args() args: UpdateOnePersonArgs,
+  ): Promise<Person | null> {
+    return this.prismaClient.person.update({
+      ...args,
+    });
+  }
+
+  @Mutation(() => Person, {
+    nullable: false,
+  })
+  async createOnePerson(@Args() args: CreateOnePersonArgs): Promise<Person> {
+    return this.prismaClient.person.create({
+      ...args,
+    });
+  }
+
+  @Mutation(() => AffectedRowsOutput, {
+    nullable: false,
+  })
+  async deleteManyPerson(
+    @Args() args: DeleteManyPersonArgs,
+  ): Promise<AffectedRowsOutput> {
+    return this.prismaClient.person.deleteMany({
+      ...args,
+    });
+  }
+}

server/src/api/resolvers/relation-resolver/workspace-member-relations.resolver.ts

@@ -0,0 +1,43 @@
+import * as TypeGraphQL from '@nestjs/graphql';
+import type { GraphQLResolveInfo } from 'graphql';
+import { User } from '../../generated-graphql/models/User';
+import { Workspace } from '../../generated-graphql/models/Workspace';
+import { WorkspaceMember } from '../../generated-graphql/models/WorkspaceMember';
+import { PrismaClient } from '@prisma/client';
+
+@TypeGraphQL.Resolver(() => WorkspaceMember)
+export class WorkspaceMemberRelationsResolver {
+  constructor(private readonly prismaClient: PrismaClient) {}
+
+  @TypeGraphQL.ResolveField(() => User, {
+    nullable: false,
+  })
+  async user(
+    @TypeGraphQL.Parent() workspaceMember: WorkspaceMember,
+    @TypeGraphQL.Info() info: GraphQLResolveInfo,
+  ): Promise<User> {
+    return this.prismaClient.workspaceMember
+      .findUniqueOrThrow({
+        where: {
+          id: workspaceMember.id,
+        },
+      })
+      .user({});
+  }
+
+  @TypeGraphQL.ResolveField((_type) => Workspace, {
+    nullable: false,
+  })
+  async workspace(
+    @TypeGraphQL.Parent() workspaceMember: WorkspaceMember,
+    @TypeGraphQL.Info() info: GraphQLResolveInfo,
+  ): Promise<Workspace> {
+    return this.prismaClient.workspaceMember
+      .findUniqueOrThrow({
+        where: {
+          id: workspaceMember.id,
+        },
+      })
+      .workspace({});
+  }
+}

server/src/api/resolvers/relations/company-relations.resolver.ts

@@ -0,0 +1,58 @@
+import * as TypeGraphQL from '@nestjs/graphql';
+import { Company } from '../../generated-graphql/models/Company';
+import { Person } from '../../generated-graphql/models/Person';
+import { User } from '../../generated-graphql/models/User';
+import { Workspace } from '../../generated-graphql/models/Workspace';
+import { PrismaClient } from '@prisma/client';
+import { CompanyPeopleArgs } from '../../generated-graphql/resolvers/relations/Company/args/CompanyPeopleArgs';
+
+@TypeGraphQL.Resolver(() => Company)
+export class CompanyRelationsResolver {
+  constructor(private readonly prismaClient: PrismaClient) {}
+
+  @TypeGraphQL.ResolveField(() => User, {
+    nullable: true,
+  })
+  async accountOwner(
+    @TypeGraphQL.Parent() company: Company,
+  ): Promise<User | null> {
+    return this.prismaClient.company
+      .findUniqueOrThrow({
+        where: {
+          id: company.id,
+        },
+      })
+      .accountOwner({});
+  }
+
+  @TypeGraphQL.ResolveField(() => [Person], {
+    nullable: false,
+  })
+  async people(
+    @TypeGraphQL.Root() company: Company,
+    @TypeGraphQL.Args() args: CompanyPeopleArgs,
+  ): Promise<Person[]> {
+    return this.prismaClient.company
+      .findUniqueOrThrow({
+        where: {
+          id: company.id,
+        },
+      })
+      .people({
+        ...args,
+      });
+  }
+
+  @TypeGraphQL.ResolveField(() => Workspace, {
+    nullable: false,
+  })
+  async workspace(@TypeGraphQL.Root() company: Company): Promise<Workspace> {
+    return this.prismaClient.company
+      .findUniqueOrThrow({
+        where: {
+          id: company.id,
+        },
+      })
+      .workspace({});
+  }
+}

server/src/api/resolvers/relations/people-relations.resolver.ts

@@ -0,0 +1,36 @@
+import * as TypeGraphQL from '@nestjs/graphql';
+import { Company } from '../../generated-graphql/models/Company';
+import { Person } from '../../generated-graphql/models/Person';
+import { Workspace } from '../../generated-graphql/models/Workspace';
+import { PrismaClient } from '@prisma/client';
+
+@TypeGraphQL.Resolver(() => Person)
+export class PersonRelationsResolver {
+  constructor(private readonly prismaClient: PrismaClient) {}
+
+  @TypeGraphQL.ResolveField(() => Company, {
+    nullable: true,
+  })
+  async company(@TypeGraphQL.Parent() person: Person): Promise<Company | null> {
+    return this.prismaClient.person
+      .findUniqueOrThrow({
+        where: {
+          id: person.id,
+        },
+      })
+      .company({});
+  }
+
+  @TypeGraphQL.ResolveField(() => Workspace, {
+    nullable: false,
+  })
+  async workspace(@TypeGraphQL.Parent() person: Person): Promise<Workspace> {
+    return this.prismaClient.person
+      .findUniqueOrThrow({
+        where: {
+          id: person.id,
+        },
+      })
+      .workspace({});
+  }
+}

server/src/api/resolvers/relations/user-relations.resolver.ts

@@ -0,0 +1,67 @@
+import * as TypeGraphQL from '@nestjs/graphql';
+import type { GraphQLResolveInfo } from 'graphql';
+import { Company } from '../../generated-graphql/models/Company';
+import { RefreshToken } from '../../generated-graphql/models/RefreshToken';
+import { User } from '../../generated-graphql/models/User';
+import { WorkspaceMember } from '../../generated-graphql/models/WorkspaceMember';
+import { PrismaClient } from '@prisma/client';
+import { UserCompaniesArgs } from '../../generated-graphql/resolvers/relations/User/args/UserCompaniesArgs';
+import { UserRefreshTokensArgs } from '../../generated-graphql/resolvers/relations/User/args/UserRefreshTokensArgs';
+
+@TypeGraphQL.Resolver(() => User)
+export class UserRelationsResolver {
+  constructor(private readonly prismaClient: PrismaClient) {}
+
+  @TypeGraphQL.ResolveField(() => WorkspaceMember, {
+    nullable: true,
+  })
+  async WorkspaceMember(
+    @TypeGraphQL.Parent() user: User,
+  ): Promise<WorkspaceMember | null> {
+    return this.prismaClient.user
+      .findUniqueOrThrow({
+        where: {
+          id: user.id,
+        },
+      })
+      .WorkspaceMember({});
+  }
+
+  @TypeGraphQL.ResolveField(() => [Company], {
+    nullable: false,
+  })
+  async companies(
+    @TypeGraphQL.Parent() user: User,
+    @TypeGraphQL.Info() info: GraphQLResolveInfo,
+    @TypeGraphQL.Args() args: UserCompaniesArgs,
+  ): Promise<Company[]> {
+    return this.prismaClient.user
+      .findUniqueOrThrow({
+        where: {
+          id: user.id,
+        },
+      })
+      .companies({
+        ...args,
+      });
+  }
+
+  @TypeGraphQL.ResolveField(() => [RefreshToken], {
+    nullable: false,
+  })
+  async RefreshTokens(
+    @TypeGraphQL.Parent() user: User,
+    @TypeGraphQL.Info() info: GraphQLResolveInfo,
+    @TypeGraphQL.Args() args: UserRefreshTokensArgs,
+  ): Promise<RefreshToken[]> {
+    return this.prismaClient.user
+      .findUniqueOrThrow({
+        where: {
+          id: user.id,
+        },
+      })
+      .RefreshTokens({
+        ...args,
+      });
+  }
+}

server/src/api/resolvers/relations/workspace-member-relations.resolver.ts

@@ -0,0 +1,43 @@
+import * as TypeGraphQL from '@nestjs/graphql';
+import type { GraphQLResolveInfo } from 'graphql';
+import { User } from '../../generated-graphql/models/User';
+import { Workspace } from '../../generated-graphql/models/Workspace';
+import { WorkspaceMember } from '../../generated-graphql/models/WorkspaceMember';
+import { PrismaClient } from '@prisma/client';
+
+@TypeGraphQL.Resolver(() => WorkspaceMember)
+export class WorkspaceMemberRelationsResolver {
+  constructor(private readonly prismaClient: PrismaClient) {}
+
+  @TypeGraphQL.ResolveField(() => User, {
+    nullable: false,
+  })
+  async user(
+    @TypeGraphQL.Parent() workspaceMember: WorkspaceMember,
+    @TypeGraphQL.Info() info: GraphQLResolveInfo,
+  ): Promise<User> {
+    return this.prismaClient.workspaceMember
+      .findUniqueOrThrow({
+        where: {
+          id: workspaceMember.id,
+        },
+      })
+      .user({});
+  }
+
+  @TypeGraphQL.ResolveField((_type) => Workspace, {
+    nullable: false,
+  })
+  async workspace(
+    @TypeGraphQL.Parent() workspaceMember: WorkspaceMember,
+    @TypeGraphQL.Info() info: GraphQLResolveInfo,
+  ): Promise<Workspace> {
+    return this.prismaClient.workspaceMember
+      .findUniqueOrThrow({
+        where: {
+          id: workspaceMember.id,
+        },
+      })
+      .workspace({});
+  }
+}

server/src/api/resolvers/user.resolver.ts

@@ -0,0 +1,28 @@
+import { PrismaClient } from '@prisma/client';
+import { Person, User } from '../generated-graphql/models';
+import { Resolver, Query, Args, Mutation } from '@nestjs/graphql';
+import { FindManyUserArgs } from '../generated-graphql/resolvers/crud/User/args/FindManyUserArgs';
+import { FindUniqueUserOrThrowArgs } from '../generated-graphql';
+
+@Resolver(() => User)
+export class UserResolver {
+  constructor(private readonly prismaClient: PrismaClient) {}
+
+  @Query(() => [User], {
+    nullable: false,
+  })
+  async users(@Args() args: FindManyUserArgs): Promise<User[]> {
+    return this.prismaClient.user.findMany({
+      ...args,
+    });
+  }
+
+  @Query(() => User, {
+    nullable: true,
+  })
+  async getUser(@Args() args: FindUniqueUserOrThrowArgs): Promise<User | null> {
+    return this.prismaClient.user.findUniqueOrThrow({
+      ...args,
+    });
+  }
+}