twentyhq/twenty
1
1
Fork 0
mirror of https://github.com/twentyhq/twenty.git synced 2024-11-28 01:09:11 +03:00
Code Issues Packages Projects Releases Wiki Activity

Add attachments (#733)

Browse Source 
* Add attachments v1

* Refacto

* Add Policy checks

* Fix tests

* Remove generated files from git

---------

Co-authored-by: Charles Bochet <charles@twenty.com>
This commit is contained in:
Félix Malfait 2023-07-19 00:24:03 +02:00 committed by GitHub
parent 84018efc7d
commit 10f7b08fdc
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1130 changed files with 570 additions and 39762 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1876
front/src/generated/graphql.tsx
View File

File diff suppressed because it is too large Load Diff

6
front/src/modules/activities/queries/update.ts
View File

@ -91,3 +91,9 @@ export const UPDATE_COMMENT_THREAD = gql`
}
}
`;
export const UPLOAD_ATTACHMENT = gql`
mutation UploadAttachment($file: Upload!, $activityId: String!) {
uploadAttachment(file: $file, activityId: $activityId)
}
`;

1
server/.gitignore vendored
View File

@ -1,6 +1,7 @@
# compiled output
/dist
/node_modules
/src/core/@generated
# Logs
logs

7
server/src/ability/ability.factory.ts
View File

@ -14,6 +14,7 @@ import {
Pipeline,
PipelineStage,
PipelineProgress,
Attachment,
} from '@prisma/client';
import { AbilityAction } from './ability.action';
@ -30,6 +31,7 @@ type SubjectsAbility = Subjects<{
Pipeline: Pipeline;
PipelineStage: PipelineStage;
PipelineProgress: PipelineProgress;
Attachment: Attachment;
}>;
export type AppAbility = PureAbility<
@ -98,6 +100,11 @@ export class AbilityFactory {
// CommentThreadTarget
can(AbilityAction.Read, 'CommentThreadTarget');
// Attachment
can(AbilityAction.Read, 'Attachment', { workspaceId: workspace.id });
can(AbilityAction.Update, 'Attachment', { workspaceId: workspace.id });
can(AbilityAction.Create, 'Attachment', { workspaceId: workspace.id });
// Pipeline
can(AbilityAction.Read, 'Pipeline', { workspaceId: workspace.id });

19
server/src/ability/ability.module.ts
View File

@ -85,6 +85,13 @@ import {
UpdatePipelineProgressAbilityHandler,
DeletePipelineProgressAbilityHandler,
} from './handlers/pipeline-progress.ability-handler';
import {
CreateAttachmentAbilityHandler,
DeleteAttachmentAbilityHandler,
ManageAttachmentAbilityHandler,
ReadAttachmentAbilityHandler,
UpdateAttachmentAbilityHandler,
} from './handlers/attachment.ability-handler';
@Global()
@Module({
@ -145,6 +152,12 @@ import {
CreateCommentThreadTargetAbilityHandler,
UpdateCommentThreadTargetAbilityHandler,
DeleteCommentThreadTargetAbilityHandler,
//Attachment
ManageAttachmentAbilityHandler,
ReadAttachmentAbilityHandler,
CreateAttachmentAbilityHandler,
UpdateAttachmentAbilityHandler,
DeleteAttachmentAbilityHandler,
// Pipeline
ManagePipelineAbilityHandler,
ReadPipelineAbilityHandler,
@ -220,6 +233,12 @@ import {
CreateCommentThreadTargetAbilityHandler,
UpdateCommentThreadTargetAbilityHandler,
DeleteCommentThreadTargetAbilityHandler,
//Attachment
ManageAttachmentAbilityHandler,
ReadAttachmentAbilityHandler,
CreateAttachmentAbilityHandler,
UpdateAttachmentAbilityHandler,
DeleteAttachmentAbilityHandler,
// Pipeline
ManagePipelineAbilityHandler,
ReadPipelineAbilityHandler,

67
server/src/ability/handlers/attachment.ability-handler.ts Normal file
View File

@ -0,0 +1,67 @@
import { PrismaService } from 'src/database/prisma.service';
import { AbilityAction } from '../ability.action';
import { AppAbility } from '../ability.factory';
import { IAbilityHandler } from '../interfaces/ability-handler.interface';
import {
ExecutionContext,
ForbiddenException,
Injectable,
NotFoundException,
} from '@nestjs/common';
import { assert } from 'src/utils/assert';
import { GqlExecutionContext } from '@nestjs/graphql';
import { subject } from '@casl/ability';
class AttachmentArgs {
activityId?: string;
}
@Injectable()
export class ManageAttachmentAbilityHandler implements IAbilityHandler {
async handle(ability: AppAbility) {
return ability.can(AbilityAction.Manage, 'Attachment');
}
}
@Injectable()
export class ReadAttachmentAbilityHandler implements IAbilityHandler {
handle(ability: AppAbility) {
return ability.can(AbilityAction.Read, 'Attachment');
}
}
@Injectable()
export class CreateAttachmentAbilityHandler implements IAbilityHandler {
constructor(private readonly prismaService: PrismaService) {}
async handle(ability: AppAbility, context: ExecutionContext) {
const gqlContext = GqlExecutionContext.create(context);
const args = gqlContext.getArgs<AttachmentArgs>();
assert(args.activityId, '', ForbiddenException);
const activity = await this.prismaService.commentThread.findUnique({
where: { id: args.activityId },
include: { workspace: true },
});
assert(activity, '', NotFoundException);
return ability.can(
AbilityAction.Update,
subject('Workspace', activity.workspace),
);
}
}
@Injectable()
export class UpdateAttachmentAbilityHandler implements IAbilityHandler {
async handle(ability: AppAbility) {
return ability.can(AbilityAction.Update, 'Attachment');
}
}
@Injectable()
export class DeleteAttachmentAbilityHandler implements IAbilityHandler {
async handle(ability: AppAbility) {
return ability.can(AbilityAction.Delete, 'Attachment');
}
}

2
server/src/constants/settings/interfaces/settings.interface.ts
View File

@ -6,7 +6,7 @@ type ValueOfFileFolder = `${FileFolder}`;
export interface Settings {
storage: {
imageCropSizes: {
[key in ValueOfFileFolder]: ShortCropSize[];
[key in ValueOfFileFolder]?: ShortCropSize[];
};
};
}

18
server/src/core/@generated/comment-thread-target/aggregate-comment-thread-target.output.ts
View File

@ -1,18 +0,0 @@
import { Field } from '@nestjs/graphql';
import { ObjectType } from '@nestjs/graphql';
import { CommentThreadTargetCountAggregate } from './comment-thread-target-count-aggregate.output';
import { CommentThreadTargetMinAggregate } from './comment-thread-target-min-aggregate.output';
import { CommentThreadTargetMaxAggregate } from './comment-thread-target-max-aggregate.output';
@ObjectType()
export class AggregateCommentThreadTarget {
@Field(() => CommentThreadTargetCountAggregate, {nullable:true})
_count?: CommentThreadTargetCountAggregate;
@Field(() => CommentThreadTargetMinAggregate, {nullable:true})
_min?: CommentThreadTargetMinAggregate;
@Field(() => CommentThreadTargetMaxAggregate, {nullable:true})
_max?: CommentThreadTargetMaxAggregate;
}

39
server/src/core/@generated/comment-thread-target/comment-thread-target-aggregate.args.ts
View File

@ -1,39 +0,0 @@
import { Field } from '@nestjs/graphql';
import { ArgsType } from '@nestjs/graphql';
import { CommentThreadTargetWhereInput } from './comment-thread-target-where.input';
import { Type } from 'class-transformer';
import { CommentThreadTargetOrderByWithRelationInput } from './comment-thread-target-order-by-with-relation.input';
import { CommentThreadTargetWhereUniqueInput } from './comment-thread-target-where-unique.input';
import { Int } from '@nestjs/graphql';
import { CommentThreadTargetCountAggregateInput } from './comment-thread-target-count-aggregate.input';
import { CommentThreadTargetMinAggregateInput } from './comment-thread-target-min-aggregate.input';
import { CommentThreadTargetMaxAggregateInput } from './comment-thread-target-max-aggregate.input';
@ArgsType()
export class CommentThreadTargetAggregateArgs {
@Field(() => CommentThreadTargetWhereInput, {nullable:true})
@Type(() => CommentThreadTargetWhereInput)
where?: CommentThreadTargetWhereInput;
@Field(() => [CommentThreadTargetOrderByWithRelationInput], {nullable:true})
orderBy?: Array<CommentThreadTargetOrderByWithRelationInput>;
@Field(() => CommentThreadTargetWhereUniqueInput, {nullable:true})
cursor?: CommentThreadTargetWhereUniqueInput;
@Field(() => Int, {nullable:true})
take?: number;
@Field(() => Int, {nullable:true})
skip?: number;
@Field(() => CommentThreadTargetCountAggregateInput, {nullable:true})
_count?: CommentThreadTargetCountAggregateInput;
@Field(() => CommentThreadTargetMinAggregateInput, {nullable:true})
_min?: CommentThreadTargetMinAggregateInput;
@Field(() => CommentThreadTargetMaxAggregateInput, {nullable:true})
_max?: CommentThreadTargetMaxAggregateInput;
}

31
server/src/core/@generated/comment-thread-target/comment-thread-target-count-aggregate.input.ts
View File

@ -1,31 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { HideField } from '@nestjs/graphql';
@InputType()
export class CommentThreadTargetCountAggregateInput {
@Field(() => Boolean, {nullable:true})
id?: true;
@Field(() => Boolean, {nullable:true})
commentThreadId?: true;
@Field(() => Boolean, {nullable:true})
commentableType?: true;
@Field(() => Boolean, {nullable:true})
commentableId?: true;
@HideField()
deletedAt?: true;
@Field(() => Boolean, {nullable:true})
createdAt?: true;
@Field(() => Boolean, {nullable:true})
updatedAt?: true;
@Field(() => Boolean, {nullable:true})
_all?: true;
}

32
server/src/core/@generated/comment-thread-target/comment-thread-target-count-aggregate.output.ts
View File

@ -1,32 +0,0 @@
import { Field } from '@nestjs/graphql';
import { ObjectType } from '@nestjs/graphql';
import { Int } from '@nestjs/graphql';
import { HideField } from '@nestjs/graphql';
@ObjectType()
export class CommentThreadTargetCountAggregate {
@Field(() => Int, {nullable:false})
id!: number;
@Field(() => Int, {nullable:false})
commentThreadId!: number;
@Field(() => Int, {nullable:false})
commentableType!: number;
@Field(() => Int, {nullable:false})
commentableId!: number;
@HideField()
deletedAt!: number;
@Field(() => Int, {nullable:false})
createdAt!: number;
@Field(() => Int, {nullable:false})
updatedAt!: number;
@Field(() => Int, {nullable:false})
_all!: number;
}

29
server/src/core/@generated/comment-thread-target/comment-thread-target-count-order-by-aggregate.input.ts
View File

@ -1,29 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { SortOrder } from '../prisma/sort-order.enum';
import { HideField } from '@nestjs/graphql';
@InputType()
export class CommentThreadTargetCountOrderByAggregateInput {
@Field(() => SortOrder, {nullable:true})
id?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
commentThreadId?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
commentableType?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
commentableId?: keyof typeof SortOrder;
@HideField()
deletedAt?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
createdAt?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
updatedAt?: keyof typeof SortOrder;
}

15
server/src/core/@generated/comment-thread-target/comment-thread-target-create-many-comment-thread-input-envelope.input.ts
View File

@ -1,15 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { CommentThreadTargetCreateManyCommentThreadInput } from './comment-thread-target-create-many-comment-thread.input';
import { Type } from 'class-transformer';
@InputType()
export class CommentThreadTargetCreateManyCommentThreadInputEnvelope {
@Field(() => [CommentThreadTargetCreateManyCommentThreadInput], {nullable:false})
@Type(() => CommentThreadTargetCreateManyCommentThreadInput)
data!: Array<CommentThreadTargetCreateManyCommentThreadInput>;
@Field(() => Boolean, {nullable:true})
skipDuplicates?: boolean;
}

29
server/src/core/@generated/comment-thread-target/comment-thread-target-create-many-comment-thread.input.ts
View File

@ -1,29 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import * as Validator from 'class-validator';
import { CommentableType } from '../prisma/commentable-type.enum';
import { HideField } from '@nestjs/graphql';
@InputType()
export class CommentThreadTargetCreateManyCommentThreadInput {
@Field(() => String, {nullable:true})
@Validator.IsString()
@Validator.IsOptional()
id?: string;
@Field(() => CommentableType, {nullable:false})
commentableType!: keyof typeof CommentableType;
@Field(() => String, {nullable:false})
commentableId!: string;
@HideField()
deletedAt?: Date | string;
@Field(() => Date, {nullable:true})
createdAt?: Date | string;
@Field(() => Date, {nullable:true})
updatedAt?: Date | string;
}

32
server/src/core/@generated/comment-thread-target/comment-thread-target-create-many.input.ts
View File

@ -1,32 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import * as Validator from 'class-validator';
import { CommentableType } from '../prisma/commentable-type.enum';
import { HideField } from '@nestjs/graphql';
@InputType()
export class CommentThreadTargetCreateManyInput {
@Field(() => String, {nullable:true})
@Validator.IsString()
@Validator.IsOptional()
id?: string;
@Field(() => String, {nullable:false})
commentThreadId!: string;
@Field(() => CommentableType, {nullable:false})
commentableType!: keyof typeof CommentableType;
@Field(() => String, {nullable:false})
commentableId!: string;
@HideField()
deletedAt?: Date | string;
@Field(() => Date, {nullable:true})
createdAt?: Date | string;
@Field(() => Date, {nullable:true})
updatedAt?: Date | string;
}

25
server/src/core/@generated/comment-thread-target/comment-thread-target-create-nested-many-without-comment-thread.input.ts
View File

@ -1,25 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { CommentThreadTargetCreateWithoutCommentThreadInput } from './comment-thread-target-create-without-comment-thread.input';
import { HideField } from '@nestjs/graphql';
import { CommentThreadTargetCreateOrConnectWithoutCommentThreadInput } from './comment-thread-target-create-or-connect-without-comment-thread.input';
import { CommentThreadTargetCreateManyCommentThreadInputEnvelope } from './comment-thread-target-create-many-comment-thread-input-envelope.input';
import { Type } from 'class-transformer';
import { CommentThreadTargetWhereUniqueInput } from './comment-thread-target-where-unique.input';
@InputType()
export class CommentThreadTargetCreateNestedManyWithoutCommentThreadInput {
@HideField()
create?: Array<CommentThreadTargetCreateWithoutCommentThreadInput>;
@HideField()
connectOrCreate?: Array<CommentThreadTargetCreateOrConnectWithoutCommentThreadInput>;
@Field(() => CommentThreadTargetCreateManyCommentThreadInputEnvelope, {nullable:true})
@Type(() => CommentThreadTargetCreateManyCommentThreadInputEnvelope)
createMany?: CommentThreadTargetCreateManyCommentThreadInputEnvelope;
@HideField()
connect?: Array<CommentThreadTargetWhereUniqueInput>;
}

17
server/src/core/@generated/comment-thread-target/comment-thread-target-create-or-connect-without-comment-thread.input.ts
View File

@ -1,17 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { CommentThreadTargetWhereUniqueInput } from './comment-thread-target-where-unique.input';
import { Type } from 'class-transformer';
import { CommentThreadTargetCreateWithoutCommentThreadInput } from './comment-thread-target-create-without-comment-thread.input';
@InputType()
export class CommentThreadTargetCreateOrConnectWithoutCommentThreadInput {
@Field(() => CommentThreadTargetWhereUniqueInput, {nullable:false})
@Type(() => CommentThreadTargetWhereUniqueInput)
where!: CommentThreadTargetWhereUniqueInput;
@Field(() => CommentThreadTargetCreateWithoutCommentThreadInput, {nullable:false})
@Type(() => CommentThreadTargetCreateWithoutCommentThreadInput)
create!: CommentThreadTargetCreateWithoutCommentThreadInput;
}

29
server/src/core/@generated/comment-thread-target/comment-thread-target-create-without-comment-thread.input.ts
View File

@ -1,29 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import * as Validator from 'class-validator';
import { CommentableType } from '../prisma/commentable-type.enum';
import { HideField } from '@nestjs/graphql';
@InputType()
export class CommentThreadTargetCreateWithoutCommentThreadInput {
@Field(() => String, {nullable:true})
@Validator.IsString()
@Validator.IsOptional()
id?: string;
@Field(() => CommentableType, {nullable:false})
commentableType!: keyof typeof CommentableType;
@Field(() => String, {nullable:false})
commentableId!: string;
@HideField()
deletedAt?: Date | string;
@Field(() => Date, {nullable:true})
createdAt?: Date | string;
@Field(() => Date, {nullable:true})
updatedAt?: Date | string;
}

33
server/src/core/@generated/comment-thread-target/comment-thread-target-create.input.ts
View File

@ -1,33 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import * as Validator from 'class-validator';
import { CommentableType } from '../prisma/commentable-type.enum';
import { HideField } from '@nestjs/graphql';
import { CommentThreadCreateNestedOneWithoutCommentThreadTargetsInput } from '../comment-thread/comment-thread-create-nested-one-without-comment-thread-targets.input';
@InputType()
export class CommentThreadTargetCreateInput {
@Field(() => String, {nullable:true})
@Validator.IsString()
@Validator.IsOptional()
id?: string;
@Field(() => CommentableType, {nullable:false})
commentableType!: keyof typeof CommentableType;
@Field(() => String, {nullable:false})
commentableId!: string;
@HideField()
deletedAt?: Date | string;
@Field(() => Date, {nullable:true})
createdAt?: Date | string;
@Field(() => Date, {nullable:true})
updatedAt?: Date | string;
@Field(() => CommentThreadCreateNestedOneWithoutCommentThreadTargetsInput, {nullable:false})
commentThread!: CommentThreadCreateNestedOneWithoutCommentThreadTargetsInput;
}

43
server/src/core/@generated/comment-thread-target/comment-thread-target-group-by.args.ts
View File

@ -1,43 +0,0 @@
import { Field } from '@nestjs/graphql';
import { ArgsType } from '@nestjs/graphql';
import { CommentThreadTargetWhereInput } from './comment-thread-target-where.input';
import { Type } from 'class-transformer';
import { CommentThreadTargetOrderByWithAggregationInput } from './comment-thread-target-order-by-with-aggregation.input';
import { CommentThreadTargetScalarFieldEnum } from './comment-thread-target-scalar-field.enum';
import { CommentThreadTargetScalarWhereWithAggregatesInput } from './comment-thread-target-scalar-where-with-aggregates.input';
import { Int } from '@nestjs/graphql';
import { CommentThreadTargetCountAggregateInput } from './comment-thread-target-count-aggregate.input';
import { CommentThreadTargetMinAggregateInput } from './comment-thread-target-min-aggregate.input';
import { CommentThreadTargetMaxAggregateInput } from './comment-thread-target-max-aggregate.input';
@ArgsType()
export class CommentThreadTargetGroupByArgs {
@Field(() => CommentThreadTargetWhereInput, {nullable:true})
@Type(() => CommentThreadTargetWhereInput)
where?: CommentThreadTargetWhereInput;
@Field(() => [CommentThreadTargetOrderByWithAggregationInput], {nullable:true})
orderBy?: Array<CommentThreadTargetOrderByWithAggregationInput>;
@Field(() => [CommentThreadTargetScalarFieldEnum], {nullable:false})
by!: Array<keyof typeof CommentThreadTargetScalarFieldEnum>;
@Field(() => CommentThreadTargetScalarWhereWithAggregatesInput, {nullable:true})
having?: CommentThreadTargetScalarWhereWithAggregatesInput;
@Field(() => Int, {nullable:true})
take?: number;
@Field(() => Int, {nullable:true})
skip?: number;
@Field(() => CommentThreadTargetCountAggregateInput, {nullable:true})
_count?: CommentThreadTargetCountAggregateInput;
@Field(() => CommentThreadTargetMinAggregateInput, {nullable:true})
_min?: CommentThreadTargetMinAggregateInput;
@Field(() => CommentThreadTargetMaxAggregateInput, {nullable:true})
_max?: CommentThreadTargetMaxAggregateInput;
}

44
server/src/core/@generated/comment-thread-target/comment-thread-target-group-by.output.ts
View File

@ -1,44 +0,0 @@
import { Field } from '@nestjs/graphql';
import { ObjectType } from '@nestjs/graphql';
import * as Validator from 'class-validator';
import { CommentableType } from '../prisma/commentable-type.enum';
import { HideField } from '@nestjs/graphql';
import { CommentThreadTargetCountAggregate } from './comment-thread-target-count-aggregate.output';
import { CommentThreadTargetMinAggregate } from './comment-thread-target-min-aggregate.output';
import { CommentThreadTargetMaxAggregate } from './comment-thread-target-max-aggregate.output';
@ObjectType()
export class CommentThreadTargetGroupBy {
@Field(() => String, {nullable:false})
@Validator.IsString()
@Validator.IsOptional()
id!: string;
@Field(() => String, {nullable:false})
commentThreadId!: string;
@Field(() => CommentableType, {nullable:false})
commentableType!: keyof typeof CommentableType;
@Field(() => String, {nullable:false})
commentableId!: string;
@HideField()
deletedAt?: Date | string;
@Field(() => Date, {nullable:false})
createdAt!: Date | string;
@Field(() => Date, {nullable:false})
updatedAt!: Date | string;
@Field(() => CommentThreadTargetCountAggregate, {nullable:true})
_count?: CommentThreadTargetCountAggregate;
@Field(() => CommentThreadTargetMinAggregate, {nullable:true})
_min?: CommentThreadTargetMinAggregate;
@Field(() => CommentThreadTargetMaxAggregate, {nullable:true})
_max?: CommentThreadTargetMaxAggregate;
}

16
server/src/core/@generated/comment-thread-target/comment-thread-target-list-relation-filter.input.ts
View File

@ -1,16 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { CommentThreadTargetWhereInput } from './comment-thread-target-where.input';
@InputType()
export class CommentThreadTargetListRelationFilter {
@Field(() => CommentThreadTargetWhereInput, {nullable:true})
every?: CommentThreadTargetWhereInput;
@Field(() => CommentThreadTargetWhereInput, {nullable:true})
some?: CommentThreadTargetWhereInput;
@Field(() => CommentThreadTargetWhereInput, {nullable:true})
none?: CommentThreadTargetWhereInput;
}

28
server/src/core/@generated/comment-thread-target/comment-thread-target-max-aggregate.input.ts
View File

@ -1,28 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { HideField } from '@nestjs/graphql';
@InputType()
export class CommentThreadTargetMaxAggregateInput {
@Field(() => Boolean, {nullable:true})
id?: true;
@Field(() => Boolean, {nullable:true})
commentThreadId?: true;
@Field(() => Boolean, {nullable:true})
commentableType?: true;
@Field(() => Boolean, {nullable:true})
commentableId?: true;
@HideField()
deletedAt?: true;
@Field(() => Boolean, {nullable:true})
createdAt?: true;
@Field(() => Boolean, {nullable:true})
updatedAt?: true;
}

32
server/src/core/@generated/comment-thread-target/comment-thread-target-max-aggregate.output.ts
View File

@ -1,32 +0,0 @@
import { Field } from '@nestjs/graphql';
import { ObjectType } from '@nestjs/graphql';
import * as Validator from 'class-validator';
import { CommentableType } from '../prisma/commentable-type.enum';
import { HideField } from '@nestjs/graphql';
@ObjectType()
export class CommentThreadTargetMaxAggregate {
@Field(() => String, {nullable:true})
@Validator.IsString()
@Validator.IsOptional()
id?: string;
@Field(() => String, {nullable:true})
commentThreadId?: string;
@Field(() => CommentableType, {nullable:true})
commentableType?: keyof typeof CommentableType;
@Field(() => String, {nullable:true})
commentableId?: string;
@HideField()
deletedAt?: Date | string;
@Field(() => Date, {nullable:true})
createdAt?: Date | string;
@Field(() => Date, {nullable:true})
updatedAt?: Date | string;
}

29
server/src/core/@generated/comment-thread-target/comment-thread-target-max-order-by-aggregate.input.ts
View File

@ -1,29 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { SortOrder } from '../prisma/sort-order.enum';
import { HideField } from '@nestjs/graphql';
@InputType()
export class CommentThreadTargetMaxOrderByAggregateInput {
@Field(() => SortOrder, {nullable:true})
id?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
commentThreadId?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
commentableType?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
commentableId?: keyof typeof SortOrder;
@HideField()
deletedAt?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
createdAt?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
updatedAt?: keyof typeof SortOrder;
}

28
server/src/core/@generated/comment-thread-target/comment-thread-target-min-aggregate.input.ts
View File

@ -1,28 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { HideField } from '@nestjs/graphql';
@InputType()
export class CommentThreadTargetMinAggregateInput {
@Field(() => Boolean, {nullable:true})
id?: true;
@Field(() => Boolean, {nullable:true})
commentThreadId?: true;
@Field(() => Boolean, {nullable:true})
commentableType?: true;
@Field(() => Boolean, {nullable:true})
commentableId?: true;
@HideField()
deletedAt?: true;
@Field(() => Boolean, {nullable:true})
createdAt?: true;
@Field(() => Boolean, {nullable:true})
updatedAt?: true;
}

32
server/src/core/@generated/comment-thread-target/comment-thread-target-min-aggregate.output.ts
View File

@ -1,32 +0,0 @@
import { Field } from '@nestjs/graphql';
import { ObjectType } from '@nestjs/graphql';
import * as Validator from 'class-validator';
import { CommentableType } from '../prisma/commentable-type.enum';
import { HideField } from '@nestjs/graphql';
@ObjectType()
export class CommentThreadTargetMinAggregate {
@Field(() => String, {nullable:true})
@Validator.IsString()
@Validator.IsOptional()
id?: string;
@Field(() => String, {nullable:true})
commentThreadId?: string;
@Field(() => CommentableType, {nullable:true})
commentableType?: keyof typeof CommentableType;
@Field(() => String, {nullable:true})
commentableId?: string;
@HideField()
deletedAt?: Date | string;
@Field(() => Date, {nullable:true})
createdAt?: Date | string;
@Field(() => Date, {nullable:true})
updatedAt?: Date | string;
}

29
server/src/core/@generated/comment-thread-target/comment-thread-target-min-order-by-aggregate.input.ts
View File

@ -1,29 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { SortOrder } from '../prisma/sort-order.enum';
import { HideField } from '@nestjs/graphql';
@InputType()
export class CommentThreadTargetMinOrderByAggregateInput {
@Field(() => SortOrder, {nullable:true})
id?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
commentThreadId?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
commentableType?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
commentableId?: keyof typeof SortOrder;
@HideField()
deletedAt?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
createdAt?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
updatedAt?: keyof typeof SortOrder;
}

10
server/src/core/@generated/comment-thread-target/comment-thread-target-order-by-relation-aggregate.input.ts
View File

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

41
server/src/core/@generated/comment-thread-target/comment-thread-target-order-by-with-aggregation.input.ts
View File

@ -1,41 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { SortOrder } from '../prisma/sort-order.enum';
import { HideField } from '@nestjs/graphql';
import { CommentThreadTargetCountOrderByAggregateInput } from './comment-thread-target-count-order-by-aggregate.input';
import { CommentThreadTargetMaxOrderByAggregateInput } from './comment-thread-target-max-order-by-aggregate.input';
import { CommentThreadTargetMinOrderByAggregateInput } from './comment-thread-target-min-order-by-aggregate.input';
@InputType()
export class CommentThreadTargetOrderByWithAggregationInput {
@Field(() => SortOrder, {nullable:true})
id?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
commentThreadId?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
commentableType?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
commentableId?: keyof typeof SortOrder;
@HideField()
deletedAt?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
createdAt?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
updatedAt?: keyof typeof SortOrder;
@Field(() => CommentThreadTargetCountOrderByAggregateInput, {nullable:true})
_count?: CommentThreadTargetCountOrderByAggregateInput;
@Field(() => CommentThreadTargetMaxOrderByAggregateInput, {nullable:true})
_max?: CommentThreadTargetMaxOrderByAggregateInput;
@Field(() => CommentThreadTargetMinOrderByAggregateInput, {nullable:true})
_min?: CommentThreadTargetMinOrderByAggregateInput;
}

33
server/src/core/@generated/comment-thread-target/comment-thread-target-order-by-with-relation.input.ts
View File

@ -1,33 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { SortOrder } from '../prisma/sort-order.enum';
import { HideField } from '@nestjs/graphql';
import { CommentThreadOrderByWithRelationInput } from '../comment-thread/comment-thread-order-by-with-relation.input';
@InputType()
export class CommentThreadTargetOrderByWithRelationInput {
@Field(() => SortOrder, {nullable:true})
id?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
commentThreadId?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
commentableType?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
commentableId?: keyof typeof SortOrder;
@HideField()
deletedAt?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
createdAt?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
updatedAt?: keyof typeof SortOrder;
@Field(() => CommentThreadOrderByWithRelationInput, {nullable:true})
commentThread?: CommentThreadOrderByWithRelationInput;
}

14
server/src/core/@generated/comment-thread-target/comment-thread-target-scalar-field.enum.ts
View File

@ -1,14 +0,0 @@
import { registerEnumType } from '@nestjs/graphql';
export enum CommentThreadTargetScalarFieldEnum {
id = "id",
commentThreadId = "commentThreadId",
commentableType = "commentableType",
commentableId = "commentableId",
deletedAt = "deletedAt",
createdAt = "createdAt",
updatedAt = "updatedAt"
}
registerEnumType(CommentThreadTargetScalarFieldEnum, { name: 'CommentThreadTargetScalarFieldEnum', description: undefined })

41
server/src/core/@generated/comment-thread-target/comment-thread-target-scalar-where-with-aggregates.input.ts
View File

@ -1,41 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { StringWithAggregatesFilter } from '../prisma/string-with-aggregates-filter.input';
import { EnumCommentableTypeWithAggregatesFilter } from '../prisma/enum-commentable-type-with-aggregates-filter.input';
import { DateTimeNullableWithAggregatesFilter } from '../prisma/date-time-nullable-with-aggregates-filter.input';
import { HideField } from '@nestjs/graphql';
import { DateTimeWithAggregatesFilter } from '../prisma/date-time-with-aggregates-filter.input';
@InputType()
export class CommentThreadTargetScalarWhereWithAggregatesInput {
@Field(() => [CommentThreadTargetScalarWhereWithAggregatesInput], {nullable:true})
AND?: Array<CommentThreadTargetScalarWhereWithAggregatesInput>;
@Field(() => [CommentThreadTargetScalarWhereWithAggregatesInput], {nullable:true})
OR?: Array<CommentThreadTargetScalarWhereWithAggregatesInput>;
@Field(() => [CommentThreadTargetScalarWhereWithAggregatesInput], {nullable:true})
NOT?: Array<CommentThreadTargetScalarWhereWithAggregatesInput>;
@Field(() => StringWithAggregatesFilter, {nullable:true})
id?: StringWithAggregatesFilter;
@Field(() => StringWithAggregatesFilter, {nullable:true})
commentThreadId?: StringWithAggregatesFilter;
@Field(() => EnumCommentableTypeWithAggregatesFilter, {nullable:true})
commentableType?: EnumCommentableTypeWithAggregatesFilter;
@Field(() => StringWithAggregatesFilter, {nullable:true})
commentableId?: StringWithAggregatesFilter;
@HideField()
deletedAt?: DateTimeNullableWithAggregatesFilter;
@Field(() => DateTimeWithAggregatesFilter, {nullable:true})
createdAt?: DateTimeWithAggregatesFilter;
@Field(() => DateTimeWithAggregatesFilter, {nullable:true})
updatedAt?: DateTimeWithAggregatesFilter;
}

41
server/src/core/@generated/comment-thread-target/comment-thread-target-scalar-where.input.ts
View File

@ -1,41 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { StringFilter } from '../prisma/string-filter.input';
import { EnumCommentableTypeFilter } from '../prisma/enum-commentable-type-filter.input';
import { DateTimeNullableFilter } from '../prisma/date-time-nullable-filter.input';
import { HideField } from '@nestjs/graphql';
import { DateTimeFilter } from '../prisma/date-time-filter.input';
@InputType()
export class CommentThreadTargetScalarWhereInput {
@Field(() => [CommentThreadTargetScalarWhereInput], {nullable:true})
AND?: Array<CommentThreadTargetScalarWhereInput>;
@Field(() => [CommentThreadTargetScalarWhereInput], {nullable:true})
OR?: Array<CommentThreadTargetScalarWhereInput>;
@Field(() => [CommentThreadTargetScalarWhereInput], {nullable:true})
NOT?: Array<CommentThreadTargetScalarWhereInput>;
@Field(() => StringFilter, {nullable:true})
id?: StringFilter;
@Field(() => StringFilter, {nullable:true})
commentThreadId?: StringFilter;
@Field(() => EnumCommentableTypeFilter, {nullable:true})
commentableType?: EnumCommentableTypeFilter;
@Field(() => StringFilter, {nullable:true})
commentableId?: StringFilter;
@HideField()
deletedAt?: DateTimeNullableFilter;
@Field(() => DateTimeFilter, {nullable:true})
createdAt?: DateTimeFilter;
@Field(() => DateTimeFilter, {nullable:true})
updatedAt?: DateTimeFilter;
}

27
server/src/core/@generated/comment-thread-target/comment-thread-target-unchecked-create-nested-many-without-comment-thread.input.ts
View File

@ -1,27 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { CommentThreadTargetCreateWithoutCommentThreadInput } from './comment-thread-target-create-without-comment-thread.input';
import { Type } from 'class-transformer';
import { CommentThreadTargetCreateOrConnectWithoutCommentThreadInput } from './comment-thread-target-create-or-connect-without-comment-thread.input';
import { CommentThreadTargetCreateManyCommentThreadInputEnvelope } from './comment-thread-target-create-many-comment-thread-input-envelope.input';
import { CommentThreadTargetWhereUniqueInput } from './comment-thread-target-where-unique.input';
@InputType()
export class CommentThreadTargetUncheckedCreateNestedManyWithoutCommentThreadInput {
@Field(() => [CommentThreadTargetCreateWithoutCommentThreadInput], {nullable:true})
@Type(() => CommentThreadTargetCreateWithoutCommentThreadInput)
create?: Array<CommentThreadTargetCreateWithoutCommentThreadInput>;
@Field(() => [CommentThreadTargetCreateOrConnectWithoutCommentThreadInput], {nullable:true})
@Type(() => CommentThreadTargetCreateOrConnectWithoutCommentThreadInput)
connectOrCreate?: Array<CommentThreadTargetCreateOrConnectWithoutCommentThreadInput>;
@Field(() => CommentThreadTargetCreateManyCommentThreadInputEnvelope, {nullable:true})
@Type(() => CommentThreadTargetCreateManyCommentThreadInputEnvelope)
createMany?: CommentThreadTargetCreateManyCommentThreadInputEnvelope;
@Field(() => [CommentThreadTargetWhereUniqueInput], {nullable:true})
@Type(() => CommentThreadTargetWhereUniqueInput)
connect?: Array<CommentThreadTargetWhereUniqueInput>;
}

29
server/src/core/@generated/comment-thread-target/comment-thread-target-unchecked-create-without-comment-thread.input.ts
View File

@ -1,29 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import * as Validator from 'class-validator';
import { CommentableType } from '../prisma/commentable-type.enum';
import { HideField } from '@nestjs/graphql';
@InputType()
export class CommentThreadTargetUncheckedCreateWithoutCommentThreadInput {
@Field(() => String, {nullable:true})
@Validator.IsString()
@Validator.IsOptional()
id?: string;
@Field(() => CommentableType, {nullable:false})
commentableType!: keyof typeof CommentableType;
@Field(() => String, {nullable:false})
commentableId!: string;
@HideField()
deletedAt?: Date | string;
@Field(() => Date, {nullable:true})
createdAt?: Date | string;
@Field(() => Date, {nullable:true})
updatedAt?: Date | string;
}

32
server/src/core/@generated/comment-thread-target/comment-thread-target-unchecked-create.input.ts
View File

@ -1,32 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import * as Validator from 'class-validator';
import { CommentableType } from '../prisma/commentable-type.enum';
import { HideField } from '@nestjs/graphql';
@InputType()
export class CommentThreadTargetUncheckedCreateInput {
@Field(() => String, {nullable:true})
@Validator.IsString()
@Validator.IsOptional()
id?: string;
@Field(() => String, {nullable:false})
commentThreadId!: string;
@Field(() => CommentableType, {nullable:false})
commentableType!: keyof typeof CommentableType;
@Field(() => String, {nullable:false})
commentableId!: string;
@HideField()
deletedAt?: Date | string;
@Field(() => Date, {nullable:true})
createdAt?: Date | string;
@Field(() => Date, {nullable:true})
updatedAt?: Date | string;
}

59
server/src/core/@generated/comment-thread-target/comment-thread-target-unchecked-update-many-without-comment-thread-nested.input.ts
View File

@ -1,59 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { CommentThreadTargetCreateWithoutCommentThreadInput } from './comment-thread-target-create-without-comment-thread.input';
import { Type } from 'class-transformer';
import { CommentThreadTargetCreateOrConnectWithoutCommentThreadInput } from './comment-thread-target-create-or-connect-without-comment-thread.input';
import { CommentThreadTargetUpsertWithWhereUniqueWithoutCommentThreadInput } from './comment-thread-target-upsert-with-where-unique-without-comment-thread.input';
import { CommentThreadTargetCreateManyCommentThreadInputEnvelope } from './comment-thread-target-create-many-comment-thread-input-envelope.input';
import { CommentThreadTargetWhereUniqueInput } from './comment-thread-target-where-unique.input';
import { CommentThreadTargetUpdateWithWhereUniqueWithoutCommentThreadInput } from './comment-thread-target-update-with-where-unique-without-comment-thread.input';
import { CommentThreadTargetUpdateManyWithWhereWithoutCommentThreadInput } from './comment-thread-target-update-many-with-where-without-comment-thread.input';
import { CommentThreadTargetScalarWhereInput } from './comment-thread-target-scalar-where.input';
@InputType()
export class CommentThreadTargetUncheckedUpdateManyWithoutCommentThreadNestedInput {
@Field(() => [CommentThreadTargetCreateWithoutCommentThreadInput], {nullable:true})
@Type(() => CommentThreadTargetCreateWithoutCommentThreadInput)
create?: Array<CommentThreadTargetCreateWithoutCommentThreadInput>;
@Field(() => [CommentThreadTargetCreateOrConnectWithoutCommentThreadInput], {nullable:true})
@Type(() => CommentThreadTargetCreateOrConnectWithoutCommentThreadInput)
connectOrCreate?: Array<CommentThreadTargetCreateOrConnectWithoutCommentThreadInput>;
@Field(() => [CommentThreadTargetUpsertWithWhereUniqueWithoutCommentThreadInput], {nullable:true})
@Type(() => CommentThreadTargetUpsertWithWhereUniqueWithoutCommentThreadInput)
upsert?: Array<CommentThreadTargetUpsertWithWhereUniqueWithoutCommentThreadInput>;
@Field(() => CommentThreadTargetCreateManyCommentThreadInputEnvelope, {nullable:true})
@Type(() => CommentThreadTargetCreateManyCommentThreadInputEnvelope)
createMany?: CommentThreadTargetCreateManyCommentThreadInputEnvelope;
@Field(() => [CommentThreadTargetWhereUniqueInput], {nullable:true})
@Type(() => CommentThreadTargetWhereUniqueInput)
set?: Array<CommentThreadTargetWhereUniqueInput>;
@Field(() => [CommentThreadTargetWhereUniqueInput], {nullable:true})
@Type(() => CommentThreadTargetWhereUniqueInput)
disconnect?: Array<CommentThreadTargetWhereUniqueInput>;
@Field(() => [CommentThreadTargetWhereUniqueInput], {nullable:true})
@Type(() => CommentThreadTargetWhereUniqueInput)
delete?: Array<CommentThreadTargetWhereUniqueInput>;
@Field(() => [CommentThreadTargetWhereUniqueInput], {nullable:true})
@Type(() => CommentThreadTargetWhereUniqueInput)
connect?: Array<CommentThreadTargetWhereUniqueInput>;
@Field(() => [CommentThreadTargetUpdateWithWhereUniqueWithoutCommentThreadInput], {nullable:true})
@Type(() => CommentThreadTargetUpdateWithWhereUniqueWithoutCommentThreadInput)
update?: Array<CommentThreadTargetUpdateWithWhereUniqueWithoutCommentThreadInput>;
@Field(() => [CommentThreadTargetUpdateManyWithWhereWithoutCommentThreadInput], {nullable:true})
@Type(() => CommentThreadTargetUpdateManyWithWhereWithoutCommentThreadInput)
updateMany?: Array<CommentThreadTargetUpdateManyWithWhereWithoutCommentThreadInput>;
@Field(() => [CommentThreadTargetScalarWhereInput], {nullable:true})
@Type(() => CommentThreadTargetScalarWhereInput)
deleteMany?: Array<CommentThreadTargetScalarWhereInput>;
}

29
server/src/core/@generated/comment-thread-target/comment-thread-target-unchecked-update-many-without-comment-thread-targets.input.ts
View File

@ -1,29 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-operations.input';
import { EnumCommentableTypeFieldUpdateOperationsInput } from '../prisma/enum-commentable-type-field-update-operations.input';
import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
import { HideField } from '@nestjs/graphql';
import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
@InputType()
export class CommentThreadTargetUncheckedUpdateManyWithoutCommentThreadTargetsInput {
@Field(() => StringFieldUpdateOperationsInput, {nullable:true})
id?: StringFieldUpdateOperationsInput;
@Field(() => EnumCommentableTypeFieldUpdateOperationsInput, {nullable:true})
commentableType?: EnumCommentableTypeFieldUpdateOperationsInput;
@Field(() => StringFieldUpdateOperationsInput, {nullable:true})
commentableId?: StringFieldUpdateOperationsInput;
@HideField()
deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
@Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
createdAt?: DateTimeFieldUpdateOperationsInput;
@Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
updatedAt?: DateTimeFieldUpdateOperationsInput;
}

32
server/src/core/@generated/comment-thread-target/comment-thread-target-unchecked-update-many.input.ts
View File

@ -1,32 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-operations.input';
import { EnumCommentableTypeFieldUpdateOperationsInput } from '../prisma/enum-commentable-type-field-update-operations.input';
import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
import { HideField } from '@nestjs/graphql';
import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
@InputType()
export class CommentThreadTargetUncheckedUpdateManyInput {
@Field(() => StringFieldUpdateOperationsInput, {nullable:true})
id?: StringFieldUpdateOperationsInput;
@Field(() => StringFieldUpdateOperationsInput, {nullable:true})
commentThreadId?: StringFieldUpdateOperationsInput;
@Field(() => EnumCommentableTypeFieldUpdateOperationsInput, {nullable:true})
commentableType?: EnumCommentableTypeFieldUpdateOperationsInput;
@Field(() => StringFieldUpdateOperationsInput, {nullable:true})
commentableId?: StringFieldUpdateOperationsInput;
@HideField()
deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
@Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
createdAt?: DateTimeFieldUpdateOperationsInput;
@Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
updatedAt?: DateTimeFieldUpdateOperationsInput;
}

29
server/src/core/@generated/comment-thread-target/comment-thread-target-unchecked-update-without-comment-thread.input.ts
View File

@ -1,29 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-operations.input';
import { EnumCommentableTypeFieldUpdateOperationsInput } from '../prisma/enum-commentable-type-field-update-operations.input';
import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
import { HideField } from '@nestjs/graphql';
import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
@InputType()
export class CommentThreadTargetUncheckedUpdateWithoutCommentThreadInput {
@Field(() => StringFieldUpdateOperationsInput, {nullable:true})
id?: StringFieldUpdateOperationsInput;
@Field(() => EnumCommentableTypeFieldUpdateOperationsInput, {nullable:true})
commentableType?: EnumCommentableTypeFieldUpdateOperationsInput;
@Field(() => StringFieldUpdateOperationsInput, {nullable:true})
commentableId?: StringFieldUpdateOperationsInput;
@HideField()
deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
@Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
createdAt?: DateTimeFieldUpdateOperationsInput;
@Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
updatedAt?: DateTimeFieldUpdateOperationsInput;
}

32
server/src/core/@generated/comment-thread-target/comment-thread-target-unchecked-update.input.ts
View File

@ -1,32 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-operations.input';
import { EnumCommentableTypeFieldUpdateOperationsInput } from '../prisma/enum-commentable-type-field-update-operations.input';
import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
import { HideField } from '@nestjs/graphql';
import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
@InputType()
export class CommentThreadTargetUncheckedUpdateInput {
@Field(() => StringFieldUpdateOperationsInput, {nullable:true})
id?: StringFieldUpdateOperationsInput;
@Field(() => StringFieldUpdateOperationsInput, {nullable:true})
commentThreadId?: StringFieldUpdateOperationsInput;
@Field(() => EnumCommentableTypeFieldUpdateOperationsInput, {nullable:true})
commentableType?: EnumCommentableTypeFieldUpdateOperationsInput;
@Field(() => StringFieldUpdateOperationsInput, {nullable:true})
commentableId?: StringFieldUpdateOperationsInput;
@HideField()
deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
@Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
createdAt?: DateTimeFieldUpdateOperationsInput;
@Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
updatedAt?: DateTimeFieldUpdateOperationsInput;
}

29
server/src/core/@generated/comment-thread-target/comment-thread-target-update-many-mutation.input.ts
View File

@ -1,29 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-operations.input';
import { EnumCommentableTypeFieldUpdateOperationsInput } from '../prisma/enum-commentable-type-field-update-operations.input';
import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
import { HideField } from '@nestjs/graphql';
import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
@InputType()
export class CommentThreadTargetUpdateManyMutationInput {
@Field(() => StringFieldUpdateOperationsInput, {nullable:true})
id?: StringFieldUpdateOperationsInput;
@Field(() => EnumCommentableTypeFieldUpdateOperationsInput, {nullable:true})
commentableType?: EnumCommentableTypeFieldUpdateOperationsInput;
@Field(() => StringFieldUpdateOperationsInput, {nullable:true})
commentableId?: StringFieldUpdateOperationsInput;
@HideField()
deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
@Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
createdAt?: DateTimeFieldUpdateOperationsInput;
@Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
updatedAt?: DateTimeFieldUpdateOperationsInput;
}

17
server/src/core/@generated/comment-thread-target/comment-thread-target-update-many-with-where-without-comment-thread.input.ts
View File

@ -1,17 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { CommentThreadTargetScalarWhereInput } from './comment-thread-target-scalar-where.input';
import { Type } from 'class-transformer';
import { CommentThreadTargetUpdateManyMutationInput } from './comment-thread-target-update-many-mutation.input';
@InputType()
export class CommentThreadTargetUpdateManyWithWhereWithoutCommentThreadInput {
@Field(() => CommentThreadTargetScalarWhereInput, {nullable:false})
@Type(() => CommentThreadTargetScalarWhereInput)
where!: CommentThreadTargetScalarWhereInput;
@Field(() => CommentThreadTargetUpdateManyMutationInput, {nullable:false})
@Type(() => CommentThreadTargetUpdateManyMutationInput)
data!: CommentThreadTargetUpdateManyMutationInput;
}

59
server/src/core/@generated/comment-thread-target/comment-thread-target-update-many-without-comment-thread-nested.input.ts
View File

@ -1,59 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { CommentThreadTargetCreateWithoutCommentThreadInput } from './comment-thread-target-create-without-comment-thread.input';
import { Type } from 'class-transformer';
import { CommentThreadTargetCreateOrConnectWithoutCommentThreadInput } from './comment-thread-target-create-or-connect-without-comment-thread.input';
import { CommentThreadTargetUpsertWithWhereUniqueWithoutCommentThreadInput } from './comment-thread-target-upsert-with-where-unique-without-comment-thread.input';
import { CommentThreadTargetCreateManyCommentThreadInputEnvelope } from './comment-thread-target-create-many-comment-thread-input-envelope.input';
import { CommentThreadTargetWhereUniqueInput } from './comment-thread-target-where-unique.input';
import { CommentThreadTargetUpdateWithWhereUniqueWithoutCommentThreadInput } from './comment-thread-target-update-with-where-unique-without-comment-thread.input';
import { CommentThreadTargetUpdateManyWithWhereWithoutCommentThreadInput } from './comment-thread-target-update-many-with-where-without-comment-thread.input';
import { CommentThreadTargetScalarWhereInput } from './comment-thread-target-scalar-where.input';
@InputType()
export class CommentThreadTargetUpdateManyWithoutCommentThreadNestedInput {
@Field(() => [CommentThreadTargetCreateWithoutCommentThreadInput], {nullable:true})
@Type(() => CommentThreadTargetCreateWithoutCommentThreadInput)
create?: Array<CommentThreadTargetCreateWithoutCommentThreadInput>;
@Field(() => [CommentThreadTargetCreateOrConnectWithoutCommentThreadInput], {nullable:true})
@Type(() => CommentThreadTargetCreateOrConnectWithoutCommentThreadInput)
connectOrCreate?: Array<CommentThreadTargetCreateOrConnectWithoutCommentThreadInput>;
@Field(() => [CommentThreadTargetUpsertWithWhereUniqueWithoutCommentThreadInput], {nullable:true})
@Type(() => CommentThreadTargetUpsertWithWhereUniqueWithoutCommentThreadInput)
upsert?: Array<CommentThreadTargetUpsertWithWhereUniqueWithoutCommentThreadInput>;
@Field(() => CommentThreadTargetCreateManyCommentThreadInputEnvelope, {nullable:true})
@Type(() => CommentThreadTargetCreateManyCommentThreadInputEnvelope)
createMany?: CommentThreadTargetCreateManyCommentThreadInputEnvelope;
@Field(() => [CommentThreadTargetWhereUniqueInput], {nullable:true})
@Type(() => CommentThreadTargetWhereUniqueInput)
set?: Array<CommentThreadTargetWhereUniqueInput>;
@Field(() => [CommentThreadTargetWhereUniqueInput], {nullable:true})
@Type(() => CommentThreadTargetWhereUniqueInput)
disconnect?: Array<CommentThreadTargetWhereUniqueInput>;
@Field(() => [CommentThreadTargetWhereUniqueInput], {nullable:true})
@Type(() => CommentThreadTargetWhereUniqueInput)
delete?: Array<CommentThreadTargetWhereUniqueInput>;
@Field(() => [CommentThreadTargetWhereUniqueInput], {nullable:true})
@Type(() => CommentThreadTargetWhereUniqueInput)
connect?: Array<CommentThreadTargetWhereUniqueInput>;
@Field(() => [CommentThreadTargetUpdateWithWhereUniqueWithoutCommentThreadInput], {nullable:true})
@Type(() => CommentThreadTargetUpdateWithWhereUniqueWithoutCommentThreadInput)
update?: Array<CommentThreadTargetUpdateWithWhereUniqueWithoutCommentThreadInput>;
@Field(() => [CommentThreadTargetUpdateManyWithWhereWithoutCommentThreadInput], {nullable:true})
@Type(() => CommentThreadTargetUpdateManyWithWhereWithoutCommentThreadInput)
updateMany?: Array<CommentThreadTargetUpdateManyWithWhereWithoutCommentThreadInput>;
@Field(() => [CommentThreadTargetScalarWhereInput], {nullable:true})
@Type(() => CommentThreadTargetScalarWhereInput)
deleteMany?: Array<CommentThreadTargetScalarWhereInput>;
}

17
server/src/core/@generated/comment-thread-target/comment-thread-target-update-with-where-unique-without-comment-thread.input.ts
View File

@ -1,17 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { CommentThreadTargetWhereUniqueInput } from './comment-thread-target-where-unique.input';
import { Type } from 'class-transformer';
import { CommentThreadTargetUpdateWithoutCommentThreadInput } from './comment-thread-target-update-without-comment-thread.input';
@InputType()
export class CommentThreadTargetUpdateWithWhereUniqueWithoutCommentThreadInput {
@Field(() => CommentThreadTargetWhereUniqueInput, {nullable:false})
@Type(() => CommentThreadTargetWhereUniqueInput)
where!: CommentThreadTargetWhereUniqueInput;
@Field(() => CommentThreadTargetUpdateWithoutCommentThreadInput, {nullable:false})
@Type(() => CommentThreadTargetUpdateWithoutCommentThreadInput)
data!: CommentThreadTargetUpdateWithoutCommentThreadInput;
}

29
server/src/core/@generated/comment-thread-target/comment-thread-target-update-without-comment-thread.input.ts
View File

@ -1,29 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-operations.input';
import { EnumCommentableTypeFieldUpdateOperationsInput } from '../prisma/enum-commentable-type-field-update-operations.input';
import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
import { HideField } from '@nestjs/graphql';
import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
@InputType()
export class CommentThreadTargetUpdateWithoutCommentThreadInput {
@Field(() => StringFieldUpdateOperationsInput, {nullable:true})
id?: StringFieldUpdateOperationsInput;
@Field(() => EnumCommentableTypeFieldUpdateOperationsInput, {nullable:true})
commentableType?: EnumCommentableTypeFieldUpdateOperationsInput;
@Field(() => StringFieldUpdateOperationsInput, {nullable:true})
commentableId?: StringFieldUpdateOperationsInput;
@HideField()
deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
@Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
createdAt?: DateTimeFieldUpdateOperationsInput;
@Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
updatedAt?: DateTimeFieldUpdateOperationsInput;
}

33
server/src/core/@generated/comment-thread-target/comment-thread-target-update.input.ts
View File

@ -1,33 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-operations.input';
import { EnumCommentableTypeFieldUpdateOperationsInput } from '../prisma/enum-commentable-type-field-update-operations.input';
import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
import { HideField } from '@nestjs/graphql';
import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
import { CommentThreadUpdateOneRequiredWithoutCommentThreadTargetsNestedInput } from '../comment-thread/comment-thread-update-one-required-without-comment-thread-targets-nested.input';
@InputType()
export class CommentThreadTargetUpdateInput {
@Field(() => StringFieldUpdateOperationsInput, {nullable:true})
id?: StringFieldUpdateOperationsInput;
@Field(() => EnumCommentableTypeFieldUpdateOperationsInput, {nullable:true})
commentableType?: EnumCommentableTypeFieldUpdateOperationsInput;
@Field(() => StringFieldUpdateOperationsInput, {nullable:true})
commentableId?: StringFieldUpdateOperationsInput;
@HideField()
deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
@Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
createdAt?: DateTimeFieldUpdateOperationsInput;
@Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
updatedAt?: DateTimeFieldUpdateOperationsInput;
@Field(() => CommentThreadUpdateOneRequiredWithoutCommentThreadTargetsNestedInput, {nullable:true})
commentThread?: CommentThreadUpdateOneRequiredWithoutCommentThreadTargetsNestedInput;
}

22
server/src/core/@generated/comment-thread-target/comment-thread-target-upsert-with-where-unique-without-comment-thread.input.ts
View File

@ -1,22 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { CommentThreadTargetWhereUniqueInput } from './comment-thread-target-where-unique.input';
import { Type } from 'class-transformer';
import { CommentThreadTargetUpdateWithoutCommentThreadInput } from './comment-thread-target-update-without-comment-thread.input';
import { CommentThreadTargetCreateWithoutCommentThreadInput } from './comment-thread-target-create-without-comment-thread.input';
@InputType()
export class CommentThreadTargetUpsertWithWhereUniqueWithoutCommentThreadInput {
@Field(() => CommentThreadTargetWhereUniqueInput, {nullable:false})
@Type(() => CommentThreadTargetWhereUniqueInput)
where!: CommentThreadTargetWhereUniqueInput;
@Field(() => CommentThreadTargetUpdateWithoutCommentThreadInput, {nullable:false})
@Type(() => CommentThreadTargetUpdateWithoutCommentThreadInput)
update!: CommentThreadTargetUpdateWithoutCommentThreadInput;
@Field(() => CommentThreadTargetCreateWithoutCommentThreadInput, {nullable:false})
@Type(() => CommentThreadTargetCreateWithoutCommentThreadInput)
create!: CommentThreadTargetCreateWithoutCommentThreadInput;
}

12
server/src/core/@generated/comment-thread-target/comment-thread-target-where-unique.input.ts
View File

@ -1,12 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import * as Validator from 'class-validator';
@InputType()
export class CommentThreadTargetWhereUniqueInput {
@Field(() => String, {nullable:true})
@Validator.IsString()
@Validator.IsOptional()
id?: string;
}

45
server/src/core/@generated/comment-thread-target/comment-thread-target-where.input.ts
View File

@ -1,45 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { StringFilter } from '../prisma/string-filter.input';
import { EnumCommentableTypeFilter } from '../prisma/enum-commentable-type-filter.input';
import { DateTimeNullableFilter } from '../prisma/date-time-nullable-filter.input';
import { HideField } from '@nestjs/graphql';
import { DateTimeFilter } from '../prisma/date-time-filter.input';
import { CommentThreadRelationFilter } from '../comment-thread/comment-thread-relation-filter.input';
@InputType()
export class CommentThreadTargetWhereInput {
@Field(() => [CommentThreadTargetWhereInput], {nullable:true})
AND?: Array<CommentThreadTargetWhereInput>;
@Field(() => [CommentThreadTargetWhereInput], {nullable:true})
OR?: Array<CommentThreadTargetWhereInput>;
@Field(() => [CommentThreadTargetWhereInput], {nullable:true})
NOT?: Array<CommentThreadTargetWhereInput>;
@Field(() => StringFilter, {nullable:true})
id?: StringFilter;
@Field(() => StringFilter, {nullable:true})
commentThreadId?: StringFilter;
@Field(() => EnumCommentableTypeFilter, {nullable:true})
commentableType?: EnumCommentableTypeFilter;
@Field(() => StringFilter, {nullable:true})
commentableId?: StringFilter;
@HideField()
deletedAt?: DateTimeNullableFilter;
@Field(() => DateTimeFilter, {nullable:true})
createdAt?: DateTimeFilter;
@Field(() => DateTimeFilter, {nullable:true})
updatedAt?: DateTimeFilter;
@Field(() => CommentThreadRelationFilter, {nullable:true})
commentThread?: CommentThreadRelationFilter;
}

34
server/src/core/@generated/comment-thread-target/comment-thread-target.model.ts
View File

@ -1,34 +0,0 @@
import { Field } from '@nestjs/graphql';
import { ObjectType } from '@nestjs/graphql';
import { ID } from '@nestjs/graphql';
import { CommentableType } from '../prisma/commentable-type.enum';
import { HideField } from '@nestjs/graphql';
import { CommentThread } from '../comment-thread/comment-thread.model';
@ObjectType()
export class CommentThreadTarget {
@Field(() => ID, {nullable:false})
id!: string;
@Field(() => String, {nullable:false})
commentThreadId!: string;
@Field(() => CommentableType, {nullable:false})
commentableType!: keyof typeof CommentableType;
@Field(() => String, {nullable:false})
commentableId!: string;
@HideField()
deletedAt!: Date | null;
@Field(() => Date, {nullable:false})
createdAt!: Date;
@Field(() => Date, {nullable:false})
updatedAt!: Date;
@Field(() => CommentThread, {nullable:false})
commentThread?: CommentThread;
}

18
server/src/core/@generated/comment-thread-target/create-many-comment-thread-target.args.ts
View File

@ -1,18 +0,0 @@
import { Field } from '@nestjs/graphql';
import { ArgsType } from '@nestjs/graphql';
import { CommentThreadTargetCreateManyInput } from './comment-thread-target-create-many.input';
import { Type } from 'class-transformer';
import { ValidateNested } from 'class-validator';
@ArgsType()
export class CreateManyCommentThreadTargetArgs {
@Field(() => [CommentThreadTargetCreateManyInput], {nullable:false})
@Type(() => CommentThreadTargetCreateManyInput)
@ValidateNested({each: true})
@Type(() => CommentThreadTargetCreateManyInput)
data!: Array<CommentThreadTargetCreateManyInput>;
@Field(() => Boolean, {nullable:true})
skipDuplicates?: boolean;
}

15
server/src/core/@generated/comment-thread-target/create-one-comment-thread-target.args.ts
View File

@ -1,15 +0,0 @@
import { Field } from '@nestjs/graphql';
import { ArgsType } from '@nestjs/graphql';
import { CommentThreadTargetCreateInput } from './comment-thread-target-create.input';
import { Type } from 'class-transformer';
import { ValidateNested } from 'class-validator';
@ArgsType()
export class CreateOneCommentThreadTargetArgs {
@Field(() => CommentThreadTargetCreateInput, {nullable:false})
@Type(() => CommentThreadTargetCreateInput)
@ValidateNested({each: true})
@Type(() => CommentThreadTargetCreateInput)
data!: CommentThreadTargetCreateInput;
}

12
server/src/core/@generated/comment-thread-target/delete-many-comment-thread-target.args.ts
View File

@ -1,12 +0,0 @@
import { Field } from '@nestjs/graphql';
import { ArgsType } from '@nestjs/graphql';
import { CommentThreadTargetWhereInput } from './comment-thread-target-where.input';
import { Type } from 'class-transformer';
@ArgsType()
export class DeleteManyCommentThreadTargetArgs {
@Field(() => CommentThreadTargetWhereInput, {nullable:true})
@Type(() => CommentThreadTargetWhereInput)
where?: CommentThreadTargetWhereInput;
}

12
server/src/core/@generated/comment-thread-target/delete-one-comment-thread-target.args.ts
View File

@ -1,12 +0,0 @@
import { Field } from '@nestjs/graphql';
import { ArgsType } from '@nestjs/graphql';
import { CommentThreadTargetWhereUniqueInput } from './comment-thread-target-where-unique.input';
import { Type } from 'class-transformer';
@ArgsType()
export class DeleteOneCommentThreadTargetArgs {
@Field(() => CommentThreadTargetWhereUniqueInput, {nullable:false})
@Type(() => CommentThreadTargetWhereUniqueInput)
where!: CommentThreadTargetWhereUniqueInput;
}

31
server/src/core/@generated/comment-thread-target/find-first-comment-thread-target-or-throw.args.ts
View File

@ -1,31 +0,0 @@
import { Field } from '@nestjs/graphql';
import { ArgsType } from '@nestjs/graphql';
import { CommentThreadTargetWhereInput } from './comment-thread-target-where.input';
import { Type } from 'class-transformer';
import { CommentThreadTargetOrderByWithRelationInput } from './comment-thread-target-order-by-with-relation.input';
import { CommentThreadTargetWhereUniqueInput } from './comment-thread-target-where-unique.input';
import { Int } from '@nestjs/graphql';
import { CommentThreadTargetScalarFieldEnum } from './comment-thread-target-scalar-field.enum';
@ArgsType()
export class FindFirstCommentThreadTargetOrThrowArgs {
@Field(() => CommentThreadTargetWhereInput, {nullable:true})
@Type(() => CommentThreadTargetWhereInput)
where?: CommentThreadTargetWhereInput;
@Field(() => [CommentThreadTargetOrderByWithRelationInput], {nullable:true})
orderBy?: Array<CommentThreadTargetOrderByWithRelationInput>;
@Field(() => CommentThreadTargetWhereUniqueInput, {nullable:true})
cursor?: CommentThreadTargetWhereUniqueInput;
@Field(() => Int, {nullable:true})
take?: number;
@Field(() => Int, {nullable:true})
skip?: number;
@Field(() => [CommentThreadTargetScalarFieldEnum], {nullable:true})
distinct?: Array<keyof typeof CommentThreadTargetScalarFieldEnum>;
}

31
server/src/core/@generated/comment-thread-target/find-first-comment-thread-target.args.ts
View File

@ -1,31 +0,0 @@
import { Field } from '@nestjs/graphql';
import { ArgsType } from '@nestjs/graphql';
import { CommentThreadTargetWhereInput } from './comment-thread-target-where.input';
import { Type } from 'class-transformer';
import { CommentThreadTargetOrderByWithRelationInput } from './comment-thread-target-order-by-with-relation.input';
import { CommentThreadTargetWhereUniqueInput } from './comment-thread-target-where-unique.input';
import { Int } from '@nestjs/graphql';
import { CommentThreadTargetScalarFieldEnum } from './comment-thread-target-scalar-field.enum';
@ArgsType()
export class FindFirstCommentThreadTargetArgs {
@Field(() => CommentThreadTargetWhereInput, {nullable:true})
@Type(() => CommentThreadTargetWhereInput)
where?: CommentThreadTargetWhereInput;
@Field(() => [CommentThreadTargetOrderByWithRelationInput], {nullable:true})
orderBy?: Array<CommentThreadTargetOrderByWithRelationInput>;
@Field(() => CommentThreadTargetWhereUniqueInput, {nullable:true})
cursor?: CommentThreadTargetWhereUniqueInput;
@Field(() => Int, {nullable:true})
take?: number;
@Field(() => Int, {nullable:true})
skip?: number;
@Field(() => [CommentThreadTargetScalarFieldEnum], {nullable:true})
distinct?: Array<keyof typeof CommentThreadTargetScalarFieldEnum>;
}

31
server/src/core/@generated/comment-thread-target/find-many-comment-thread-target.args.ts
View File

@ -1,31 +0,0 @@
import { Field } from '@nestjs/graphql';
import { ArgsType } from '@nestjs/graphql';
import { CommentThreadTargetWhereInput } from './comment-thread-target-where.input';
import { Type } from 'class-transformer';
import { CommentThreadTargetOrderByWithRelationInput } from './comment-thread-target-order-by-with-relation.input';
import { CommentThreadTargetWhereUniqueInput } from './comment-thread-target-where-unique.input';
import { Int } from '@nestjs/graphql';
import { CommentThreadTargetScalarFieldEnum } from './comment-thread-target-scalar-field.enum';
@ArgsType()
export class FindManyCommentThreadTargetArgs {
@Field(() => CommentThreadTargetWhereInput, {nullable:true})
@Type(() => CommentThreadTargetWhereInput)
where?: CommentThreadTargetWhereInput;
@Field(() => [CommentThreadTargetOrderByWithRelationInput], {nullable:true})
orderBy?: Array<CommentThreadTargetOrderByWithRelationInput>;
@Field(() => CommentThreadTargetWhereUniqueInput, {nullable:true})
cursor?: CommentThreadTargetWhereUniqueInput;
@Field(() => Int, {nullable:true})
take?: number;
@Field(() => Int, {nullable:true})
skip?: number;
@Field(() => [CommentThreadTargetScalarFieldEnum], {nullable:true})
distinct?: Array<keyof typeof CommentThreadTargetScalarFieldEnum>;
}

12
server/src/core/@generated/comment-thread-target/find-unique-comment-thread-target-or-throw.args.ts
View File

@ -1,12 +0,0 @@
import { Field } from '@nestjs/graphql';
import { ArgsType } from '@nestjs/graphql';
import { CommentThreadTargetWhereUniqueInput } from './comment-thread-target-where-unique.input';
import { Type } from 'class-transformer';
@ArgsType()
export class FindUniqueCommentThreadTargetOrThrowArgs {
@Field(() => CommentThreadTargetWhereUniqueInput, {nullable:false})
@Type(() => CommentThreadTargetWhereUniqueInput)
where!: CommentThreadTargetWhereUniqueInput;
}

12
server/src/core/@generated/comment-thread-target/find-unique-comment-thread-target.args.ts
View File

@ -1,12 +0,0 @@
import { Field } from '@nestjs/graphql';
import { ArgsType } from '@nestjs/graphql';
import { CommentThreadTargetWhereUniqueInput } from './comment-thread-target-where-unique.input';
import { Type } from 'class-transformer';
@ArgsType()
export class FindUniqueCommentThreadTargetArgs {
@Field(() => CommentThreadTargetWhereUniqueInput, {nullable:false})
@Type(() => CommentThreadTargetWhereUniqueInput)
where!: CommentThreadTargetWhereUniqueInput;
}

20
server/src/core/@generated/comment-thread-target/update-many-comment-thread-target.args.ts
View File

@ -1,20 +0,0 @@
import { Field } from '@nestjs/graphql';
import { ArgsType } from '@nestjs/graphql';
import { CommentThreadTargetUpdateManyMutationInput } from './comment-thread-target-update-many-mutation.input';
import { Type } from 'class-transformer';
import { ValidateNested } from 'class-validator';
import { CommentThreadTargetWhereInput } from './comment-thread-target-where.input';
@ArgsType()
export class UpdateManyCommentThreadTargetArgs {
@Field(() => CommentThreadTargetUpdateManyMutationInput, {nullable:false})
@Type(() => CommentThreadTargetUpdateManyMutationInput)
@ValidateNested({each: true})
@Type(() => CommentThreadTargetUpdateManyMutationInput)
data!: CommentThreadTargetUpdateManyMutationInput;
@Field(() => CommentThreadTargetWhereInput, {nullable:true})
@Type(() => CommentThreadTargetWhereInput)
where?: CommentThreadTargetWhereInput;
}

20
server/src/core/@generated/comment-thread-target/update-one-comment-thread-target.args.ts
View File

@ -1,20 +0,0 @@
import { Field } from '@nestjs/graphql';
import { ArgsType } from '@nestjs/graphql';
import { CommentThreadTargetUpdateInput } from './comment-thread-target-update.input';
import { Type } from 'class-transformer';
import { ValidateNested } from 'class-validator';
import { CommentThreadTargetWhereUniqueInput } from './comment-thread-target-where-unique.input';
@ArgsType()
export class UpdateOneCommentThreadTargetArgs {
@Field(() => CommentThreadTargetUpdateInput, {nullable:false})
@Type(() => CommentThreadTargetUpdateInput)
@ValidateNested({each: true})
@Type(() => CommentThreadTargetUpdateInput)
data!: CommentThreadTargetUpdateInput;
@Field(() => CommentThreadTargetWhereUniqueInput, {nullable:false})
@Type(() => CommentThreadTargetWhereUniqueInput)
where!: CommentThreadTargetWhereUniqueInput;
}

22
server/src/core/@generated/comment-thread-target/upsert-one-comment-thread-target.args.ts
View File

@ -1,22 +0,0 @@
import { Field } from '@nestjs/graphql';
import { ArgsType } from '@nestjs/graphql';
import { CommentThreadTargetWhereUniqueInput } from './comment-thread-target-where-unique.input';
import { Type } from 'class-transformer';
import { CommentThreadTargetCreateInput } from './comment-thread-target-create.input';
import { CommentThreadTargetUpdateInput } from './comment-thread-target-update.input';
@ArgsType()
export class UpsertOneCommentThreadTargetArgs {
@Field(() => CommentThreadTargetWhereUniqueInput, {nullable:false})
@Type(() => CommentThreadTargetWhereUniqueInput)
where!: CommentThreadTargetWhereUniqueInput;
@Field(() => CommentThreadTargetCreateInput, {nullable:false})
@Type(() => CommentThreadTargetCreateInput)
create!: CommentThreadTargetCreateInput;
@Field(() => CommentThreadTargetUpdateInput, {nullable:false})
@Type(() => CommentThreadTargetUpdateInput)
update!: CommentThreadTargetUpdateInput;
}

18
server/src/core/@generated/comment-thread/aggregate-comment-thread.output.ts
View File

@ -1,18 +0,0 @@
import { Field } from '@nestjs/graphql';
import { ObjectType } from '@nestjs/graphql';
import { CommentThreadCountAggregate } from './comment-thread-count-aggregate.output';
import { CommentThreadMinAggregate } from './comment-thread-min-aggregate.output';
import { CommentThreadMaxAggregate } from './comment-thread-max-aggregate.output';
@ObjectType()
export class AggregateCommentThread {
@Field(() => CommentThreadCountAggregate, {nullable:true})
_count?: CommentThreadCountAggregate;
@Field(() => CommentThreadMinAggregate, {nullable:true})
_min?: CommentThreadMinAggregate;
@Field(() => CommentThreadMaxAggregate, {nullable:true})
_max?: CommentThreadMaxAggregate;
}

39
server/src/core/@generated/comment-thread/comment-thread-aggregate.args.ts
View File

@ -1,39 +0,0 @@
import { Field } from '@nestjs/graphql';
import { ArgsType } from '@nestjs/graphql';
import { CommentThreadWhereInput } from './comment-thread-where.input';
import { Type } from 'class-transformer';
import { CommentThreadOrderByWithRelationInput } from './comment-thread-order-by-with-relation.input';
import { CommentThreadWhereUniqueInput } from './comment-thread-where-unique.input';
import { Int } from '@nestjs/graphql';
import { CommentThreadCountAggregateInput } from './comment-thread-count-aggregate.input';
import { CommentThreadMinAggregateInput } from './comment-thread-min-aggregate.input';
import { CommentThreadMaxAggregateInput } from './comment-thread-max-aggregate.input';
@ArgsType()
export class CommentThreadAggregateArgs {
@Field(() => CommentThreadWhereInput, {nullable:true})
@Type(() => CommentThreadWhereInput)
where?: CommentThreadWhereInput;
@Field(() => [CommentThreadOrderByWithRelationInput], {nullable:true})
orderBy?: Array<CommentThreadOrderByWithRelationInput>;
@Field(() => CommentThreadWhereUniqueInput, {nullable:true})
cursor?: CommentThreadWhereUniqueInput;
@Field(() => Int, {nullable:true})
take?: number;
@Field(() => Int, {nullable:true})
skip?: number;
@Field(() => CommentThreadCountAggregateInput, {nullable:true})
_count?: CommentThreadCountAggregateInput;
@Field(() => CommentThreadMinAggregateInput, {nullable:true})
_min?: CommentThreadMinAggregateInput;
@Field(() => CommentThreadMaxAggregateInput, {nullable:true})
_max?: CommentThreadMaxAggregateInput;
}

49
server/src/core/@generated/comment-thread/comment-thread-count-aggregate.input.ts
View File

@ -1,49 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { HideField } from '@nestjs/graphql';
@InputType()
export class CommentThreadCountAggregateInput {
@Field(() => Boolean, {nullable:true})
id?: true;
@HideField()
workspaceId?: true;
@Field(() => Boolean, {nullable:true})
authorId?: true;
@Field(() => Boolean, {nullable:true})
body?: true;
@Field(() => Boolean, {nullable:true})
title?: true;
@Field(() => Boolean, {nullable:true})
type?: true;
@Field(() => Boolean, {nullable:true})
reminderAt?: true;
@Field(() => Boolean, {nullable:true})
dueAt?: true;
@Field(() => Boolean, {nullable:true})
completedAt?: true;
@Field(() => Boolean, {nullable:true})
assigneeId?: true;
@HideField()
deletedAt?: true;
@Field(() => Boolean, {nullable:true})
createdAt?: true;
@Field(() => Boolean, {nullable:true})
updatedAt?: true;
@Field(() => Boolean, {nullable:true})
_all?: true;
}

50
server/src/core/@generated/comment-thread/comment-thread-count-aggregate.output.ts
View File

@ -1,50 +0,0 @@
import { Field } from '@nestjs/graphql';
import { ObjectType } from '@nestjs/graphql';
import { Int } from '@nestjs/graphql';
import { HideField } from '@nestjs/graphql';
@ObjectType()
export class CommentThreadCountAggregate {
@Field(() => Int, {nullable:false})
id!: number;
@HideField()
workspaceId!: number;
@Field(() => Int, {nullable:false})
authorId!: number;
@Field(() => Int, {nullable:false})
body!: number;
@Field(() => Int, {nullable:false})
title!: number;
@Field(() => Int, {nullable:false})
type!: number;
@Field(() => Int, {nullable:false})
reminderAt!: number;
@Field(() => Int, {nullable:false})
dueAt!: number;
@Field(() => Int, {nullable:false})
completedAt!: number;
@Field(() => Int, {nullable:false})
assigneeId!: number;
@HideField()
deletedAt!: number;
@Field(() => Int, {nullable:false})
createdAt!: number;
@Field(() => Int, {nullable:false})
updatedAt!: number;
@Field(() => Int, {nullable:false})
_all!: number;
}

47
server/src/core/@generated/comment-thread/comment-thread-count-order-by-aggregate.input.ts
View File

@ -1,47 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { SortOrder } from '../prisma/sort-order.enum';
import { HideField } from '@nestjs/graphql';
@InputType()
export class CommentThreadCountOrderByAggregateInput {
@Field(() => SortOrder, {nullable:true})
id?: keyof typeof SortOrder;
@HideField()
workspaceId?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
authorId?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
body?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
title?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
type?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
reminderAt?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
dueAt?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
completedAt?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
assigneeId?: keyof typeof SortOrder;
@HideField()
deletedAt?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
createdAt?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
updatedAt?: keyof typeof SortOrder;
}

15
server/src/core/@generated/comment-thread/comment-thread-create-many-assignee-input-envelope.input.ts
View File

@ -1,15 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { CommentThreadCreateManyAssigneeInput } from './comment-thread-create-many-assignee.input';
import { Type } from 'class-transformer';
@InputType()
export class CommentThreadCreateManyAssigneeInputEnvelope {
@Field(() => [CommentThreadCreateManyAssigneeInput], {nullable:false})
@Type(() => CommentThreadCreateManyAssigneeInput)
data!: Array<CommentThreadCreateManyAssigneeInput>;
@Field(() => Boolean, {nullable:true})
skipDuplicates?: boolean;
}

47
server/src/core/@generated/comment-thread/comment-thread-create-many-assignee.input.ts
View File

@ -1,47 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import * as Validator from 'class-validator';
import { HideField } from '@nestjs/graphql';
import { ActivityType } from '../prisma/activity-type.enum';
@InputType()
export class CommentThreadCreateManyAssigneeInput {
@Field(() => String, {nullable:true})
@Validator.IsString()
@Validator.IsOptional()
id?: string;
@HideField()
workspaceId!: string;
@Field(() => String, {nullable:false})
authorId!: string;
@Field(() => String, {nullable:true})
body?: string;
@Field(() => String, {nullable:true})
title?: string;
@Field(() => ActivityType, {nullable:true})
type?: keyof typeof ActivityType;
@Field(() => Date, {nullable:true})
reminderAt?: Date | string;
@Field(() => Date, {nullable:true})
dueAt?: Date | string;
@Field(() => Date, {nullable:true})
completedAt?: Date | string;
@HideField()
deletedAt?: Date | string;
@Field(() => Date, {nullable:true})
createdAt?: Date | string;
@Field(() => Date, {nullable:true})
updatedAt?: Date | string;
}

15
server/src/core/@generated/comment-thread/comment-thread-create-many-author-input-envelope.input.ts
View File

@ -1,15 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { CommentThreadCreateManyAuthorInput } from './comment-thread-create-many-author.input';
import { Type } from 'class-transformer';
@InputType()
export class CommentThreadCreateManyAuthorInputEnvelope {
@Field(() => [CommentThreadCreateManyAuthorInput], {nullable:false})
@Type(() => CommentThreadCreateManyAuthorInput)
data!: Array<CommentThreadCreateManyAuthorInput>;
@Field(() => Boolean, {nullable:true})
skipDuplicates?: boolean;
}

47
server/src/core/@generated/comment-thread/comment-thread-create-many-author.input.ts
View File

@ -1,47 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import * as Validator from 'class-validator';
import { HideField } from '@nestjs/graphql';
import { ActivityType } from '../prisma/activity-type.enum';
@InputType()
export class CommentThreadCreateManyAuthorInput {
@Field(() => String, {nullable:true})
@Validator.IsString()
@Validator.IsOptional()
id?: string;
@HideField()
workspaceId!: string;
@Field(() => String, {nullable:true})
body?: string;
@Field(() => String, {nullable:true})
title?: string;
@Field(() => ActivityType, {nullable:true})
type?: keyof typeof ActivityType;
@Field(() => Date, {nullable:true})
reminderAt?: Date | string;
@Field(() => Date, {nullable:true})
dueAt?: Date | string;
@Field(() => Date, {nullable:true})
completedAt?: Date | string;
@Field(() => String, {nullable:true})
assigneeId?: string;
@HideField()
deletedAt?: Date | string;
@Field(() => Date, {nullable:true})
createdAt?: Date | string;
@Field(() => Date, {nullable:true})
updatedAt?: Date | string;
}

15
server/src/core/@generated/comment-thread/comment-thread-create-many-workspace-input-envelope.input.ts
View File

@ -1,15 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { CommentThreadCreateManyWorkspaceInput } from './comment-thread-create-many-workspace.input';
import { Type } from 'class-transformer';
@InputType()
export class CommentThreadCreateManyWorkspaceInputEnvelope {
@Field(() => [CommentThreadCreateManyWorkspaceInput], {nullable:false})
@Type(() => CommentThreadCreateManyWorkspaceInput)
data!: Array<CommentThreadCreateManyWorkspaceInput>;
@Field(() => Boolean, {nullable:true})
skipDuplicates?: boolean;
}

47
server/src/core/@generated/comment-thread/comment-thread-create-many-workspace.input.ts
View File

@ -1,47 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import * as Validator from 'class-validator';
import { ActivityType } from '../prisma/activity-type.enum';
import { HideField } from '@nestjs/graphql';
@InputType()
export class CommentThreadCreateManyWorkspaceInput {
@Field(() => String, {nullable:true})
@Validator.IsString()
@Validator.IsOptional()
id?: string;
@Field(() => String, {nullable:false})
authorId!: string;
@Field(() => String, {nullable:true})
body?: string;
@Field(() => String, {nullable:true})
title?: string;
@Field(() => ActivityType, {nullable:true})
type?: keyof typeof ActivityType;
@Field(() => Date, {nullable:true})
reminderAt?: Date | string;
@Field(() => Date, {nullable:true})
dueAt?: Date | string;
@Field(() => Date, {nullable:true})
completedAt?: Date | string;
@Field(() => String, {nullable:true})
assigneeId?: string;
@HideField()
deletedAt?: Date | string;
@Field(() => Date, {nullable:true})
createdAt?: Date | string;
@Field(() => Date, {nullable:true})
updatedAt?: Date | string;
}

50
server/src/core/@generated/comment-thread/comment-thread-create-many.input.ts
View File

@ -1,50 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import * as Validator from 'class-validator';
import { HideField } from '@nestjs/graphql';
import { ActivityType } from '../prisma/activity-type.enum';
@InputType()
export class CommentThreadCreateManyInput {
@Field(() => String, {nullable:true})
@Validator.IsString()
@Validator.IsOptional()
id?: string;
@HideField()
workspaceId!: string;
@Field(() => String, {nullable:false})
authorId!: string;
@Field(() => String, {nullable:true})
body?: string;
@Field(() => String, {nullable:true})
title?: string;
@Field(() => ActivityType, {nullable:true})
type?: keyof typeof ActivityType;
@Field(() => Date, {nullable:true})
reminderAt?: Date | string;
@Field(() => Date, {nullable:true})
dueAt?: Date | string;
@Field(() => Date, {nullable:true})
completedAt?: Date | string;
@Field(() => String, {nullable:true})
assigneeId?: string;
@HideField()
deletedAt?: Date | string;
@Field(() => Date, {nullable:true})
createdAt?: Date | string;
@Field(() => Date, {nullable:true})
updatedAt?: Date | string;
}

27
server/src/core/@generated/comment-thread/comment-thread-create-nested-many-without-assignee.input.ts
View File

@ -1,27 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { CommentThreadCreateWithoutAssigneeInput } from './comment-thread-create-without-assignee.input';
import { Type } from 'class-transformer';
import { CommentThreadCreateOrConnectWithoutAssigneeInput } from './comment-thread-create-or-connect-without-assignee.input';
import { CommentThreadCreateManyAssigneeInputEnvelope } from './comment-thread-create-many-assignee-input-envelope.input';
import { CommentThreadWhereUniqueInput } from './comment-thread-where-unique.input';
@InputType()
export class CommentThreadCreateNestedManyWithoutAssigneeInput {
@Field(() => [CommentThreadCreateWithoutAssigneeInput], {nullable:true})
@Type(() => CommentThreadCreateWithoutAssigneeInput)
create?: Array<CommentThreadCreateWithoutAssigneeInput>;
@Field(() => [CommentThreadCreateOrConnectWithoutAssigneeInput], {nullable:true})
@Type(() => CommentThreadCreateOrConnectWithoutAssigneeInput)
connectOrCreate?: Array<CommentThreadCreateOrConnectWithoutAssigneeInput>;
@Field(() => CommentThreadCreateManyAssigneeInputEnvelope, {nullable:true})
@Type(() => CommentThreadCreateManyAssigneeInputEnvelope)
createMany?: CommentThreadCreateManyAssigneeInputEnvelope;
@Field(() => [CommentThreadWhereUniqueInput], {nullable:true})
@Type(() => CommentThreadWhereUniqueInput)
connect?: Array<CommentThreadWhereUniqueInput>;
}

27
server/src/core/@generated/comment-thread/comment-thread-create-nested-many-without-author.input.ts
View File

@ -1,27 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { CommentThreadCreateWithoutAuthorInput } from './comment-thread-create-without-author.input';
import { Type } from 'class-transformer';
import { CommentThreadCreateOrConnectWithoutAuthorInput } from './comment-thread-create-or-connect-without-author.input';
import { CommentThreadCreateManyAuthorInputEnvelope } from './comment-thread-create-many-author-input-envelope.input';
import { CommentThreadWhereUniqueInput } from './comment-thread-where-unique.input';
@InputType()
export class CommentThreadCreateNestedManyWithoutAuthorInput {
@Field(() => [CommentThreadCreateWithoutAuthorInput], {nullable:true})
@Type(() => CommentThreadCreateWithoutAuthorInput)
create?: Array<CommentThreadCreateWithoutAuthorInput>;
@Field(() => [CommentThreadCreateOrConnectWithoutAuthorInput], {nullable:true})
@Type(() => CommentThreadCreateOrConnectWithoutAuthorInput)
connectOrCreate?: Array<CommentThreadCreateOrConnectWithoutAuthorInput>;
@Field(() => CommentThreadCreateManyAuthorInputEnvelope, {nullable:true})
@Type(() => CommentThreadCreateManyAuthorInputEnvelope)
createMany?: CommentThreadCreateManyAuthorInputEnvelope;
@Field(() => [CommentThreadWhereUniqueInput], {nullable:true})
@Type(() => CommentThreadWhereUniqueInput)
connect?: Array<CommentThreadWhereUniqueInput>;
}

27
server/src/core/@generated/comment-thread/comment-thread-create-nested-many-without-workspace.input.ts
View File

@ -1,27 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { CommentThreadCreateWithoutWorkspaceInput } from './comment-thread-create-without-workspace.input';
import { Type } from 'class-transformer';
import { CommentThreadCreateOrConnectWithoutWorkspaceInput } from './comment-thread-create-or-connect-without-workspace.input';
import { CommentThreadCreateManyWorkspaceInputEnvelope } from './comment-thread-create-many-workspace-input-envelope.input';
import { CommentThreadWhereUniqueInput } from './comment-thread-where-unique.input';
@InputType()
export class CommentThreadCreateNestedManyWithoutWorkspaceInput {
@Field(() => [CommentThreadCreateWithoutWorkspaceInput], {nullable:true})
@Type(() => CommentThreadCreateWithoutWorkspaceInput)
create?: Array<CommentThreadCreateWithoutWorkspaceInput>;
@Field(() => [CommentThreadCreateOrConnectWithoutWorkspaceInput], {nullable:true})
@Type(() => CommentThreadCreateOrConnectWithoutWorkspaceInput)
connectOrCreate?: Array<CommentThreadCreateOrConnectWithoutWorkspaceInput>;
@Field(() => CommentThreadCreateManyWorkspaceInputEnvelope, {nullable:true})
@Type(() => CommentThreadCreateManyWorkspaceInputEnvelope)
createMany?: CommentThreadCreateManyWorkspaceInputEnvelope;
@Field(() => [CommentThreadWhereUniqueInput], {nullable:true})
@Type(() => CommentThreadWhereUniqueInput)
connect?: Array<CommentThreadWhereUniqueInput>;
}

22
server/src/core/@generated/comment-thread/comment-thread-create-nested-one-without-comment-thread-targets.input.ts
View File

@ -1,22 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { CommentThreadCreateWithoutCommentThreadTargetsInput } from './comment-thread-create-without-comment-thread-targets.input';
import { Type } from 'class-transformer';
import { CommentThreadCreateOrConnectWithoutCommentThreadTargetsInput } from './comment-thread-create-or-connect-without-comment-thread-targets.input';
import { CommentThreadWhereUniqueInput } from './comment-thread-where-unique.input';
@InputType()
export class CommentThreadCreateNestedOneWithoutCommentThreadTargetsInput {
@Field(() => CommentThreadCreateWithoutCommentThreadTargetsInput, {nullable:true})
@Type(() => CommentThreadCreateWithoutCommentThreadTargetsInput)
create?: CommentThreadCreateWithoutCommentThreadTargetsInput;
@Field(() => CommentThreadCreateOrConnectWithoutCommentThreadTargetsInput, {nullable:true})
@Type(() => CommentThreadCreateOrConnectWithoutCommentThreadTargetsInput)
connectOrCreate?: CommentThreadCreateOrConnectWithoutCommentThreadTargetsInput;
@Field(() => CommentThreadWhereUniqueInput, {nullable:true})
@Type(() => CommentThreadWhereUniqueInput)
connect?: CommentThreadWhereUniqueInput;
}

21
server/src/core/@generated/comment-thread/comment-thread-create-nested-one-without-comments.input.ts
View File

@ -1,21 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { CommentThreadCreateWithoutCommentsInput } from './comment-thread-create-without-comments.input';
import { HideField } from '@nestjs/graphql';
import { CommentThreadCreateOrConnectWithoutCommentsInput } from './comment-thread-create-or-connect-without-comments.input';
import { CommentThreadWhereUniqueInput } from './comment-thread-where-unique.input';
import { Type } from 'class-transformer';
@InputType()
export class CommentThreadCreateNestedOneWithoutCommentsInput {
@HideField()
create?: CommentThreadCreateWithoutCommentsInput;
@HideField()
connectOrCreate?: CommentThreadCreateOrConnectWithoutCommentsInput;
@Field(() => CommentThreadWhereUniqueInput, {nullable:true})
@Type(() => CommentThreadWhereUniqueInput)
connect?: CommentThreadWhereUniqueInput;
}

17
server/src/core/@generated/comment-thread/comment-thread-create-or-connect-without-assignee.input.ts
View File

@ -1,17 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { CommentThreadWhereUniqueInput } from './comment-thread-where-unique.input';
import { Type } from 'class-transformer';
import { CommentThreadCreateWithoutAssigneeInput } from './comment-thread-create-without-assignee.input';
@InputType()
export class CommentThreadCreateOrConnectWithoutAssigneeInput {
@Field(() => CommentThreadWhereUniqueInput, {nullable:false})
@Type(() => CommentThreadWhereUniqueInput)
where!: CommentThreadWhereUniqueInput;
@Field(() => CommentThreadCreateWithoutAssigneeInput, {nullable:false})
@Type(() => CommentThreadCreateWithoutAssigneeInput)
create!: CommentThreadCreateWithoutAssigneeInput;
}

17
server/src/core/@generated/comment-thread/comment-thread-create-or-connect-without-author.input.ts
View File

@ -1,17 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { CommentThreadWhereUniqueInput } from './comment-thread-where-unique.input';
import { Type } from 'class-transformer';
import { CommentThreadCreateWithoutAuthorInput } from './comment-thread-create-without-author.input';
@InputType()
export class CommentThreadCreateOrConnectWithoutAuthorInput {
@Field(() => CommentThreadWhereUniqueInput, {nullable:false})
@Type(() => CommentThreadWhereUniqueInput)
where!: CommentThreadWhereUniqueInput;
@Field(() => CommentThreadCreateWithoutAuthorInput, {nullable:false})
@Type(() => CommentThreadCreateWithoutAuthorInput)
create!: CommentThreadCreateWithoutAuthorInput;
}

17
server/src/core/@generated/comment-thread/comment-thread-create-or-connect-without-comment-thread-targets.input.ts
View File

@ -1,17 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { CommentThreadWhereUniqueInput } from './comment-thread-where-unique.input';
import { Type } from 'class-transformer';
import { CommentThreadCreateWithoutCommentThreadTargetsInput } from './comment-thread-create-without-comment-thread-targets.input';
@InputType()
export class CommentThreadCreateOrConnectWithoutCommentThreadTargetsInput {
@Field(() => CommentThreadWhereUniqueInput, {nullable:false})
@Type(() => CommentThreadWhereUniqueInput)
where!: CommentThreadWhereUniqueInput;
@Field(() => CommentThreadCreateWithoutCommentThreadTargetsInput, {nullable:false})
@Type(() => CommentThreadCreateWithoutCommentThreadTargetsInput)
create!: CommentThreadCreateWithoutCommentThreadTargetsInput;
}

17
server/src/core/@generated/comment-thread/comment-thread-create-or-connect-without-comments.input.ts
View File

@ -1,17 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { CommentThreadWhereUniqueInput } from './comment-thread-where-unique.input';
import { Type } from 'class-transformer';
import { CommentThreadCreateWithoutCommentsInput } from './comment-thread-create-without-comments.input';
@InputType()
export class CommentThreadCreateOrConnectWithoutCommentsInput {
@Field(() => CommentThreadWhereUniqueInput, {nullable:false})
@Type(() => CommentThreadWhereUniqueInput)
where!: CommentThreadWhereUniqueInput;
@Field(() => CommentThreadCreateWithoutCommentsInput, {nullable:false})
@Type(() => CommentThreadCreateWithoutCommentsInput)
create!: CommentThreadCreateWithoutCommentsInput;
}

17
server/src/core/@generated/comment-thread/comment-thread-create-or-connect-without-workspace.input.ts
View File

@ -1,17 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { CommentThreadWhereUniqueInput } from './comment-thread-where-unique.input';
import { Type } from 'class-transformer';
import { CommentThreadCreateWithoutWorkspaceInput } from './comment-thread-create-without-workspace.input';
@InputType()
export class CommentThreadCreateOrConnectWithoutWorkspaceInput {
@Field(() => CommentThreadWhereUniqueInput, {nullable:false})
@Type(() => CommentThreadWhereUniqueInput)
where!: CommentThreadWhereUniqueInput;
@Field(() => CommentThreadCreateWithoutWorkspaceInput, {nullable:false})
@Type(() => CommentThreadCreateWithoutWorkspaceInput)
create!: CommentThreadCreateWithoutWorkspaceInput;
}

57
server/src/core/@generated/comment-thread/comment-thread-create-without-assignee.input.ts
View File

@ -1,57 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import * as Validator from 'class-validator';
import { ActivityType } from '../prisma/activity-type.enum';
import { HideField } from '@nestjs/graphql';
import { CommentThreadTargetCreateNestedManyWithoutCommentThreadInput } from '../comment-thread-target/comment-thread-target-create-nested-many-without-comment-thread.input';
import { CommentCreateNestedManyWithoutCommentThreadInput } from '../comment/comment-create-nested-many-without-comment-thread.input';
import { WorkspaceCreateNestedOneWithoutCommentThreadsInput } from '../workspace/workspace-create-nested-one-without-comment-threads.input';
import { UserCreateNestedOneWithoutAuthoredCommentThreadsInput } from '../user/user-create-nested-one-without-authored-comment-threads.input';
@InputType()
export class CommentThreadCreateWithoutAssigneeInput {
@Field(() => String, {nullable:true})
@Validator.IsString()
@Validator.IsOptional()
id?: string;
@Field(() => String, {nullable:true})
body?: string;
@Field(() => String, {nullable:true})
title?: string;
@Field(() => ActivityType, {nullable:true})
type?: keyof typeof ActivityType;
@Field(() => Date, {nullable:true})
reminderAt?: Date | string;
@Field(() => Date, {nullable:true})
dueAt?: Date | string;
@Field(() => Date, {nullable:true})
completedAt?: Date | string;
@HideField()
deletedAt?: Date | string;
@Field(() => Date, {nullable:true})
createdAt?: Date | string;
@Field(() => Date, {nullable:true})
updatedAt?: Date | string;
@Field(() => CommentThreadTargetCreateNestedManyWithoutCommentThreadInput, {nullable:true})
commentThreadTargets?: CommentThreadTargetCreateNestedManyWithoutCommentThreadInput;
@Field(() => CommentCreateNestedManyWithoutCommentThreadInput, {nullable:true})
comments?: CommentCreateNestedManyWithoutCommentThreadInput;
@HideField()
workspace!: WorkspaceCreateNestedOneWithoutCommentThreadsInput;
@Field(() => UserCreateNestedOneWithoutAuthoredCommentThreadsInput, {nullable:false})
author!: UserCreateNestedOneWithoutAuthoredCommentThreadsInput;
}

57
server/src/core/@generated/comment-thread/comment-thread-create-without-author.input.ts
View File

@ -1,57 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import * as Validator from 'class-validator';
import { ActivityType } from '../prisma/activity-type.enum';
import { HideField } from '@nestjs/graphql';
import { CommentThreadTargetCreateNestedManyWithoutCommentThreadInput } from '../comment-thread-target/comment-thread-target-create-nested-many-without-comment-thread.input';
import { CommentCreateNestedManyWithoutCommentThreadInput } from '../comment/comment-create-nested-many-without-comment-thread.input';
import { WorkspaceCreateNestedOneWithoutCommentThreadsInput } from '../workspace/workspace-create-nested-one-without-comment-threads.input';
import { UserCreateNestedOneWithoutAssignedCommentThreadsInput } from '../user/user-create-nested-one-without-assigned-comment-threads.input';
@InputType()
export class CommentThreadCreateWithoutAuthorInput {
@Field(() => String, {nullable:true})
@Validator.IsString()
@Validator.IsOptional()
id?: string;
@Field(() => String, {nullable:true})
body?: string;
@Field(() => String, {nullable:true})
title?: string;
@Field(() => ActivityType, {nullable:true})
type?: keyof typeof ActivityType;
@Field(() => Date, {nullable:true})
reminderAt?: Date | string;
@Field(() => Date, {nullable:true})
dueAt?: Date | string;
@Field(() => Date, {nullable:true})
completedAt?: Date | string;
@HideField()
deletedAt?: Date | string;
@Field(() => Date, {nullable:true})
createdAt?: Date | string;
@Field(() => Date, {nullable:true})
updatedAt?: Date | string;
@Field(() => CommentThreadTargetCreateNestedManyWithoutCommentThreadInput, {nullable:true})
commentThreadTargets?: CommentThreadTargetCreateNestedManyWithoutCommentThreadInput;
@Field(() => CommentCreateNestedManyWithoutCommentThreadInput, {nullable:true})
comments?: CommentCreateNestedManyWithoutCommentThreadInput;
@HideField()
workspace!: WorkspaceCreateNestedOneWithoutCommentThreadsInput;
@Field(() => UserCreateNestedOneWithoutAssignedCommentThreadsInput, {nullable:true})
assignee?: UserCreateNestedOneWithoutAssignedCommentThreadsInput;
}

57
server/src/core/@generated/comment-thread/comment-thread-create-without-comment-thread-targets.input.ts
View File

@ -1,57 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import * as Validator from 'class-validator';
import { ActivityType } from '../prisma/activity-type.enum';
import { HideField } from '@nestjs/graphql';
import { CommentCreateNestedManyWithoutCommentThreadInput } from '../comment/comment-create-nested-many-without-comment-thread.input';
import { WorkspaceCreateNestedOneWithoutCommentThreadsInput } from '../workspace/workspace-create-nested-one-without-comment-threads.input';
import { UserCreateNestedOneWithoutAuthoredCommentThreadsInput } from '../user/user-create-nested-one-without-authored-comment-threads.input';
import { UserCreateNestedOneWithoutAssignedCommentThreadsInput } from '../user/user-create-nested-one-without-assigned-comment-threads.input';
@InputType()
export class CommentThreadCreateWithoutCommentThreadTargetsInput {
@Field(() => String, {nullable:true})
@Validator.IsString()
@Validator.IsOptional()
id?: string;
@Field(() => String, {nullable:true})
body?: string;
@Field(() => String, {nullable:true})
title?: string;
@Field(() => ActivityType, {nullable:true})
type?: keyof typeof ActivityType;
@Field(() => Date, {nullable:true})
reminderAt?: Date | string;
@Field(() => Date, {nullable:true})
dueAt?: Date | string;
@Field(() => Date, {nullable:true})
completedAt?: Date | string;
@HideField()
deletedAt?: Date | string;
@Field(() => Date, {nullable:true})
createdAt?: Date | string;
@Field(() => Date, {nullable:true})
updatedAt?: Date | string;
@Field(() => CommentCreateNestedManyWithoutCommentThreadInput, {nullable:true})
comments?: CommentCreateNestedManyWithoutCommentThreadInput;
@HideField()
workspace!: WorkspaceCreateNestedOneWithoutCommentThreadsInput;
@Field(() => UserCreateNestedOneWithoutAuthoredCommentThreadsInput, {nullable:false})
author!: UserCreateNestedOneWithoutAuthoredCommentThreadsInput;
@Field(() => UserCreateNestedOneWithoutAssignedCommentThreadsInput, {nullable:true})
assignee?: UserCreateNestedOneWithoutAssignedCommentThreadsInput;
}

57
server/src/core/@generated/comment-thread/comment-thread-create-without-comments.input.ts
View File

@ -1,57 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import * as Validator from 'class-validator';
import { ActivityType } from '../prisma/activity-type.enum';
import { HideField } from '@nestjs/graphql';
import { CommentThreadTargetCreateNestedManyWithoutCommentThreadInput } from '../comment-thread-target/comment-thread-target-create-nested-many-without-comment-thread.input';
import { WorkspaceCreateNestedOneWithoutCommentThreadsInput } from '../workspace/workspace-create-nested-one-without-comment-threads.input';
import { UserCreateNestedOneWithoutAuthoredCommentThreadsInput } from '../user/user-create-nested-one-without-authored-comment-threads.input';
import { UserCreateNestedOneWithoutAssignedCommentThreadsInput } from '../user/user-create-nested-one-without-assigned-comment-threads.input';
@InputType()
export class CommentThreadCreateWithoutCommentsInput {
@Field(() => String, {nullable:true})
@Validator.IsString()
@Validator.IsOptional()
id?: string;
@Field(() => String, {nullable:true})
body?: string;
@Field(() => String, {nullable:true})
title?: string;
@Field(() => ActivityType, {nullable:true})
type?: keyof typeof ActivityType;
@Field(() => Date, {nullable:true})
reminderAt?: Date | string;
@Field(() => Date, {nullable:true})
dueAt?: Date | string;
@Field(() => Date, {nullable:true})
completedAt?: Date | string;
@HideField()
deletedAt?: Date | string;
@Field(() => Date, {nullable:true})
createdAt?: Date | string;
@Field(() => Date, {nullable:true})
updatedAt?: Date | string;
@Field(() => CommentThreadTargetCreateNestedManyWithoutCommentThreadInput, {nullable:true})
commentThreadTargets?: CommentThreadTargetCreateNestedManyWithoutCommentThreadInput;
@HideField()
workspace!: WorkspaceCreateNestedOneWithoutCommentThreadsInput;
@Field(() => UserCreateNestedOneWithoutAuthoredCommentThreadsInput, {nullable:false})
author!: UserCreateNestedOneWithoutAuthoredCommentThreadsInput;
@Field(() => UserCreateNestedOneWithoutAssignedCommentThreadsInput, {nullable:true})
assignee?: UserCreateNestedOneWithoutAssignedCommentThreadsInput;
}

57
server/src/core/@generated/comment-thread/comment-thread-create-without-workspace.input.ts
View File

@ -1,57 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import * as Validator from 'class-validator';
import { ActivityType } from '../prisma/activity-type.enum';
import { HideField } from '@nestjs/graphql';
import { CommentThreadTargetCreateNestedManyWithoutCommentThreadInput } from '../comment-thread-target/comment-thread-target-create-nested-many-without-comment-thread.input';
import { CommentCreateNestedManyWithoutCommentThreadInput } from '../comment/comment-create-nested-many-without-comment-thread.input';
import { UserCreateNestedOneWithoutAuthoredCommentThreadsInput } from '../user/user-create-nested-one-without-authored-comment-threads.input';
import { UserCreateNestedOneWithoutAssignedCommentThreadsInput } from '../user/user-create-nested-one-without-assigned-comment-threads.input';
@InputType()
export class CommentThreadCreateWithoutWorkspaceInput {
@Field(() => String, {nullable:true})
@Validator.IsString()
@Validator.IsOptional()
id?: string;
@Field(() => String, {nullable:true})
body?: string;
@Field(() => String, {nullable:true})
title?: string;
@Field(() => ActivityType, {nullable:true})
type?: keyof typeof ActivityType;
@Field(() => Date, {nullable:true})
reminderAt?: Date | string;
@Field(() => Date, {nullable:true})
dueAt?: Date | string;
@Field(() => Date, {nullable:true})
completedAt?: Date | string;
@HideField()
deletedAt?: Date | string;
@Field(() => Date, {nullable:true})
createdAt?: Date | string;
@Field(() => Date, {nullable:true})
updatedAt?: Date | string;
@Field(() => CommentThreadTargetCreateNestedManyWithoutCommentThreadInput, {nullable:true})
commentThreadTargets?: CommentThreadTargetCreateNestedManyWithoutCommentThreadInput;
@Field(() => CommentCreateNestedManyWithoutCommentThreadInput, {nullable:true})
comments?: CommentCreateNestedManyWithoutCommentThreadInput;
@Field(() => UserCreateNestedOneWithoutAuthoredCommentThreadsInput, {nullable:false})
author!: UserCreateNestedOneWithoutAuthoredCommentThreadsInput;
@Field(() => UserCreateNestedOneWithoutAssignedCommentThreadsInput, {nullable:true})
assignee?: UserCreateNestedOneWithoutAssignedCommentThreadsInput;
}

61
server/src/core/@generated/comment-thread/comment-thread-create.input.ts
View File

@ -1,61 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import * as Validator from 'class-validator';
import { ActivityType } from '../prisma/activity-type.enum';
import { HideField } from '@nestjs/graphql';
import { CommentThreadTargetCreateNestedManyWithoutCommentThreadInput } from '../comment-thread-target/comment-thread-target-create-nested-many-without-comment-thread.input';
import { CommentCreateNestedManyWithoutCommentThreadInput } from '../comment/comment-create-nested-many-without-comment-thread.input';
import { WorkspaceCreateNestedOneWithoutCommentThreadsInput } from '../workspace/workspace-create-nested-one-without-comment-threads.input';
import { UserCreateNestedOneWithoutAuthoredCommentThreadsInput } from '../user/user-create-nested-one-without-authored-comment-threads.input';
import { UserCreateNestedOneWithoutAssignedCommentThreadsInput } from '../user/user-create-nested-one-without-assigned-comment-threads.input';
@InputType()
export class CommentThreadCreateInput {
@Field(() => String, {nullable:true})
@Validator.IsString()
@Validator.IsOptional()
id?: string;
@Field(() => String, {nullable:true})
body?: string;
@Field(() => String, {nullable:true})
title?: string;
@Field(() => ActivityType, {nullable:true})
type?: keyof typeof ActivityType;
@Field(() => Date, {nullable:true})
reminderAt?: Date | string;
@Field(() => Date, {nullable:true})
dueAt?: Date | string;
@Field(() => Date, {nullable:true})
completedAt?: Date | string;
@HideField()
deletedAt?: Date | string;
@Field(() => Date, {nullable:true})
createdAt?: Date | string;
@Field(() => Date, {nullable:true})
updatedAt?: Date | string;
@Field(() => CommentThreadTargetCreateNestedManyWithoutCommentThreadInput, {nullable:true})
commentThreadTargets?: CommentThreadTargetCreateNestedManyWithoutCommentThreadInput;
@Field(() => CommentCreateNestedManyWithoutCommentThreadInput, {nullable:true})
comments?: CommentCreateNestedManyWithoutCommentThreadInput;
@HideField()
workspace!: WorkspaceCreateNestedOneWithoutCommentThreadsInput;
@Field(() => UserCreateNestedOneWithoutAuthoredCommentThreadsInput, {nullable:false})
author!: UserCreateNestedOneWithoutAuthoredCommentThreadsInput;
@Field(() => UserCreateNestedOneWithoutAssignedCommentThreadsInput, {nullable:true})
assignee?: UserCreateNestedOneWithoutAssignedCommentThreadsInput;
}

43
server/src/core/@generated/comment-thread/comment-thread-group-by.args.ts
View File

@ -1,43 +0,0 @@
import { Field } from '@nestjs/graphql';
import { ArgsType } from '@nestjs/graphql';
import { CommentThreadWhereInput } from './comment-thread-where.input';
import { Type } from 'class-transformer';
import { CommentThreadOrderByWithAggregationInput } from './comment-thread-order-by-with-aggregation.input';
import { CommentThreadScalarFieldEnum } from './comment-thread-scalar-field.enum';
import { CommentThreadScalarWhereWithAggregatesInput } from './comment-thread-scalar-where-with-aggregates.input';
import { Int } from '@nestjs/graphql';
import { CommentThreadCountAggregateInput } from './comment-thread-count-aggregate.input';
import { CommentThreadMinAggregateInput } from './comment-thread-min-aggregate.input';
import { CommentThreadMaxAggregateInput } from './comment-thread-max-aggregate.input';
@ArgsType()
export class CommentThreadGroupByArgs {
@Field(() => CommentThreadWhereInput, {nullable:true})
@Type(() => CommentThreadWhereInput)
where?: CommentThreadWhereInput;
@Field(() => [CommentThreadOrderByWithAggregationInput], {nullable:true})
orderBy?: Array<CommentThreadOrderByWithAggregationInput>;
@Field(() => [CommentThreadScalarFieldEnum], {nullable:false})
by!: Array<keyof typeof CommentThreadScalarFieldEnum>;
@Field(() => CommentThreadScalarWhereWithAggregatesInput, {nullable:true})
having?: CommentThreadScalarWhereWithAggregatesInput;
@Field(() => Int, {nullable:true})
take?: number;
@Field(() => Int, {nullable:true})
skip?: number;
@Field(() => CommentThreadCountAggregateInput, {nullable:true})
_count?: CommentThreadCountAggregateInput;
@Field(() => CommentThreadMinAggregateInput, {nullable:true})
_min?: CommentThreadMinAggregateInput;
@Field(() => CommentThreadMaxAggregateInput, {nullable:true})
_max?: CommentThreadMaxAggregateInput;
}

62
server/src/core/@generated/comment-thread/comment-thread-group-by.output.ts
View File

@ -1,62 +0,0 @@
import { Field } from '@nestjs/graphql';
import { ObjectType } from '@nestjs/graphql';
import * as Validator from 'class-validator';
import { HideField } from '@nestjs/graphql';
import { ActivityType } from '../prisma/activity-type.enum';
import { CommentThreadCountAggregate } from './comment-thread-count-aggregate.output';
import { CommentThreadMinAggregate } from './comment-thread-min-aggregate.output';
import { CommentThreadMaxAggregate } from './comment-thread-max-aggregate.output';
@ObjectType()
export class CommentThreadGroupBy {
@Field(() => String, {nullable:false})
@Validator.IsString()
@Validator.IsOptional()
id!: string;
@HideField()
workspaceId!: string;
@Field(() => String, {nullable:false})
authorId!: string;
@Field(() => String, {nullable:true})
body?: string;
@Field(() => String, {nullable:true})
title?: string;
@Field(() => ActivityType, {nullable:false})
type!: keyof typeof ActivityType;
@Field(() => Date, {nullable:true})
reminderAt?: Date | string;
@Field(() => Date, {nullable:true})
dueAt?: Date | string;
@Field(() => Date, {nullable:true})
completedAt?: Date | string;
@Field(() => String, {nullable:true})
assigneeId?: string;
@HideField()
deletedAt?: Date | string;
@Field(() => Date, {nullable:false})
createdAt!: Date | string;
@Field(() => Date, {nullable:false})
updatedAt!: Date | string;
@Field(() => CommentThreadCountAggregate, {nullable:true})
_count?: CommentThreadCountAggregate;
@Field(() => CommentThreadMinAggregate, {nullable:true})
_min?: CommentThreadMinAggregate;
@Field(() => CommentThreadMaxAggregate, {nullable:true})
_max?: CommentThreadMaxAggregate;
}

16
server/src/core/@generated/comment-thread/comment-thread-list-relation-filter.input.ts
View File

@ -1,16 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { CommentThreadWhereInput } from './comment-thread-where.input';
@InputType()
export class CommentThreadListRelationFilter {
@Field(() => CommentThreadWhereInput, {nullable:true})
every?: CommentThreadWhereInput;
@Field(() => CommentThreadWhereInput, {nullable:true})
some?: CommentThreadWhereInput;
@Field(() => CommentThreadWhereInput, {nullable:true})
none?: CommentThreadWhereInput;
}

46
server/src/core/@generated/comment-thread/comment-thread-max-aggregate.input.ts
View File

@ -1,46 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { HideField } from '@nestjs/graphql';
@InputType()
export class CommentThreadMaxAggregateInput {
@Field(() => Boolean, {nullable:true})
id?: true;
@HideField()
workspaceId?: true;
@Field(() => Boolean, {nullable:true})
authorId?: true;
@Field(() => Boolean, {nullable:true})
body?: true;
@Field(() => Boolean, {nullable:true})
title?: true;
@Field(() => Boolean, {nullable:true})
type?: true;
@Field(() => Boolean, {nullable:true})
reminderAt?: true;
@Field(() => Boolean, {nullable:true})
dueAt?: true;
@Field(() => Boolean, {nullable:true})
completedAt?: true;
@Field(() => Boolean, {nullable:true})
assigneeId?: true;
@HideField()
deletedAt?: true;
@Field(() => Boolean, {nullable:true})
createdAt?: true;
@Field(() => Boolean, {nullable:true})
updatedAt?: true;
}

50
server/src/core/@generated/comment-thread/comment-thread-max-aggregate.output.ts
View File

@ -1,50 +0,0 @@
import { Field } from '@nestjs/graphql';
import { ObjectType } from '@nestjs/graphql';
import * as Validator from 'class-validator';
import { HideField } from '@nestjs/graphql';
import { ActivityType } from '../prisma/activity-type.enum';
@ObjectType()
export class CommentThreadMaxAggregate {
@Field(() => String, {nullable:true})
@Validator.IsString()
@Validator.IsOptional()
id?: string;
@HideField()
workspaceId?: string;
@Field(() => String, {nullable:true})
authorId?: string;
@Field(() => String, {nullable:true})
body?: string;
@Field(() => String, {nullable:true})
title?: string;
@Field(() => ActivityType, {nullable:true})
type?: keyof typeof ActivityType;
@Field(() => Date, {nullable:true})
reminderAt?: Date | string;
@Field(() => Date, {nullable:true})
dueAt?: Date | string;
@Field(() => Date, {nullable:true})
completedAt?: Date | string;
@Field(() => String, {nullable:true})
assigneeId?: string;
@HideField()
deletedAt?: Date | string;
@Field(() => Date, {nullable:true})
createdAt?: Date | string;
@Field(() => Date, {nullable:true})
updatedAt?: Date | string;
}

47
server/src/core/@generated/comment-thread/comment-thread-max-order-by-aggregate.input.ts
View File

@ -1,47 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { SortOrder } from '../prisma/sort-order.enum';
import { HideField } from '@nestjs/graphql';
@InputType()
export class CommentThreadMaxOrderByAggregateInput {
@Field(() => SortOrder, {nullable:true})
id?: keyof typeof SortOrder;
@HideField()
workspaceId?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
authorId?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
body?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
title?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
type?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
reminderAt?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
dueAt?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
completedAt?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
assigneeId?: keyof typeof SortOrder;
@HideField()
deletedAt?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
createdAt?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
updatedAt?: keyof typeof SortOrder;
}

46
server/src/core/@generated/comment-thread/comment-thread-min-aggregate.input.ts
View File

@ -1,46 +0,0 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { HideField } from '@nestjs/graphql';
@InputType()
export class CommentThreadMinAggregateInput {
@Field(() => Boolean, {nullable:true})
id?: true;
@HideField()
workspaceId?: true;
@Field(() => Boolean, {nullable:true})
authorId?: true;
@Field(() => Boolean, {nullable:true})
body?: true;
@Field(() => Boolean, {nullable:true})
title?: true;
@Field(() => Boolean, {nullable:true})
type?: true;
@Field(() => Boolean, {nullable:true})
reminderAt?: true;
@Field(() => Boolean, {nullable:true})
dueAt?: true;
@Field(() => Boolean, {nullable:true})
completedAt?: true;
@Field(() => Boolean, {nullable:true})
assigneeId?: true;
@HideField()
deletedAt?: true;
@Field(() => Boolean, {nullable:true})
createdAt?: true;
@Field(() => Boolean, {nullable:true})
updatedAt?: true;
}

50
server/src/core/@generated/comment-thread/comment-thread-min-aggregate.output.ts
View File

@ -1,50 +0,0 @@
import { Field } from '@nestjs/graphql';
import { ObjectType } from '@nestjs/graphql';
import * as Validator from 'class-validator';
import { HideField } from '@nestjs/graphql';
import { ActivityType } from '../prisma/activity-type.enum';
@ObjectType()
export class CommentThreadMinAggregate {
@Field(() => String, {nullable:true})
@Validator.IsString()
@Validator.IsOptional()
id?: string;
@HideField()
workspaceId?: string;
@Field(() => String, {nullable:true})
authorId?: string;
@Field(() => String, {nullable:true})
body?: string;
@Field(() => String, {nullable:true})
title?: string;
@Field(() => ActivityType, {nullable:true})
type?: keyof typeof ActivityType;
@Field(() => Date, {nullable:true})
reminderAt?: Date | string;
@Field(() => Date, {nullable:true})
dueAt?: Date | string;
@Field(() => Date, {nullable:true})
completedAt?: Date | string;
@Field(() => String, {nullable:true})
assigneeId?: string;
@HideField()
deletedAt?: Date | string;
@Field(() => Date, {nullable:true})
createdAt?: Date | string;
@Field(() => Date, {nullable:true})
updatedAt?: Date | string;
}

Some files were not shown because too many files have changed in this diff Show More