seperated backend and frontend

backend/src/people/dto/create-person.input.ts

@@ -0,0 +1,7 @@
+import { InputType, Field, ID } from '@nestjs/graphql';
+
+
+@InputType()
+export class CreatePersonInput {
+
+}

backend/src/people/people.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { PeopleResolver } from './people.resolver';
+import { PeopleService } from './people.service';
+import { MongooseModule } from '@nestjs/mongoose';
+import { Person, PersonSchema } from '@/models/person.model';
+
+@Module({
+  imports: [MongooseModule.forFeature([{ name: Person.name, schema: PersonSchema }])],
+  providers: [PeopleResolver, PeopleService]
+})
+export class PeopleModule { }

backend/src/people/people.resolver.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { PeopleResolver } from './people.resolver';
+
+describe('PeopleResolver', () => {
+  let resolver: PeopleResolver;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [PeopleResolver],
+    }).compile();
+
+    resolver = module.get<PeopleResolver>(PeopleResolver);
+  });
+
+  it('should be defined', () => {
+    expect(resolver).toBeDefined();
+  });
+});

backend/src/people/people.resolver.ts

@@ -0,0 +1,29 @@
+import { Resolver, Query, Args, ID, Info, Mutation } from '@nestjs/graphql';
+import { Types } from 'mongoose';
+import { Person } from '@/models/person.model';
+import { PeopleService } from '@/people/people.service';
+import { CreatePersonInput } from './dto/create-person.input';
+import graphqlFields from 'graphql-fields';
+import type { GraphQLResolveInfo } from 'graphql';
+
+@Resolver()
+export class PeopleResolver {
+
+    constructor(private readonly peopleService: PeopleService) { }
+
+    @Query(() => [Person], { name: 'Persons' })
+    async getPersons(@Info() info: GraphQLResolveInfo): Promise<Person[]> {
+        const fields = graphqlFields(info); const projection = this.peopleService.buildProjection(fields); return this.peopleService.findAll(projection);
+    }
+
+    @Query(() => Person, { name: 'Person', nullable: true })
+    async getPerson(@Args('id', { type: () => ID }) id: string, @Info() info: GraphQLResolveInfo): Promise<Person | null> {
+        const fields = graphqlFields(info); const projection = this.peopleService.buildProjection(fields); return this.peopleService.findById(new Types.ObjectId(id), projection);
+    }
+
+    @Mutation(() => Person, { name: 'createPerson' })
+    async createPerson(@Args('input') input: CreatePersonInput): Promise<Person> {
+        return this.peopleService.create(input);
+    }
+
+}

backend/src/people/people.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { PeopleService } from './people.service';
+
+describe('PeopleService', () => {
+  let service: PeopleService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [PeopleService],
+    }).compile();
+
+    service = module.get<PeopleService>(PeopleService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

backend/src/people/people.service.ts

@@ -0,0 +1,36 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Types, Model } from 'mongoose';
+import { Person, PersonDocument } from '@/models/person.model';
+import { CreatePersonInput } from './dto/create-person.input';
+
+@Injectable()
+export class PeopleService {
+
+    constructor(
+        @InjectModel(Person.name) private readonly personModel: Model<PersonDocument>
+    ) { }
+
+    async findAll(projection?: any): Promise<PersonDocument[]> {
+        return this.personModel.find({}, projection, { lean: false }).populate({ path: 'person', select: projection?.person }).exec();
+    }
+
+    async findById(id: Types.ObjectId, projection?: any): Promise<PersonDocument | null> {
+        return this.personModel.findById(id, projection, { lean: false }).populate({ path: 'person', select: projection?.person }).exec();
+    }
+
+    async create(input: CreatePersonInput): Promise<PersonDocument> {
+        const person = new this.personModel(input);
+        return person.save();
+    }
+
+    buildProjection(fields: Record<string, any>): any {
+        const projection: any = {};
+        for (const key in fields) {
+            if (key === 'person' && typeof fields[key] === 'object') { for (const subField of Object.keys(fields[key])) { projection[`person.${subField}`] = 1 } }
+            else { projection[key] = 1 }
+        }
+        return projection;
+    }
+
+}