Nest.js, Graphql, Typeorm, Postgres mutations - postgresql

I`m a newbee at this technologies and I literally dont understand how to do task. My task: create 2 tables, for categories and tasks, after that create mutation for creating category and tasks(todos).
mutation {
createTodo(input: {
categoryName: “”,
text: “”
}) {
category: {
id
title
}
id
text
isCompleted
}
}
I created objectTypes and input types, but I dont understand how to create such mutation. Example objectTypes and Inputs
#ObjectType()
export class CategoryType {
#Field(() => ID)
id: number
#Field(() => String)
readonly title: string
}
export interface TodoI {
id: number;
text: string;
isCompleted: boolean;
categoryId: number
category: any;
}
#InputType()
export class CategoryInput {
#Field()
readonly title: string
#Field(() => TodoInput,{nullable: true})
readonly todos: TodoI
}
#ObjectType()
export class TodoType {
#Field(() => ID)
id: number
#Field()
readonly text: string
#Field()
readonly isCompleted: boolean
#Field(() => Int)
readonly categoryId: number
}
#InputType()
export class TodoInput {
#Field()
readonly text: string;
#Field()
readonly isCompleted: boolean;
#Field(() => Int)
readonly categoryId: number;
}

Related

How to Implement Typeorm Entity Array of Object

I want to achieve this output:
{
.....,
dependants: [{name: 'john', age: 29},{name: 'doe', age: 17}]
}
I have an entity like this:
class PartnerStaff extends BaseEntity {
constructor(
id: string,
company: string,
branch: string,
dependants: DependantDto[],
) {
super();
this.staffId = id;
this.company = company;
this.branch = branch;
this.dependants = dependants;
}
#PrimaryGeneratedColumn('increment')
id!: number;
#Column({
unique: true,
nullable: true,
})
staffId!: string;
#Column({
nullable: true,
name: 'company',
})
company!: string;
#Column()
branch!: string;
#Column('json', {nullable: true})
dependants?: DependantDto[];
}
And my dependants dto:
class DependantDto {
#IsString()
#IsNotEmpty({ message: 'dependant name is required' })
readonly name!: string;
#IsString()
#IsNotEmpty({ message: 'dependant age is required' })
readonly age!: number;
}
I am getting dependants: ['string'] on swagger.
I have tried these but still not working...
#Column('jsonb', {nullable: true})
#Column({type: 'array', nullable: true})
I was able to solve it this way....
#Column({type: 'json'})
dependants: DependantsDto[];
Then in my PartnerStaffDto, I did ...
#IsOptional()
#ApiModelProperty({
isArray: true
})
dependants: DependantsDto[];
So now I get what i was expecting ealier dependants: [{name: '', age: 0}]

Typegoose, graphql, how to update fields with object types

I have a user schema:
#ObjectType()
export class User {
#Field(() => String)
_id: string;
#Field(() => String)
#prop({ required: true })
userName: string;
#Field(() => UserType)
#prop({ enum: UserType })
userType: UserType;
#Field(() => String)
#prop({ required: true })
email: string;
#prop({ required: true })
password: string;
#Field(() => Employee)
#prop({ required: false })
employee: Employee;
#Field(() => Employer)
#prop({ required: false })
employer: Employer;
}
and the employee field has this schema:
#ObjectType()
class Employee {
#Field(() => String)
firstName: string;
#Field(() => String)
middleName: string;
#Field(() => String)
lastName: string;
#Field(() => String)
birthday: string;
#Field(() => String)
address1: string;
#Field(() => String)
address2: string;
#Field(() => String)
phoneNumber: string;
#Field(() => String)
emailAddress: string;
#Field(() => String)
socialMedia: string;
#Field(() => String)
imageLink: string;
#Field(() => [WorkExperiences])
workExperiences: WorkExperiences[];
#Field(() => Personality)
personality: Personality;
#Field(() => Direction)
direction: Direction;
#Field(() => [Education])
education: Education[];
#Field(() => [Certificates])
certificates: Certificates[];
#Field(() => [Awards])
awards: Awards[];
#Field(() => String)
applications: string;
}
I want to create a login form which only adds email and username then redirect to a onboarding page.
I am trying to create a separate mutations with Education, workExperience and other stuffs.
But I am not sure what I am doing.
What I did so far was to create a resolver for example education:
#Authorized()
#Mutation(() => User)
createEducation(
#Arg("input") input: CreateEducationInput,
#Ctx() context: Context
) {
const user = context.user!;
return this.qualificationService.createEducation({
...input,
user: user?._id,
});
}
But I can't seem to create education and throws some error.
I am not sure if I am doing this correctly. Really need help. Thanks guys!

Flutter Ferry Graphql pointing to the Entitiy not the dto

I have an entity is Nestjs
#Entity({ name: 'recipes' })
#ObjectType()
export class Recipe {
#PrimaryGeneratedColumn()
#Field(() => Int)
id: number;
#Column()
#Field()
videoUrl: string;
#Column()
#Field()
description: string;
}
I also have a create recipe dto
#InputType()
export class CreateRecipeInput {
#Field()
videoUrl: string;
#Field()
description: string;
#Field(() => [String])
ingredientNames: string[];
#Field(() => [String])
instructionNames: string[];
}
in my ferry Graphql I have this
mutation CreateRecipe($createRecipeInput: CreateRecipeInput!) {
createRecipe(createRecipeInput: $createRecipeInput) {
videoUrl
description
ingredientNames
}
}
The problem I have is if I get an error in the property ingredientNames, but if I add that property to the Recipe entity it works. It's like Ferry is not following the Recipe Dto. When I look at the schema.graphql is flutter The create recipe Dto is there.
input CreateRecipeInput {
videoUrl: String!
description: String!
ingredientNames: [String!]!
instructionNames: [String!]!
}

TypeORM PostgreSQL #ManyToOne save violates not-null constraint

I have a basic nestjs app with 3 entities :
document: DocumentEntity has pages: PageEntity[] as #OneToMany relation
page: PageEntity has words: WordEntity[]as #OneToMany relation + #ManyToOne document
word: WordEntity has a #ManyToOne page: PageEntity
This is quite straightforward and the first part of those relations works as expected :
I can save new pages doing so :
async createPage(documentId: number, url: string) {
const document = await this.documentRepository.findOne({ id: documentId });
if (document) {
const pageEntity = new PageEntity();
pageEntity.imgUrl = url;
pageEntity.document = document;
await this.pageRepository.save(pageEntity);
}
}
but when I try to apply the same logic to the words/page relation, it fails. I m not sure why this behaves differently
async postWord(pageId: number, word: { text: string }) {
const page = await this.pageRepository.findOne({ id: pageId });
if (page) {
const wordEntity = new WordEntity();
wordEntity.text = word.text;
wordEntity.page = page;
await this.wordRepository.save(wordEntity);
}
}
Error Message :
[ExceptionsHandler] null value in column "pageId" of relation "word_entity" violates not-null constraint +107723ms
QueryFailedError: null value in column "pageId" of relation "word_entity" violates not-null constraint
here are the entities declarations :
// document.entity.ts
#Entity()
class DocumentEntity {
#PrimaryGeneratedColumn()
public id?: number;
#Column()
public name: string;
#Column()
public locale: string;
#Column()
public pdfUrl: string;
#Column()
public folderPath: string;
#OneToMany(() => PageEntity, (page) => page.document, {
primary: true,
eager: true,
cascade: true,
})
public pages?: PageEntity[];
}
export default DocumentEntity;
// page.entity.ts
#Entity()
class PageEntity {
#PrimaryGeneratedColumn()
public id?: number;
#Column({ nullable: true })
public pageNumber?: number;
#Column({ nullable: true })
public text?: string;
#Column()
public imgUrl: string;
#OneToMany(() => WordEntity, (word) => word.page, {
eager: true,
onDelete: 'CASCADE',
primary: true,
})
words?: WordEntity[];
#ManyToOne(() => DocumentEntity, {
primary: true,
onDelete: 'CASCADE',
})
#JoinColumn()
public document: DocumentEntity;
}
export default PageEntity;
// word.entity.ts
#Entity()
class WordEntity {
#PrimaryGeneratedColumn()
public id?: number;
#ManyToOne(() => PageEntity, {
nullable: true,
primary: true,
onDelete: 'CASCADE',
})
#JoinColumn()
public page!: PageEntity;
#Column()
public text: string;
#Column({ type: 'decimal', nullable: true })
public confidence?: number;
}
Try this:
#Entity()
class WordEntity {
.....
#ManyToOne(() => PageEntity, {
nullable: true,
primary: true,
onDelete: 'CASCADE',
})
#JoinColumn({
name: 'pageId',
referencedColumnName: 'id',
})
page?: PageEntity;
#Column({ nullable: true })
pageId?: number
.....
}
async postWord(pageId: number, word: { text: string }) {
const wordEntity = new WordEntity();
wordEntity.text = word.text;
// check if the pageId exists, maybe inside Dto with a decorator
wordEntity.pageId = pageId;
await this.wordRepository.save(wordEntity);
}
You need to remove the primary: true from your #ManyToOne relation because a primary relation cannot be set as NULL

NestJS Insert a Comment into a user blog post

I have an app where an user can create a list of Recipes and each Recipe can have multiple comments that many users can post.
This is what im trying to do:
I have a comments Enitity:
import {
Entity,
PrimaryGeneratedColumn,
Column,
BeforeUpdate,
ManyToOne,
JoinColumn,
ManyToMany,
} from 'typeorm';
import { UserEntity } from 'src/user/models/user.entity';
import { RecipeEntity } from 'src/recipe/model/recipe-entry.entity';
import { User } from 'src/user/models/user.interface';
#Entity('comments_entry')
export class CommentsEntity {
#PrimaryGeneratedColumn()
id: number;
#Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' })
createdAt: Date;
#Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' })
updatedAt: Date;
#BeforeUpdate()
updateTimestamp() {
this.updatedAt = new Date();
}
#ManyToOne(
type => UserEntity,
user => user.username,
)
author: UserEntity;
#Column()
recipe_id: number;
#Column()
author_id: number;
#ManyToOne(
type => RecipeEntity,
recipe => recipe.comment,
)
#JoinColumn({ name: 'recipe_id', referencedColumnName: 'id' })
comment: RecipeEntity;
}
Linked to a Recipe entity:
import {
Entity,
PrimaryGeneratedColumn,
Column,
BeforeUpdate,
ManyToOne,
JoinColumn,
OneToMany,
JoinTable,
ManyToMany,
} from 'typeorm';
import { UserEntity } from 'src/user/models/user.entity';
import { CommentsEntity } from 'src/comments/model/comments.entity';
#Entity('recipe_entry')
export class RecipeEntity {
#PrimaryGeneratedColumn()
id: number;
#Column()
title: string;
#Column()
slug: string;
#Column('text', { array: true, nullable: true })
ingr: string[];
#Column({ default: '' })
description: string;
#Column({ default: '' })
body: string;
#Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' })
createdAt: Date;
#Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' })
updatedAt: Date;
#BeforeUpdate()
updateTimestamp() {
this.updatedAt = new Date();
}
#Column({ nullable: true })
headerImage: string;
#Column({ nullable: true })
publishedDate: Date;
#Column({ nullable: true })
isPublished: boolean;
#Column()
user_id: number;
#ManyToOne(
type => UserEntity,
user => user.recipeEntries,
)
#JoinColumn({ name: 'user_id', referencedColumnName: 'id' })
author: UserEntity;
#Column({ default: 0 })
totalWeight: number;
#Column('text', { array: true, default: '{}' })
dietLabels: string[];
#Column({ default: 0 })
calorieQuantity: number;
#Column({ default: 0 })
proteinQuantity: number;
#Column({ default: 0 })
carbQuantity: number;
#Column({ default: 0 })
fatQuantity: number;
#Column({ default: 0 })
sugarQuantity: number;
#Column('text', { array: true, nullable: true })
likes: string[];
#Column({ default: false, nullable: true })
isLiked: boolean;
#OneToMany(
type => CommentsEntity,
comments => comments.comment,
)
comment: CommentsEntity[];
}
Linked to an User entity:
import {
Entity,
PrimaryGeneratedColumn,
Column,
BeforeInsert,
OneToMany,
} from 'typeorm';
import { UserRole } from './user.interface';
import { RecipeEntity } from 'src/recipe/model/recipe-entry.entity';
import { CommentsEntity } from 'src/comments/model/comments.entity';
#Entity()
export class UserEntity {
#PrimaryGeneratedColumn()
id: number;
#Column()
name: string;
#Column({ unique: true })
username: string;
#Column({ unique: true })
email: string;
#Column({ select: false })
password: string;
#Column({ type: 'enum', enum: UserRole, default: UserRole.USER })
role: UserRole;
#Column({ nullable: true })
profileImage: string;
#Column({ default: false, nullable: true })
favourite: boolean;
#OneToMany(
type => RecipeEntity,
recipeEntity => recipeEntity.author,
)
recipeEntries: RecipeEntity[];
#OneToMany(
type => CommentsEntity,
recipeEntryEntity => recipeEntryEntity.author,
)
commentEntries: CommentsEntity[];
#BeforeInsert()
emailToLowerCase() {
this.email = this.email.toLowerCase();
}
}
As an user i can post recipes. But im failing to add comments on specific recipes.
2 errors:
When i create a Recipe with some hardcoded comments, the users and recipe table gets filled but the comments_entry table is empty.
And im failing to implement the method to add comments to a specific recipe.
Controller:
#UseGuards(JwtAuthGuard)
#Post('recipe/:id')
createComment(
#Param() params,
#Body() comment: string,
#Request() req,
): Observable<RecipeEntry> {
const user = req.user;
const id = params.id;
return this.recipeService.createComment(user, id, comment);
}
createComment(id: number, commentEntry: string): Observable<RecipeEntry> {
return from(this.findOne(id)).pipe(
switchMap((recipe: RecipeEntry) => {
const newComment = recipe.comment.push(commentEntry);
return this.recipeRepository.save(newComment);
}),
);
}
Type 'Observable<DeepPartial[]>' is not assignable to type 'Observable'.
Property 'comment' is missing in type 'DeepPartial[]' but required in type 'RecipeEntry'.ts(2322)
recipe-entry.interface.ts(18, 3): 'comment' is declared here.
Any help?
Can't build working example but may be would helpful:
Redo your relations (I simplified entities for example, but you should use full:) ):
#Entity('comments_entry')
export class CommentsEntity {
#Column()
authorId: number;
#ManyToOne(type => UserEntity, user => user.id)
author: UserEntity;
#ManyToOne(type => RecipeEntity, recipe => recipe.id)
recipe: RecipeEntity;
}
#Entity('recipe_entry')
export class RecipeEntity {
#Column()
authorId: number;
#ManyToOne(type => UserEntity, user => user.id)
author: UserEntity;
#OneToMany(type => CommentsEntity, comment => comment.recipe)
comments: CommentsEntity[];
}
#Entity('user_entry')
export class UserEntity {
#OneToMany( type => RecipeEntity, recipe => recipe.author)
recipes: RecipeEntity[];
#OneToMany(type => CommentsEntity, comment => comment.author)
comments: CommentsEntity[];
}
RecipeDto something like:
RecipeDto: {
authorId: number | string,
comments: CommentDto[],
****other recipe data
}
create new Recipe:
createRecipe(recipeDto: RecipeDto): Observable<RecipeEntry> {
const { comments, authorId } = recipeDto;
if(comments) {
const commentPromises = comments.map(async comment => {
comment.authorId = authorId;
return await this.commentRepository.save(comment);
});
recipeDto.comments = await Promise.all(commentPromises);
}
return await this.recipeRepository.save(recipeDto);
}
If I understood correctly, you are trying that:
One User --> Many Recipes
One User --> Many Comments
One Recipe --> Many Comments
Your entities seems right.
Normally a typeorm repository returns a promise and not an observable.
You need to convert it to an Observable.
And at the moment you are trying to store a comment in the recipeRepo. You should save the whole recipe. And before you have to save the comment in the comment repo (if you are not working with cascades).
Something like this:
createComment(id: number, commentEntry: string): Observable<RecipeEntry> {
return from(this.findOne(id)).pipe(
switchMap((recipe: RecipeEntry) => {
return from(this.commentRepository.save(newComment)).pipe(
map(com: Comment) => {
recipe.comment.push(com);
return from(this.recipeRepository.save(recipe));
}
)
);
}
If you enable cascades, you can do this in only one call.