twentyhq/twenty
1
1
Fork 0
mirror of https://github.com/twentyhq/twenty.git synced 2025-01-03 17:53:58 +03:00
Code Issues Packages Projects Releases Wiki Activity

Add comments to Prisma Schema and GraphQL server (#162)

Browse Source 
* Lowercase all relations in prisma/graphql schema

* Add Comments data model and graphql schema

* Make comments availalble on the api through resolvers and guard them

* Update front graphql schema

* Fix PR
This commit is contained in:
Charles Bochet 2023-05-31 15:41:53 +02:00 committed by GitHub
parent 8bd91139ca
commit a3a3c1924f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
311 changed files with 8480 additions and 202 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
front/src/apollo.tsx
View File

@ -10,8 +10,6 @@ import { RestLink } from 'apollo-link-rest';
import { onError } from '@apollo/client/link/error';
import { refreshAccessToken } from './services/auth/AuthService';
console.log(process.env.REACT_APP_API_URL);
const apiLink = createHttpLink({
uri: `${process.env.REACT_APP_API_URL}`,
});

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

@ -31,12 +31,401 @@ export type BoolFilter = {
not?: InputMaybe<NestedBoolFilter>;
};
export type Comment = {
__typename?: 'Comment';
author: User;
authorId: Scalars['String'];
body: Scalars['String'];
commentThread: CommentThread;
commentThreadId: Scalars['String'];
createdAt: Scalars['DateTime'];
deletedAt?: Maybe<Scalars['DateTime']>;
id: Scalars['ID'];
updatedAt: Scalars['DateTime'];
workspace: Workspace;
workspaceId: Scalars['String'];
};
export type CommentCreateInput = {
author: UserCreateNestedOneWithoutCommentsInput;
body: Scalars['String'];
commentThread: CommentThreadCreateNestedOneWithoutCommentsInput;
createdAt?: InputMaybe<Scalars['DateTime']>;
deletedAt?: InputMaybe<Scalars['DateTime']>;
id: Scalars['String'];
updatedAt?: InputMaybe<Scalars['DateTime']>;
};
export type CommentCreateManyAuthorInput = {
body: Scalars['String'];
commentThreadId: Scalars['String'];
createdAt?: InputMaybe<Scalars['DateTime']>;
deletedAt?: InputMaybe<Scalars['DateTime']>;
id: Scalars['String'];
updatedAt?: InputMaybe<Scalars['DateTime']>;
};
export type CommentCreateManyAuthorInputEnvelope = {
data: Array<CommentCreateManyAuthorInput>;
skipDuplicates?: InputMaybe<Scalars['Boolean']>;
};
export type CommentCreateManyCommentThreadInput = {
authorId: Scalars['String'];
body: Scalars['String'];
createdAt?: InputMaybe<Scalars['DateTime']>;
deletedAt?: InputMaybe<Scalars['DateTime']>;
id: Scalars['String'];
updatedAt?: InputMaybe<Scalars['DateTime']>;
};
export type CommentCreateManyCommentThreadInputEnvelope = {
data: Array<CommentCreateManyCommentThreadInput>;
skipDuplicates?: InputMaybe<Scalars['Boolean']>;
};
export type CommentCreateNestedManyWithoutAuthorInput = {
connect?: InputMaybe<Array<CommentWhereUniqueInput>>;
connectOrCreate?: InputMaybe<Array<CommentCreateOrConnectWithoutAuthorInput>>;
create?: InputMaybe<Array<CommentCreateWithoutAuthorInput>>;
createMany?: InputMaybe<CommentCreateManyAuthorInputEnvelope>;
};
export type CommentCreateNestedManyWithoutCommentThreadInput = {
createMany?: InputMaybe<CommentCreateManyCommentThreadInputEnvelope>;
};
export type CommentCreateOrConnectWithoutAuthorInput = {
create: CommentCreateWithoutAuthorInput;
where: CommentWhereUniqueInput;
};
export type CommentCreateWithoutAuthorInput = {
body: Scalars['String'];
commentThread: CommentThreadCreateNestedOneWithoutCommentsInput;
createdAt?: InputMaybe<Scalars['DateTime']>;
deletedAt?: InputMaybe<Scalars['DateTime']>;
id: Scalars['String'];
updatedAt?: InputMaybe<Scalars['DateTime']>;
};
export type CommentListRelationFilter = {
every?: InputMaybe<CommentWhereInput>;
none?: InputMaybe<CommentWhereInput>;
some?: InputMaybe<CommentWhereInput>;
};
export type CommentOrderByRelationAggregateInput = {
_count?: InputMaybe<SortOrder>;
};
export type CommentScalarWhereInput = {
AND?: InputMaybe<Array<CommentScalarWhereInput>>;
NOT?: InputMaybe<Array<CommentScalarWhereInput>>;
OR?: InputMaybe<Array<CommentScalarWhereInput>>;
authorId?: InputMaybe<StringFilter>;
body?: InputMaybe<StringFilter>;
commentThreadId?: InputMaybe<StringFilter>;
createdAt?: InputMaybe<DateTimeFilter>;
deletedAt?: InputMaybe<DateTimeNullableFilter>;
id?: InputMaybe<StringFilter>;
updatedAt?: InputMaybe<DateTimeFilter>;
};
export type CommentThread = {
__typename?: 'CommentThread';
_count: CommentThreadCount;
commentThreadTargets?: Maybe<Array<CommentThreadTarget>>;
comments?: Maybe<Array<Comment>>;
createdAt: Scalars['DateTime'];
deletedAt?: Maybe<Scalars['DateTime']>;
id: Scalars['ID'];
updatedAt: Scalars['DateTime'];
workspace: Workspace;
workspaceId: Scalars['String'];
};
export type CommentThreadCount = {
__typename?: 'CommentThreadCount';
commentThreadTargets: Scalars['Int'];
comments: Scalars['Int'];
};
export type CommentThreadCreateInput = {
commentThreadTargets?: InputMaybe<CommentThreadTargetCreateNestedManyWithoutCommentThreadInput>;
comments?: InputMaybe<CommentCreateNestedManyWithoutCommentThreadInput>;
createdAt?: InputMaybe<Scalars['DateTime']>;
deletedAt?: InputMaybe<Scalars['DateTime']>;
id: Scalars['String'];
updatedAt?: InputMaybe<Scalars['DateTime']>;
};
export type CommentThreadCreateNestedOneWithoutCommentsInput = {
connect?: InputMaybe<CommentThreadWhereUniqueInput>;
};
export type CommentThreadCreateOrConnectWithoutCommentsInput = {
create: CommentThreadCreateWithoutCommentsInput;
where: CommentThreadWhereUniqueInput;
};
export type CommentThreadCreateWithoutCommentsInput = {
commentThreadTargets?: InputMaybe<CommentThreadTargetCreateNestedManyWithoutCommentThreadInput>;
createdAt?: InputMaybe<Scalars['DateTime']>;
deletedAt?: InputMaybe<Scalars['DateTime']>;
id: Scalars['String'];
updatedAt?: InputMaybe<Scalars['DateTime']>;
};
export type CommentThreadRelationFilter = {
is?: InputMaybe<CommentThreadWhereInput>;
isNot?: InputMaybe<CommentThreadWhereInput>;
};
export type CommentThreadTarget = {
__typename?: 'CommentThreadTarget';
commentThread: CommentThread;
commentThreadId: Scalars['String'];
commentableId: Scalars['String'];
commentableType: CommentableType;
createdAt: Scalars['DateTime'];
deletedAt?: Maybe<Scalars['DateTime']>;
id: Scalars['ID'];
updatedAt: Scalars['DateTime'];
};
export type CommentThreadTargetCreateManyCommentThreadInput = {
commentableId: Scalars['String'];
commentableType: CommentableType;
createdAt?: InputMaybe<Scalars['DateTime']>;
deletedAt?: InputMaybe<Scalars['DateTime']>;
id: Scalars['String'];
updatedAt?: InputMaybe<Scalars['DateTime']>;
};
export type CommentThreadTargetCreateManyCommentThreadInputEnvelope = {
data: Array<CommentThreadTargetCreateManyCommentThreadInput>;
skipDuplicates?: InputMaybe<Scalars['Boolean']>;
};
export type CommentThreadTargetCreateNestedManyWithoutCommentThreadInput = {
createMany?: InputMaybe<CommentThreadTargetCreateManyCommentThreadInputEnvelope>;
};
export type CommentThreadTargetCreateOrConnectWithoutCommentThreadInput = {
create: CommentThreadTargetCreateWithoutCommentThreadInput;
where: CommentThreadTargetWhereUniqueInput;
};
export type CommentThreadTargetCreateWithoutCommentThreadInput = {
commentableId: Scalars['String'];
commentableType: CommentableType;
createdAt?: InputMaybe<Scalars['DateTime']>;
deletedAt?: InputMaybe<Scalars['DateTime']>;
id: Scalars['String'];
updatedAt?: InputMaybe<Scalars['DateTime']>;
};
export type CommentThreadTargetListRelationFilter = {
every?: InputMaybe<CommentThreadTargetWhereInput>;
none?: InputMaybe<CommentThreadTargetWhereInput>;
some?: InputMaybe<CommentThreadTargetWhereInput>;
};
export type CommentThreadTargetScalarWhereInput = {
AND?: InputMaybe<Array<CommentThreadTargetScalarWhereInput>>;
NOT?: InputMaybe<Array<CommentThreadTargetScalarWhereInput>>;
OR?: InputMaybe<Array<CommentThreadTargetScalarWhereInput>>;
commentThreadId?: InputMaybe<StringFilter>;
commentableId?: InputMaybe<StringFilter>;
commentableType?: InputMaybe<EnumCommentableTypeFilter>;
createdAt?: InputMaybe<DateTimeFilter>;
deletedAt?: InputMaybe<DateTimeNullableFilter>;
id?: InputMaybe<StringFilter>;
updatedAt?: InputMaybe<DateTimeFilter>;
};
export type CommentThreadTargetUpdateManyMutationInput = {
commentableId?: InputMaybe<StringFieldUpdateOperationsInput>;
commentableType?: InputMaybe<EnumCommentableTypeFieldUpdateOperationsInput>;
createdAt?: InputMaybe<DateTimeFieldUpdateOperationsInput>;
deletedAt?: InputMaybe<NullableDateTimeFieldUpdateOperationsInput>;
id?: InputMaybe<StringFieldUpdateOperationsInput>;
updatedAt?: InputMaybe<DateTimeFieldUpdateOperationsInput>;
};
export type CommentThreadTargetUpdateManyWithWhereWithoutCommentThreadInput = {
data: CommentThreadTargetUpdateManyMutationInput;
where: CommentThreadTargetScalarWhereInput;
};
export type CommentThreadTargetUpdateManyWithoutCommentThreadNestedInput = {
connect?: InputMaybe<Array<CommentThreadTargetWhereUniqueInput>>;
connectOrCreate?: InputMaybe<Array<CommentThreadTargetCreateOrConnectWithoutCommentThreadInput>>;
create?: InputMaybe<Array<CommentThreadTargetCreateWithoutCommentThreadInput>>;
createMany?: InputMaybe<CommentThreadTargetCreateManyCommentThreadInputEnvelope>;
delete?: InputMaybe<Array<CommentThreadTargetWhereUniqueInput>>;
deleteMany?: InputMaybe<Array<CommentThreadTargetScalarWhereInput>>;
disconnect?: InputMaybe<Array<CommentThreadTargetWhereUniqueInput>>;
set?: InputMaybe<Array<CommentThreadTargetWhereUniqueInput>>;
update?: InputMaybe<Array<CommentThreadTargetUpdateWithWhereUniqueWithoutCommentThreadInput>>;
updateMany?: InputMaybe<Array<CommentThreadTargetUpdateManyWithWhereWithoutCommentThreadInput>>;
upsert?: InputMaybe<Array<CommentThreadTargetUpsertWithWhereUniqueWithoutCommentThreadInput>>;
};
export type CommentThreadTargetUpdateWithWhereUniqueWithoutCommentThreadInput = {
data: CommentThreadTargetUpdateWithoutCommentThreadInput;
where: CommentThreadTargetWhereUniqueInput;
};
export type CommentThreadTargetUpdateWithoutCommentThreadInput = {
commentableId?: InputMaybe<StringFieldUpdateOperationsInput>;
commentableType?: InputMaybe<EnumCommentableTypeFieldUpdateOperationsInput>;
createdAt?: InputMaybe<DateTimeFieldUpdateOperationsInput>;
deletedAt?: InputMaybe<NullableDateTimeFieldUpdateOperationsInput>;
id?: InputMaybe<StringFieldUpdateOperationsInput>;
updatedAt?: InputMaybe<DateTimeFieldUpdateOperationsInput>;
};
export type CommentThreadTargetUpsertWithWhereUniqueWithoutCommentThreadInput = {
create: CommentThreadTargetCreateWithoutCommentThreadInput;
update: CommentThreadTargetUpdateWithoutCommentThreadInput;
where: CommentThreadTargetWhereUniqueInput;
};
export type CommentThreadTargetWhereInput = {
AND?: InputMaybe<Array<CommentThreadTargetWhereInput>>;
NOT?: InputMaybe<Array<CommentThreadTargetWhereInput>>;
OR?: InputMaybe<Array<CommentThreadTargetWhereInput>>;
commentThread?: InputMaybe<CommentThreadRelationFilter>;
commentThreadId?: InputMaybe<StringFilter>;
commentableId?: InputMaybe<StringFilter>;
commentableType?: InputMaybe<EnumCommentableTypeFilter>;
createdAt?: InputMaybe<DateTimeFilter>;
deletedAt?: InputMaybe<DateTimeNullableFilter>;
id?: InputMaybe<StringFilter>;
updatedAt?: InputMaybe<DateTimeFilter>;
};
export type CommentThreadTargetWhereUniqueInput = {
id?: InputMaybe<Scalars['String']>;
};
export type CommentThreadUpdateOneRequiredWithoutCommentsNestedInput = {
connect?: InputMaybe<CommentThreadWhereUniqueInput>;
connectOrCreate?: InputMaybe<CommentThreadCreateOrConnectWithoutCommentsInput>;
create?: InputMaybe<CommentThreadCreateWithoutCommentsInput>;
update?: InputMaybe<CommentThreadUpdateWithoutCommentsInput>;
upsert?: InputMaybe<CommentThreadUpsertWithoutCommentsInput>;
};
export type CommentThreadUpdateWithoutCommentsInput = {
commentThreadTargets?: InputMaybe<CommentThreadTargetUpdateManyWithoutCommentThreadNestedInput>;
createdAt?: InputMaybe<DateTimeFieldUpdateOperationsInput>;
deletedAt?: InputMaybe<NullableDateTimeFieldUpdateOperationsInput>;
id?: InputMaybe<StringFieldUpdateOperationsInput>;
updatedAt?: InputMaybe<DateTimeFieldUpdateOperationsInput>;
};
export type CommentThreadUpsertWithoutCommentsInput = {
create: CommentThreadCreateWithoutCommentsInput;
update: CommentThreadUpdateWithoutCommentsInput;
};
export type CommentThreadWhereInput = {
AND?: InputMaybe<Array<CommentThreadWhereInput>>;
NOT?: InputMaybe<Array<CommentThreadWhereInput>>;
OR?: InputMaybe<Array<CommentThreadWhereInput>>;
commentThreadTargets?: InputMaybe<CommentThreadTargetListRelationFilter>;
comments?: InputMaybe<CommentListRelationFilter>;
createdAt?: InputMaybe<DateTimeFilter>;
deletedAt?: InputMaybe<DateTimeNullableFilter>;
id?: InputMaybe<StringFilter>;
updatedAt?: InputMaybe<DateTimeFilter>;
};
export type CommentThreadWhereUniqueInput = {
id?: InputMaybe<Scalars['String']>;
};
export type CommentUpdateManyMutationInput = {
body?: InputMaybe<StringFieldUpdateOperationsInput>;
createdAt?: InputMaybe<DateTimeFieldUpdateOperationsInput>;
deletedAt?: InputMaybe<NullableDateTimeFieldUpdateOperationsInput>;
id?: InputMaybe<StringFieldUpdateOperationsInput>;
updatedAt?: InputMaybe<DateTimeFieldUpdateOperationsInput>;
};
export type CommentUpdateManyWithWhereWithoutAuthorInput = {
data: CommentUpdateManyMutationInput;
where: CommentScalarWhereInput;
};
export type CommentUpdateManyWithoutAuthorNestedInput = {
connect?: InputMaybe<Array<CommentWhereUniqueInput>>;
connectOrCreate?: InputMaybe<Array<CommentCreateOrConnectWithoutAuthorInput>>;
create?: InputMaybe<Array<CommentCreateWithoutAuthorInput>>;
createMany?: InputMaybe<CommentCreateManyAuthorInputEnvelope>;
delete?: InputMaybe<Array<CommentWhereUniqueInput>>;
deleteMany?: InputMaybe<Array<CommentScalarWhereInput>>;
disconnect?: InputMaybe<Array<CommentWhereUniqueInput>>;
set?: InputMaybe<Array<CommentWhereUniqueInput>>;
update?: InputMaybe<Array<CommentUpdateWithWhereUniqueWithoutAuthorInput>>;
updateMany?: InputMaybe<Array<CommentUpdateManyWithWhereWithoutAuthorInput>>;
upsert?: InputMaybe<Array<CommentUpsertWithWhereUniqueWithoutAuthorInput>>;
};
export type CommentUpdateWithWhereUniqueWithoutAuthorInput = {
data: CommentUpdateWithoutAuthorInput;
where: CommentWhereUniqueInput;
};
export type CommentUpdateWithoutAuthorInput = {
body?: InputMaybe<StringFieldUpdateOperationsInput>;
commentThread?: InputMaybe<CommentThreadUpdateOneRequiredWithoutCommentsNestedInput>;
createdAt?: InputMaybe<DateTimeFieldUpdateOperationsInput>;
deletedAt?: InputMaybe<NullableDateTimeFieldUpdateOperationsInput>;
id?: InputMaybe<StringFieldUpdateOperationsInput>;
updatedAt?: InputMaybe<DateTimeFieldUpdateOperationsInput>;
};
export type CommentUpsertWithWhereUniqueWithoutAuthorInput = {
create: CommentCreateWithoutAuthorInput;
update: CommentUpdateWithoutAuthorInput;
where: CommentWhereUniqueInput;
};
export type CommentWhereInput = {
AND?: InputMaybe<Array<CommentWhereInput>>;
NOT?: InputMaybe<Array<CommentWhereInput>>;
OR?: InputMaybe<Array<CommentWhereInput>>;
author?: InputMaybe<UserRelationFilter>;
authorId?: InputMaybe<StringFilter>;
body?: InputMaybe<StringFilter>;
commentThread?: InputMaybe<CommentThreadRelationFilter>;
commentThreadId?: InputMaybe<StringFilter>;
createdAt?: InputMaybe<DateTimeFilter>;
deletedAt?: InputMaybe<DateTimeNullableFilter>;
id?: InputMaybe<StringFilter>;
updatedAt?: InputMaybe<DateTimeFilter>;
};
export type CommentWhereUniqueInput = {
id?: InputMaybe<Scalars['String']>;
};
export enum CommentableType {
Company = 'Company',
Person = 'Person'
}
export type Company = {
__typename?: 'Company';
_count: CompanyCount;
accountOwner?: Maybe<User>;
accountOwnerId?: Maybe<Scalars['String']>;
address: Scalars['String'];
commentThreads: Array<CommentThread>;
createdAt: Scalars['DateTime'];
deletedAt?: Maybe<Scalars['DateTime']>;
domainName: Scalars['String'];
@ -219,6 +608,17 @@ export type DateTimeNullableFilter = {
notIn?: InputMaybe<Array<Scalars['DateTime']>>;
};
export type EnumCommentableTypeFieldUpdateOperationsInput = {
set?: InputMaybe<CommentableType>;
};
export type EnumCommentableTypeFilter = {
equals?: InputMaybe<CommentableType>;
in?: InputMaybe<Array<CommentableType>>;
not?: InputMaybe<NestedEnumCommentableTypeFilter>;
notIn?: InputMaybe<Array<CommentableType>>;
};
export type IntNullableFilter = {
equals?: InputMaybe<Scalars['Int']>;
gt?: InputMaybe<Scalars['Int']>;
@ -248,6 +648,8 @@ export type JsonNullableFilter = {
export type Mutation = {
__typename?: 'Mutation';
createOneComment: Comment;
createOneCommentThread: CommentThread;
createOneCompany: Company;
createOnePerson: Person;
deleteManyCompany: AffectedRows;
@ -257,6 +659,16 @@ export type Mutation = {
};
export type MutationCreateOneCommentArgs = {
data: CommentCreateInput;
};
export type MutationCreateOneCommentThreadArgs = {
data: CommentThreadCreateInput;
};
export type MutationCreateOneCompanyArgs = {
data: CompanyCreateInput;
};
@ -315,6 +727,13 @@ export type NestedDateTimeNullableFilter = {
notIn?: InputMaybe<Array<Scalars['DateTime']>>;
};
export type NestedEnumCommentableTypeFilter = {
equals?: InputMaybe<CommentableType>;
in?: InputMaybe<Array<CommentableType>>;
not?: InputMaybe<NestedEnumCommentableTypeFilter>;
notIn?: InputMaybe<Array<CommentableType>>;
};
export type NestedIntNullableFilter = {
equals?: InputMaybe<Scalars['Int']>;
gt?: InputMaybe<Scalars['Int']>;
@ -373,6 +792,7 @@ export type NullableStringFieldUpdateOperationsInput = {
export type Person = {
__typename?: 'Person';
city: Scalars['String'];
commentThreads: Array<CommentThread>;
company?: Maybe<Company>;
companyId?: Maybe<Scalars['String']>;
createdAt: Scalars['DateTime'];
@ -814,10 +1234,9 @@ export type StringNullableFilter = {
export type User = {
__typename?: 'User';
RefreshTokens?: Maybe<Array<RefreshToken>>;
WorkspaceMember?: Maybe<WorkspaceMember>;
_count: UserCount;
avatarUrl?: Maybe<Scalars['String']>;
comments?: Maybe<Array<Comment>>;
companies?: Maybe<Array<Company>>;
createdAt: Scalars['DateTime'];
deletedAt?: Maybe<Scalars['DateTime']>;
@ -831,17 +1250,9 @@ export type User = {
metadata?: Maybe<Scalars['JSON']>;
passwordHash?: Maybe<Scalars['String']>;
phoneNumber?: Maybe<Scalars['String']>;
refreshTokens?: Maybe<Array<RefreshToken>>;
updatedAt: Scalars['DateTime'];
};
export type UserRefreshTokensArgs = {
cursor?: InputMaybe<RefreshTokenWhereUniqueInput>;
distinct?: InputMaybe<Array<RefreshTokenScalarFieldEnum>>;
orderBy?: InputMaybe<Array<RefreshTokenOrderByWithRelationInput>>;
skip?: InputMaybe<Scalars['Int']>;
take?: InputMaybe<Scalars['Int']>;
where?: InputMaybe<RefreshTokenWhereInput>;
workspaceMember?: Maybe<WorkspaceMember>;
};
@ -854,10 +1265,25 @@ export type UserCompaniesArgs = {
where?: InputMaybe<CompanyWhereInput>;
};
export type UserRefreshTokensArgs = {
cursor?: InputMaybe<RefreshTokenWhereUniqueInput>;
distinct?: InputMaybe<Array<RefreshTokenScalarFieldEnum>>;
orderBy?: InputMaybe<Array<RefreshTokenOrderByWithRelationInput>>;
skip?: InputMaybe<Scalars['Int']>;
take?: InputMaybe<Scalars['Int']>;
where?: InputMaybe<RefreshTokenWhereInput>;
};
export type UserCount = {
__typename?: 'UserCount';
RefreshTokens: Scalars['Int'];
comments: Scalars['Int'];
companies: Scalars['Int'];
refreshTokens: Scalars['Int'];
};
export type UserCreateNestedOneWithoutCommentsInput = {
connect?: InputMaybe<UserWhereUniqueInput>;
};
export type UserCreateNestedOneWithoutCompaniesInput = {
@ -872,9 +1298,8 @@ export type UserCreateOrConnectWithoutCompaniesInput = {
};
export type UserCreateWithoutCompaniesInput = {
RefreshTokens?: InputMaybe<RefreshTokenCreateNestedManyWithoutUserInput>;
WorkspaceMember?: InputMaybe<WorkspaceMemberCreateNestedOneWithoutUserInput>;
avatarUrl?: InputMaybe<Scalars['String']>;
comments?: InputMaybe<CommentCreateNestedManyWithoutAuthorInput>;
createdAt?: InputMaybe<Scalars['DateTime']>;
deletedAt?: InputMaybe<Scalars['DateTime']>;
disabled?: InputMaybe<Scalars['Boolean']>;
@ -887,13 +1312,14 @@ export type UserCreateWithoutCompaniesInput = {
metadata?: InputMaybe<Scalars['JSON']>;
passwordHash?: InputMaybe<Scalars['String']>;
phoneNumber?: InputMaybe<Scalars['String']>;
refreshTokens?: InputMaybe<RefreshTokenCreateNestedManyWithoutUserInput>;
updatedAt?: InputMaybe<Scalars['DateTime']>;
workspaceMember?: InputMaybe<WorkspaceMemberCreateNestedOneWithoutUserInput>;
};
export type UserOrderByWithRelationInput = {
RefreshTokens?: InputMaybe<RefreshTokenOrderByRelationAggregateInput>;
WorkspaceMember?: InputMaybe<WorkspaceMemberOrderByWithRelationInput>;
avatarUrl?: InputMaybe<SortOrder>;
comments?: InputMaybe<CommentOrderByRelationAggregateInput>;
companies?: InputMaybe<CompanyOrderByRelationAggregateInput>;
createdAt?: InputMaybe<SortOrder>;
deletedAt?: InputMaybe<SortOrder>;
@ -907,7 +1333,9 @@ export type UserOrderByWithRelationInput = {
metadata?: InputMaybe<SortOrder>;
passwordHash?: InputMaybe<SortOrder>;
phoneNumber?: InputMaybe<SortOrder>;
refreshTokens?: InputMaybe<RefreshTokenOrderByRelationAggregateInput>;
updatedAt?: InputMaybe<SortOrder>;
workspaceMember?: InputMaybe<WorkspaceMemberOrderByWithRelationInput>;
};
export type UserRelationFilter = {
@ -943,9 +1371,8 @@ export type UserUpdateOneWithoutCompaniesNestedInput = {
};
export type UserUpdateWithoutCompaniesInput = {
RefreshTokens?: InputMaybe<RefreshTokenUpdateManyWithoutUserNestedInput>;
WorkspaceMember?: InputMaybe<WorkspaceMemberUpdateOneWithoutUserNestedInput>;
avatarUrl?: InputMaybe<NullableStringFieldUpdateOperationsInput>;
comments?: InputMaybe<CommentUpdateManyWithoutAuthorNestedInput>;
createdAt?: InputMaybe<DateTimeFieldUpdateOperationsInput>;
deletedAt?: InputMaybe<NullableDateTimeFieldUpdateOperationsInput>;
disabled?: InputMaybe<BoolFieldUpdateOperationsInput>;
@ -958,7 +1385,9 @@ export type UserUpdateWithoutCompaniesInput = {
metadata?: InputMaybe<Scalars['JSON']>;
passwordHash?: InputMaybe<NullableStringFieldUpdateOperationsInput>;
phoneNumber?: InputMaybe<NullableStringFieldUpdateOperationsInput>;
refreshTokens?: InputMaybe<RefreshTokenUpdateManyWithoutUserNestedInput>;
updatedAt?: InputMaybe<DateTimeFieldUpdateOperationsInput>;
workspaceMember?: InputMaybe<WorkspaceMemberUpdateOneWithoutUserNestedInput>;
};
export type UserUpsertWithoutCompaniesInput = {
@ -970,9 +1399,8 @@ export type UserWhereInput = {
AND?: InputMaybe<Array<UserWhereInput>>;
NOT?: InputMaybe<Array<UserWhereInput>>;
OR?: InputMaybe<Array<UserWhereInput>>;
RefreshTokens?: InputMaybe<RefreshTokenListRelationFilter>;
WorkspaceMember?: InputMaybe<WorkspaceMemberRelationFilter>;
avatarUrl?: InputMaybe<StringNullableFilter>;
comments?: InputMaybe<CommentListRelationFilter>;
companies?: InputMaybe<CompanyListRelationFilter>;
createdAt?: InputMaybe<DateTimeFilter>;
deletedAt?: InputMaybe<DateTimeNullableFilter>;
@ -986,7 +1414,9 @@ export type UserWhereInput = {
metadata?: InputMaybe<JsonNullableFilter>;
passwordHash?: InputMaybe<StringNullableFilter>;
phoneNumber?: InputMaybe<StringNullableFilter>;
refreshTokens?: InputMaybe<RefreshTokenListRelationFilter>;
updatedAt?: InputMaybe<DateTimeFilter>;
workspaceMember?: InputMaybe<WorkspaceMemberRelationFilter>;
};
export type UserWhereUniqueInput = {
@ -996,8 +1426,9 @@ export type UserWhereUniqueInput = {
export type Workspace = {
__typename?: 'Workspace';
WorkspaceMember?: Maybe<Array<WorkspaceMember>>;
_count: WorkspaceCount;
commentThreads?: Maybe<Array<CommentThread>>;
comments?: Maybe<Array<Comment>>;
companies?: Maybe<Array<Company>>;
createdAt: Scalars['DateTime'];
deletedAt?: Maybe<Scalars['DateTime']>;
@ -1007,13 +1438,16 @@ export type Workspace = {
logo?: Maybe<Scalars['String']>;
people?: Maybe<Array<Person>>;
updatedAt: Scalars['DateTime'];
workspaceMember?: Maybe<Array<WorkspaceMember>>;
};
export type WorkspaceCount = {
__typename?: 'WorkspaceCount';
WorkspaceMember: Scalars['Int'];
commentThreads: Scalars['Int'];
comments: Scalars['Int'];
companies: Scalars['Int'];
people: Scalars['Int'];
workspaceMember: Scalars['Int'];
};
export type WorkspaceMember = {
@ -1105,7 +1539,7 @@ export type GetCompaniesQueryVariables = Exact<{
}>;
export type GetCompaniesQuery = { __typename?: 'Query', findManyCompany: Array<{ __typename?: 'Company', id: string, domainName: string, name: string, createdAt: any, address: string, employees?: number | null, accountOwner?: { __typename?: 'User', id: string, email: string, displayName: string } | null }> };
export type GetCompaniesQuery = { __typename?: 'Query', companies: Array<{ __typename?: 'Company', id: string, domainName: string, name: string, createdAt: any, address: string, employees?: number | null, accountOwner?: { __typename?: 'User', id: string, email: string, displayName: string } | null }> };
export type UpdateCompanyMutationVariables = Exact<{
id?: InputMaybe<Scalars['String']>;
@ -1146,7 +1580,7 @@ export type GetPeopleQueryVariables = Exact<{
}>;
export type GetPeopleQuery = { __typename?: 'Query', findManyPerson: Array<{ __typename?: 'Person', id: string, phone: string, email: string, city: string, firstname: string, lastname: string, createdAt: any, company?: { __typename?: 'Company', id: string, name: string, domainName: string } | null }> };
export type GetPeopleQuery = { __typename?: 'Query', people: Array<{ __typename?: 'Person', id: string, phone: string, email: string, city: string, firstname: string, lastname: string, createdAt: any, company?: { __typename?: 'Company', id: string, name: string, domainName: string } | null }> };
export type UpdatePeopleMutationVariables = Exact<{
id?: InputMaybe<Scalars['String']>;
@ -1201,7 +1635,7 @@ export type SearchUserQueryQuery = { __typename?: 'Query', searchResults: Array<
export type EmptyQueryQueryVariables = Exact<{ [key: string]: never; }>;
export type EmptyQueryQuery = { __typename?: 'Query', findManyUser: Array<{ __typename?: 'User', id: string }> };
export type EmptyQueryQuery = { __typename?: 'Query', searchResults: Array<{ __typename?: 'User', id: string }> };
export type SearchCompanyQueryQueryVariables = Exact<{
where?: InputMaybe<CompanyWhereInput>;
@ -1216,7 +1650,7 @@ export type GetCurrentUserQueryVariables = Exact<{
}>;
export type GetCurrentUserQuery = { __typename?: 'Query', findManyUser: Array<{ __typename?: 'User', id: string, email: string, displayName: string, workspaceMember?: { __typename?: 'WorkspaceMember', workspace: { __typename?: 'Workspace', id: string, domainName: string, displayName: string, logo?: string | null } } | null }> };
export type GetCurrentUserQuery = { __typename?: 'Query', users: Array<{ __typename?: 'User', id: string, email: string, displayName: string, workspaceMember?: { __typename?: 'WorkspaceMember', workspace: { __typename?: 'Workspace', id: string, domainName: string, displayName: string, logo?: string | null } } | null }> };
export type GetUsersQueryVariables = Exact<{ [key: string]: never; }>;
@ -1226,7 +1660,7 @@ export type GetUsersQuery = { __typename?: 'Query', findManyUser: Array<{ __type
export const GetCompaniesDocument = gql`
query GetCompanies($orderBy: [CompanyOrderByWithRelationInput!], $where: CompanyWhereInput) {
findManyCompany(orderBy: $orderBy, where: $where) {
companies: findManyCompany(orderBy: $orderBy, where: $where) {
id
domainName
name
@ -1402,7 +1836,7 @@ export type DeleteCompaniesMutationResult = Apollo.MutationResult<DeleteCompanie
export type DeleteCompaniesMutationOptions = Apollo.BaseMutationOptions<DeleteCompaniesMutation, DeleteCompaniesMutationVariables>;
export const GetPeopleDocument = gql`
query GetPeople($orderBy: [PersonOrderByWithRelationInput!], $where: PersonWhereInput, $limit: Int) {
findManyPerson(orderBy: $orderBy, where: $where, take: $limit) {
people: findManyPerson(orderBy: $orderBy, where: $where, take: $limit) {
id
phone
email
@ -1669,7 +2103,7 @@ export type SearchUserQueryLazyQueryHookResult = ReturnType<typeof useSearchUser
export type SearchUserQueryQueryResult = Apollo.QueryResult<SearchUserQueryQuery, SearchUserQueryQueryVariables>;
export const EmptyQueryDocument = gql`
query EmptyQuery {
findManyUser {
searchResults: findManyUser {
id
}
}
@ -1741,11 +2175,11 @@ export type SearchCompanyQueryLazyQueryHookResult = ReturnType<typeof useSearchC
export type SearchCompanyQueryQueryResult = Apollo.QueryResult<SearchCompanyQueryQuery, SearchCompanyQueryQueryVariables>;
export const GetCurrentUserDocument = gql`
query getCurrentUser($uuid: String) {
findManyUser(where: {id: {equals: $uuid}}) {
users: findManyUser(where: {id: {equals: $uuid}}) {
id
email
displayName
workspaceMember: WorkspaceMember {
workspaceMember {
workspace {
id
domainName

1
front/src/pages/auth/Callback.tsx
View File

@ -7,7 +7,6 @@ function Callback() {
const [isLoading, setIsLoading] = useState(true);
const refreshToken = searchParams.get('refreshToken');
console.log('refreshToken', refreshToken);
localStorage.setItem('refreshToken', refreshToken || '');
const navigate = useNavigate();

2
front/src/services/api/users/index.tsx
View File

@ -7,7 +7,7 @@ export const GET_CURRENT_USER = gql`
id
email
displayName
workspaceMember: WorkspaceMember {
workspaceMember {
workspace {
id
domainName

17
server/src/api/@generated/comment-thread-target/aggregate-comment-thread-target.output.ts Normal file
View File

@ -0,0 +1,17 @@
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;
}

40
server/src/api/@generated/comment-thread-target/comment-thread-target-aggregate.args.ts Normal file
View File

@ -0,0 +1,40 @@
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;
}

29
server/src/api/@generated/comment-thread-target/comment-thread-target-count-aggregate.input.ts Normal file
View File

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

30
server/src/api/@generated/comment-thread-target/comment-thread-target-count-aggregate.output.ts Normal file
View File

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

27
server/src/api/@generated/comment-thread-target/comment-thread-target-count-order-by-aggregate.input.ts Normal file
View File

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

16
server/src/api/@generated/comment-thread-target/comment-thread-target-create-many-comment-thread-input-envelope.input.ts Normal file
View File

@ -0,0 +1,16 @@
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;
}

24
server/src/api/@generated/comment-thread-target/comment-thread-target-create-many-comment-thread.input.ts Normal file
View File

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

27
server/src/api/@generated/comment-thread-target/comment-thread-target-create-many.input.ts Normal file
View File

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

26
server/src/api/@generated/comment-thread-target/comment-thread-target-create-nested-many-without-comment-thread.input.ts Normal file
View File

@ -0,0 +1,26 @@
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>;
}

18
server/src/api/@generated/comment-thread-target/comment-thread-target-create-or-connect-without-comment-thread.input.ts Normal file
View File

@ -0,0 +1,18 @@
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;
}

24
server/src/api/@generated/comment-thread-target/comment-thread-target-create-without-comment-thread.input.ts Normal file
View File

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

30
server/src/api/@generated/comment-thread-target/comment-thread-target-create.input.ts Normal file
View File

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

46
server/src/api/@generated/comment-thread-target/comment-thread-target-group-by.args.ts Normal file
View File

@ -0,0 +1,46 @@
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;
}

39
server/src/api/@generated/comment-thread-target/comment-thread-target-group-by.output.ts Normal file
View File

@ -0,0 +1,39 @@
import { Field } from '@nestjs/graphql';
import { ObjectType } from '@nestjs/graphql';
import { CommentableType } from '../prisma/commentable-type.enum';
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 })
id!: string;
@Field(() => Date, { nullable: false })
createdAt!: Date | string;
@Field(() => Date, { nullable: false })
updatedAt!: Date | string;
@Field(() => Date, { nullable: true })
deletedAt?: Date | string;
@Field(() => String, { nullable: false })
commentThreadId!: string;
@Field(() => CommentableType, { nullable: false })
commentableType!: keyof typeof CommentableType;
@Field(() => String, { nullable: false })
commentableId!: string;
@Field(() => CommentThreadTargetCountAggregate, { nullable: true })
_count?: CommentThreadTargetCountAggregate;
@Field(() => CommentThreadTargetMinAggregate, { nullable: true })
_min?: CommentThreadTargetMinAggregate;
@Field(() => CommentThreadTargetMaxAggregate, { nullable: true })
_max?: CommentThreadTargetMaxAggregate;
}

15
server/src/api/@generated/comment-thread-target/comment-thread-target-list-relation-filter.input.ts Normal file
View File

@ -0,0 +1,15 @@
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;
}

26
server/src/api/@generated/comment-thread-target/comment-thread-target-max-aggregate.input.ts Normal file
View File

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

27
server/src/api/@generated/comment-thread-target/comment-thread-target-max-aggregate.output.ts Normal file
View File

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

27
server/src/api/@generated/comment-thread-target/comment-thread-target-max-order-by-aggregate.input.ts Normal file
View File

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

26
server/src/api/@generated/comment-thread-target/comment-thread-target-min-aggregate.input.ts Normal file
View File

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

27
server/src/api/@generated/comment-thread-target/comment-thread-target-min-aggregate.output.ts Normal file
View File

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

27
server/src/api/@generated/comment-thread-target/comment-thread-target-min-order-by-aggregate.input.ts Normal file
View File

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

9
server/src/api/@generated/comment-thread-target/comment-thread-target-order-by-relation-aggregate.input.ts Normal file
View File

@ -0,0 +1,9 @@
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/api/@generated/comment-thread-target/comment-thread-target-order-by-with-aggregation.input.ts Normal file
View File

@ -0,0 +1,41 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { SortOrder } from '../prisma/sort-order.enum';
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 })
createdAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true })
updatedAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true })
deletedAt?: 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;
@Field(() => CommentThreadTargetCountOrderByAggregateInput, {
nullable: true,
})
_count?: CommentThreadTargetCountOrderByAggregateInput;
@Field(() => CommentThreadTargetMaxOrderByAggregateInput, { nullable: true })
_max?: CommentThreadTargetMaxOrderByAggregateInput;
@Field(() => CommentThreadTargetMinOrderByAggregateInput, { nullable: true })
_min?: CommentThreadTargetMinOrderByAggregateInput;
}

31
server/src/api/@generated/comment-thread-target/comment-thread-target-order-by-with-relation.input.ts Normal file
View File

@ -0,0 +1,31 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { SortOrder } from '../prisma/sort-order.enum';
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 })
createdAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true })
updatedAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true })
deletedAt?: 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;
@Field(() => CommentThreadOrderByWithRelationInput, { nullable: true })
commentThread?: CommentThreadOrderByWithRelationInput;
}

16
server/src/api/@generated/comment-thread-target/comment-thread-target-scalar-field.enum.ts Normal file
View File

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

45
server/src/api/@generated/comment-thread-target/comment-thread-target-scalar-where-with-aggregates.input.ts Normal file
View File

@ -0,0 +1,45 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { StringWithAggregatesFilter } from '../prisma/string-with-aggregates-filter.input';
import { DateTimeWithAggregatesFilter } from '../prisma/date-time-with-aggregates-filter.input';
import { DateTimeNullableWithAggregatesFilter } from '../prisma/date-time-nullable-with-aggregates-filter.input';
import { EnumCommentableTypeWithAggregatesFilter } from '../prisma/enum-commentable-type-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(() => DateTimeWithAggregatesFilter, { nullable: true })
createdAt?: DateTimeWithAggregatesFilter;
@Field(() => DateTimeWithAggregatesFilter, { nullable: true })
updatedAt?: DateTimeWithAggregatesFilter;
@Field(() => DateTimeNullableWithAggregatesFilter, { nullable: true })
deletedAt?: DateTimeNullableWithAggregatesFilter;
@Field(() => StringWithAggregatesFilter, { nullable: true })
commentThreadId?: StringWithAggregatesFilter;
@Field(() => EnumCommentableTypeWithAggregatesFilter, { nullable: true })
commentableType?: EnumCommentableTypeWithAggregatesFilter;
@Field(() => StringWithAggregatesFilter, { nullable: true })
commentableId?: StringWithAggregatesFilter;
}

39
server/src/api/@generated/comment-thread-target/comment-thread-target-scalar-where.input.ts Normal file
View File

@ -0,0 +1,39 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { StringFilter } from '../prisma/string-filter.input';
import { DateTimeFilter } from '../prisma/date-time-filter.input';
import { DateTimeNullableFilter } from '../prisma/date-time-nullable-filter.input';
import { EnumCommentableTypeFilter } from '../prisma/enum-commentable-type-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(() => DateTimeFilter, { nullable: true })
createdAt?: DateTimeFilter;
@Field(() => DateTimeFilter, { nullable: true })
updatedAt?: DateTimeFilter;
@Field(() => DateTimeNullableFilter, { nullable: true })
deletedAt?: DateTimeNullableFilter;
@Field(() => StringFilter, { nullable: true })
commentThreadId?: StringFilter;
@Field(() => EnumCommentableTypeFilter, { nullable: true })
commentableType?: EnumCommentableTypeFilter;
@Field(() => StringFilter, { nullable: true })
commentableId?: StringFilter;
}

32
server/src/api/@generated/comment-thread-target/comment-thread-target-unchecked-create-nested-many-without-comment-thread.input.ts Normal file
View File

@ -0,0 +1,32 @@
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>;
}

24
server/src/api/@generated/comment-thread-target/comment-thread-target-unchecked-create-without-comment-thread.input.ts Normal file
View File

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

27
server/src/api/@generated/comment-thread-target/comment-thread-target-unchecked-create.input.ts Normal file
View File

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

73
server/src/api/@generated/comment-thread-target/comment-thread-target-unchecked-update-many-without-comment-thread-nested.input.ts Normal file
View File

@ -0,0 +1,73 @@
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/api/@generated/comment-thread-target/comment-thread-target-unchecked-update-many-without-comment-thread-targets.input.ts Normal file
View File

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

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

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

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

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

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

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

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

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

16
server/src/api/@generated/comment-thread-target/comment-thread-target-update-many-with-where-without-comment-thread.input.ts Normal file
View File

@ -0,0 +1,16 @@
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;
}

73
server/src/api/@generated/comment-thread-target/comment-thread-target-update-many-without-comment-thread-nested.input.ts Normal file
View File

@ -0,0 +1,73 @@
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>;
}

18
server/src/api/@generated/comment-thread-target/comment-thread-target-update-with-where-unique-without-comment-thread.input.ts Normal file
View File

@ -0,0 +1,18 @@
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/api/@generated/comment-thread-target/comment-thread-target-update-without-comment-thread.input.ts Normal file
View File

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

36
server/src/api/@generated/comment-thread-target/comment-thread-target-update.input.ts Normal file
View File

@ -0,0 +1,36 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-operations.input';
import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
import { EnumCommentableTypeFieldUpdateOperationsInput } from '../prisma/enum-commentable-type-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(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
createdAt?: DateTimeFieldUpdateOperationsInput;
@Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
updatedAt?: DateTimeFieldUpdateOperationsInput;
@Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true })
deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
@Field(() => EnumCommentableTypeFieldUpdateOperationsInput, {
nullable: true,
})
commentableType?: EnumCommentableTypeFieldUpdateOperationsInput;
@Field(() => StringFieldUpdateOperationsInput, { nullable: true })
commentableId?: StringFieldUpdateOperationsInput;
@Field(
() => CommentThreadUpdateOneRequiredWithoutCommentThreadTargetsNestedInput,
{ nullable: true },
)
commentThread?: CommentThreadUpdateOneRequiredWithoutCommentThreadTargetsNestedInput;
}

25
server/src/api/@generated/comment-thread-target/comment-thread-target-upsert-with-where-unique-without-comment-thread.input.ts Normal file
View File

@ -0,0 +1,25 @@
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;
}

8
server/src/api/@generated/comment-thread-target/comment-thread-target-where-unique.input.ts Normal file
View File

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

43
server/src/api/@generated/comment-thread-target/comment-thread-target-where.input.ts Normal file
View File

@ -0,0 +1,43 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { StringFilter } from '../prisma/string-filter.input';
import { DateTimeFilter } from '../prisma/date-time-filter.input';
import { DateTimeNullableFilter } from '../prisma/date-time-nullable-filter.input';
import { EnumCommentableTypeFilter } from '../prisma/enum-commentable-type-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(() => DateTimeFilter, { nullable: true })
createdAt?: DateTimeFilter;
@Field(() => DateTimeFilter, { nullable: true })
updatedAt?: DateTimeFilter;
@Field(() => DateTimeNullableFilter, { nullable: true })
deletedAt?: DateTimeNullableFilter;
@Field(() => StringFilter, { nullable: true })
commentThreadId?: StringFilter;
@Field(() => EnumCommentableTypeFilter, { nullable: true })
commentableType?: EnumCommentableTypeFilter;
@Field(() => StringFilter, { nullable: true })
commentableId?: StringFilter;
@Field(() => CommentThreadRelationFilter, { nullable: true })
commentThread?: CommentThreadRelationFilter;
}

32
server/src/api/@generated/comment-thread-target/comment-thread-target.model.ts Normal file
View File

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

14
server/src/api/@generated/comment-thread-target/create-many-comment-thread-target.args.ts Normal file
View File

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

11
server/src/api/@generated/comment-thread-target/create-one-comment-thread-target.args.ts Normal file
View File

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

11
server/src/api/@generated/comment-thread-target/delete-many-comment-thread-target.args.ts Normal file
View File

@ -0,0 +1,11 @@
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;
}

11
server/src/api/@generated/comment-thread-target/delete-one-comment-thread-target.args.ts Normal file
View File

@ -0,0 +1,11 @@
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;
}

32
server/src/api/@generated/comment-thread-target/find-first-comment-thread-target-or-throw.args.ts Normal file
View File

@ -0,0 +1,32 @@
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>;
}

32
server/src/api/@generated/comment-thread-target/find-first-comment-thread-target.args.ts Normal file
View File

@ -0,0 +1,32 @@
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>;
}

32
server/src/api/@generated/comment-thread-target/find-many-comment-thread-target.args.ts Normal file
View File

@ -0,0 +1,32 @@
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>;
}

11
server/src/api/@generated/comment-thread-target/find-unique-comment-thread-target-or-throw.args.ts Normal file
View File

@ -0,0 +1,11 @@
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;
}

11
server/src/api/@generated/comment-thread-target/find-unique-comment-thread-target.args.ts Normal file
View File

@ -0,0 +1,11 @@
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;
}

16
server/src/api/@generated/comment-thread-target/update-many-comment-thread-target.args.ts Normal file
View File

@ -0,0 +1,16 @@
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 { CommentThreadTargetWhereInput } from './comment-thread-target-where.input';
@ArgsType()
export class UpdateManyCommentThreadTargetArgs {
@Field(() => CommentThreadTargetUpdateManyMutationInput, { nullable: false })
@Type(() => CommentThreadTargetUpdateManyMutationInput)
data!: CommentThreadTargetUpdateManyMutationInput;
@Field(() => CommentThreadTargetWhereInput, { nullable: true })
@Type(() => CommentThreadTargetWhereInput)
where?: CommentThreadTargetWhereInput;
}

16
server/src/api/@generated/comment-thread-target/update-one-comment-thread-target.args.ts Normal file
View File

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

21
server/src/api/@generated/comment-thread-target/upsert-one-comment-thread-target.args.ts Normal file
View File

@ -0,0 +1,21 @@
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;
}

17
server/src/api/@generated/comment-thread/aggregate-comment-thread.output.ts Normal file
View File

@ -0,0 +1,17 @@
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;
}

38
server/src/api/@generated/comment-thread/comment-thread-aggregate.args.ts Normal file
View File

@ -0,0 +1,38 @@
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;
}

24
server/src/api/@generated/comment-thread/comment-thread-count-aggregate.input.ts Normal file
View File

@ -0,0 +1,24 @@
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;
@Field(() => Boolean, { nullable: true })
createdAt?: true;
@Field(() => Boolean, { nullable: true })
updatedAt?: true;
@Field(() => Boolean, { nullable: true })
deletedAt?: true;
@HideField()
workspaceId?: true;
@Field(() => Boolean, { nullable: true })
_all?: true;
}

24
server/src/api/@generated/comment-thread/comment-thread-count-aggregate.output.ts Normal file
View File

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

22
server/src/api/@generated/comment-thread/comment-thread-count-order-by-aggregate.input.ts Normal file
View File

@ -0,0 +1,22 @@
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;
@Field(() => SortOrder, { nullable: true })
createdAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true })
updatedAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true })
deletedAt?: keyof typeof SortOrder;
@HideField()
workspaceId?: keyof typeof SortOrder;
}

14
server/src/api/@generated/comment-thread/comment-thread-create-many-workspace-input-envelope.input.ts Normal file
View File

@ -0,0 +1,14 @@
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;
}

17
server/src/api/@generated/comment-thread/comment-thread-create-many-workspace.input.ts Normal file
View File

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

21
server/src/api/@generated/comment-thread/comment-thread-create-many.input.ts Normal file
View File

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

30
server/src/api/@generated/comment-thread/comment-thread-create-nested-many-without-workspace.input.ts Normal file
View File

@ -0,0 +1,30 @@
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>;
}

25
server/src/api/@generated/comment-thread/comment-thread-create-nested-one-without-comment-thread-targets.input.ts Normal file
View File

@ -0,0 +1,25 @@
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;
}

20
server/src/api/@generated/comment-thread/comment-thread-create-nested-one-without-comments.input.ts Normal file
View File

@ -0,0 +1,20 @@
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;
}

18
server/src/api/@generated/comment-thread/comment-thread-create-or-connect-without-comment-thread-targets.input.ts Normal file
View File

@ -0,0 +1,18 @@
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;
}

16
server/src/api/@generated/comment-thread/comment-thread-create-or-connect-without-comments.input.ts Normal file
View File

@ -0,0 +1,16 @@
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;
}

16
server/src/api/@generated/comment-thread/comment-thread-create-or-connect-without-workspace.input.ts Normal file
View File

@ -0,0 +1,16 @@
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;
}

28
server/src/api/@generated/comment-thread/comment-thread-create-without-comment-thread-targets.input.ts Normal file
View File

@ -0,0 +1,28 @@
import { Field } from '@nestjs/graphql';
import { InputType } 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 { HideField } from '@nestjs/graphql';
@InputType()
export class CommentThreadCreateWithoutCommentThreadTargetsInput {
@Field(() => String, { nullable: false })
id!: string;
@Field(() => Date, { nullable: true })
createdAt?: Date | string;
@Field(() => Date, { nullable: true })
updatedAt?: Date | string;
@Field(() => Date, { nullable: true })
deletedAt?: Date | string;
@Field(() => CommentCreateNestedManyWithoutCommentThreadInput, {
nullable: true,
})
comments?: CommentCreateNestedManyWithoutCommentThreadInput;
@HideField()
workspace!: WorkspaceCreateNestedOneWithoutCommentThreadsInput;
}

28
server/src/api/@generated/comment-thread/comment-thread-create-without-comments.input.ts Normal file
View File

@ -0,0 +1,28 @@
import { Field } from '@nestjs/graphql';
import { InputType } 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 { HideField } from '@nestjs/graphql';
@InputType()
export class CommentThreadCreateWithoutCommentsInput {
@Field(() => String, { nullable: false })
id!: string;
@Field(() => Date, { nullable: true })
createdAt?: Date | string;
@Field(() => Date, { nullable: true })
updatedAt?: Date | string;
@Field(() => Date, { nullable: true })
deletedAt?: Date | string;
@Field(() => CommentThreadTargetCreateNestedManyWithoutCommentThreadInput, {
nullable: true,
})
commentThreadTargets?: CommentThreadTargetCreateNestedManyWithoutCommentThreadInput;
@HideField()
workspace!: WorkspaceCreateNestedOneWithoutCommentThreadsInput;
}

29
server/src/api/@generated/comment-thread/comment-thread-create-without-workspace.input.ts Normal file
View File

@ -0,0 +1,29 @@
import { Field } from '@nestjs/graphql';
import { InputType } 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';
@InputType()
export class CommentThreadCreateWithoutWorkspaceInput {
@Field(() => String, { nullable: false })
id!: string;
@Field(() => Date, { nullable: true })
createdAt?: Date | string;
@Field(() => Date, { nullable: true })
updatedAt?: Date | string;
@Field(() => Date, { nullable: true })
deletedAt?: Date | string;
@Field(() => CommentThreadTargetCreateNestedManyWithoutCommentThreadInput, {
nullable: true,
})
commentThreadTargets?: CommentThreadTargetCreateNestedManyWithoutCommentThreadInput;
@Field(() => CommentCreateNestedManyWithoutCommentThreadInput, {
nullable: true,
})
comments?: CommentCreateNestedManyWithoutCommentThreadInput;
}

34
server/src/api/@generated/comment-thread/comment-thread-create.input.ts Normal file
View File

@ -0,0 +1,34 @@
import { Field } from '@nestjs/graphql';
import { InputType } 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 { HideField } from '@nestjs/graphql';
@InputType()
export class CommentThreadCreateInput {
@Field(() => String, { nullable: false })
id!: string;
@Field(() => Date, { nullable: true })
createdAt?: Date | string;
@Field(() => Date, { nullable: true })
updatedAt?: Date | string;
@Field(() => Date, { nullable: true })
deletedAt?: Date | string;
@Field(() => CommentThreadTargetCreateNestedManyWithoutCommentThreadInput, {
nullable: true,
})
commentThreadTargets?: CommentThreadTargetCreateNestedManyWithoutCommentThreadInput;
@Field(() => CommentCreateNestedManyWithoutCommentThreadInput, {
nullable: true,
})
comments?: CommentCreateNestedManyWithoutCommentThreadInput;
@HideField()
workspace!: WorkspaceCreateNestedOneWithoutCommentThreadsInput;
}

42
server/src/api/@generated/comment-thread/comment-thread-group-by.args.ts Normal file
View File

@ -0,0 +1,42 @@
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;
}

32
server/src/api/@generated/comment-thread/comment-thread-group-by.output.ts Normal file
View File

@ -0,0 +1,32 @@
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 CommentThreadGroupBy {
@Field(() => String, { nullable: false })
id!: string;
@Field(() => Date, { nullable: false })
createdAt!: Date | string;
@Field(() => Date, { nullable: false })
updatedAt!: Date | string;
@Field(() => Date, { nullable: true })
deletedAt?: Date | string;
@Field(() => String, { nullable: false })
workspaceId!: string;
@Field(() => CommentThreadCountAggregate, { nullable: true })
_count?: CommentThreadCountAggregate;
@Field(() => CommentThreadMinAggregate, { nullable: true })
_min?: CommentThreadMinAggregate;
@Field(() => CommentThreadMaxAggregate, { nullable: true })
_max?: CommentThreadMaxAggregate;
}

15
server/src/api/@generated/comment-thread/comment-thread-list-relation-filter.input.ts Normal file
View File

@ -0,0 +1,15 @@
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;
}

21
server/src/api/@generated/comment-thread/comment-thread-max-aggregate.input.ts Normal file
View File

@ -0,0 +1,21 @@
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;
@Field(() => Boolean, { nullable: true })
createdAt?: true;
@Field(() => Boolean, { nullable: true })
updatedAt?: true;
@Field(() => Boolean, { nullable: true })
deletedAt?: true;
@HideField()
workspaceId?: true;
}

20
server/src/api/@generated/comment-thread/comment-thread-max-aggregate.output.ts Normal file
View File

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

22
server/src/api/@generated/comment-thread/comment-thread-max-order-by-aggregate.input.ts Normal file
View File

@ -0,0 +1,22 @@
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;
@Field(() => SortOrder, { nullable: true })
createdAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true })
updatedAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true })
deletedAt?: keyof typeof SortOrder;
@HideField()
workspaceId?: keyof typeof SortOrder;
}

21
server/src/api/@generated/comment-thread/comment-thread-min-aggregate.input.ts Normal file
View File

@ -0,0 +1,21 @@
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;
@Field(() => Boolean, { nullable: true })
createdAt?: true;
@Field(() => Boolean, { nullable: true })
updatedAt?: true;
@Field(() => Boolean, { nullable: true })
deletedAt?: true;
@HideField()
workspaceId?: true;
}

20
server/src/api/@generated/comment-thread/comment-thread-min-aggregate.output.ts Normal file
View File

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

22
server/src/api/@generated/comment-thread/comment-thread-min-order-by-aggregate.input.ts Normal file
View File

@ -0,0 +1,22 @@
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 CommentThreadMinOrderByAggregateInput {
@Field(() => SortOrder, { nullable: true })
id?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true })
createdAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true })
updatedAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true })
deletedAt?: keyof typeof SortOrder;
@HideField()
workspaceId?: keyof typeof SortOrder;
}

9
server/src/api/@generated/comment-thread/comment-thread-order-by-relation-aggregate.input.ts Normal file
View File

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

34
server/src/api/@generated/comment-thread/comment-thread-order-by-with-aggregation.input.ts Normal file
View File

@ -0,0 +1,34 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { SortOrder } from '../prisma/sort-order.enum';
import { HideField } from '@nestjs/graphql';
import { CommentThreadCountOrderByAggregateInput } from './comment-thread-count-order-by-aggregate.input';
import { CommentThreadMaxOrderByAggregateInput } from './comment-thread-max-order-by-aggregate.input';
import { CommentThreadMinOrderByAggregateInput } from './comment-thread-min-order-by-aggregate.input';
@InputType()
export class CommentThreadOrderByWithAggregationInput {
@Field(() => SortOrder, { nullable: true })
id?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true })
createdAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true })
updatedAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true })
deletedAt?: keyof typeof SortOrder;
@HideField()
workspaceId?: keyof typeof SortOrder;
@Field(() => CommentThreadCountOrderByAggregateInput, { nullable: true })
_count?: CommentThreadCountOrderByAggregateInput;
@Field(() => CommentThreadMaxOrderByAggregateInput, { nullable: true })
_max?: CommentThreadMaxOrderByAggregateInput;
@Field(() => CommentThreadMinOrderByAggregateInput, { nullable: true })
_min?: CommentThreadMinOrderByAggregateInput;
}

36
server/src/api/@generated/comment-thread/comment-thread-order-by-with-relation.input.ts Normal file
View File

@ -0,0 +1,36 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { SortOrder } from '../prisma/sort-order.enum';
import { HideField } from '@nestjs/graphql';
import { CommentThreadTargetOrderByRelationAggregateInput } from '../comment-thread-target/comment-thread-target-order-by-relation-aggregate.input';
import { CommentOrderByRelationAggregateInput } from '../comment/comment-order-by-relation-aggregate.input';
import { WorkspaceOrderByWithRelationInput } from '../workspace/workspace-order-by-with-relation.input';
@InputType()
export class CommentThreadOrderByWithRelationInput {
@Field(() => SortOrder, { nullable: true })
id?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true })
createdAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true })
updatedAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true })
deletedAt?: keyof typeof SortOrder;
@HideField()
workspaceId?: keyof typeof SortOrder;
@Field(() => CommentThreadTargetOrderByRelationAggregateInput, {
nullable: true,
})
commentThreadTargets?: CommentThreadTargetOrderByRelationAggregateInput;
@Field(() => CommentOrderByRelationAggregateInput, { nullable: true })
comments?: CommentOrderByRelationAggregateInput;
@HideField()
workspace?: WorkspaceOrderByWithRelationInput;
}

12
server/src/api/@generated/comment-thread/comment-thread-relation-filter.input.ts Normal file
View File

@ -0,0 +1,12 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { CommentThreadWhereInput } from './comment-thread-where.input';
@InputType()
export class CommentThreadRelationFilter {
@Field(() => CommentThreadWhereInput, { nullable: true })
is?: CommentThreadWhereInput;
@Field(() => CommentThreadWhereInput, { nullable: true })
isNot?: CommentThreadWhereInput;
}

14
server/src/api/@generated/comment-thread/comment-thread-scalar-field.enum.ts Normal file
View File

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

39
server/src/api/@generated/comment-thread/comment-thread-scalar-where-with-aggregates.input.ts Normal file
View File

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

33
server/src/api/@generated/comment-thread/comment-thread-scalar-where.input.ts Normal file
View File

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

30
server/src/api/@generated/comment-thread/comment-thread-unchecked-create-nested-many-without-workspace.input.ts Normal file
View File

@ -0,0 +1,30 @@
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 CommentThreadUncheckedCreateNestedManyWithoutWorkspaceInput {
@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>;
}

27
server/src/api/@generated/comment-thread/comment-thread-unchecked-create-without-comment-thread-targets.input.ts Normal file
View File

@ -0,0 +1,27 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { HideField } from '@nestjs/graphql';
import { CommentUncheckedCreateNestedManyWithoutCommentThreadInput } from '../comment/comment-unchecked-create-nested-many-without-comment-thread.input';
@InputType()
export class CommentThreadUncheckedCreateWithoutCommentThreadTargetsInput {
@Field(() => String, { nullable: false })
id!: string;
@Field(() => Date, { nullable: true })
createdAt?: Date | string;
@Field(() => Date, { nullable: true })
updatedAt?: Date | string;
@Field(() => Date, { nullable: true })
deletedAt?: Date | string;
@HideField()
workspaceId!: string;
@Field(() => CommentUncheckedCreateNestedManyWithoutCommentThreadInput, {
nullable: true,
})
comments?: CommentUncheckedCreateNestedManyWithoutCommentThreadInput;
}

28
server/src/api/@generated/comment-thread/comment-thread-unchecked-create-without-comments.input.ts Normal file
View File

@ -0,0 +1,28 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { HideField } from '@nestjs/graphql';
import { CommentThreadTargetUncheckedCreateNestedManyWithoutCommentThreadInput } from '../comment-thread-target/comment-thread-target-unchecked-create-nested-many-without-comment-thread.input';
@InputType()
export class CommentThreadUncheckedCreateWithoutCommentsInput {
@Field(() => String, { nullable: false })
id!: string;
@Field(() => Date, { nullable: true })
createdAt?: Date | string;
@Field(() => Date, { nullable: true })
updatedAt?: Date | string;
@Field(() => Date, { nullable: true })
deletedAt?: Date | string;
@HideField()
workspaceId!: string;
@Field(
() => CommentThreadTargetUncheckedCreateNestedManyWithoutCommentThreadInput,
{ nullable: true },
)
commentThreadTargets?: CommentThreadTargetUncheckedCreateNestedManyWithoutCommentThreadInput;
}

30
server/src/api/@generated/comment-thread/comment-thread-unchecked-create-without-workspace.input.ts Normal file
View File

@ -0,0 +1,30 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { CommentThreadTargetUncheckedCreateNestedManyWithoutCommentThreadInput } from '../comment-thread-target/comment-thread-target-unchecked-create-nested-many-without-comment-thread.input';
import { CommentUncheckedCreateNestedManyWithoutCommentThreadInput } from '../comment/comment-unchecked-create-nested-many-without-comment-thread.input';
@InputType()
export class CommentThreadUncheckedCreateWithoutWorkspaceInput {
@Field(() => String, { nullable: false })
id!: string;
@Field(() => Date, { nullable: true })
createdAt?: Date | string;
@Field(() => Date, { nullable: true })
updatedAt?: Date | string;
@Field(() => Date, { nullable: true })
deletedAt?: Date | string;
@Field(
() => CommentThreadTargetUncheckedCreateNestedManyWithoutCommentThreadInput,
{ nullable: true },
)
commentThreadTargets?: CommentThreadTargetUncheckedCreateNestedManyWithoutCommentThreadInput;
@Field(() => CommentUncheckedCreateNestedManyWithoutCommentThreadInput, {
nullable: true,
})
comments?: CommentUncheckedCreateNestedManyWithoutCommentThreadInput;
}

34
server/src/api/@generated/comment-thread/comment-thread-unchecked-create.input.ts Normal file
View File

@ -0,0 +1,34 @@
import { Field } from '@nestjs/graphql';
import { InputType } from '@nestjs/graphql';
import { HideField } from '@nestjs/graphql';
import { CommentThreadTargetUncheckedCreateNestedManyWithoutCommentThreadInput } from '../comment-thread-target/comment-thread-target-unchecked-create-nested-many-without-comment-thread.input';
import { CommentUncheckedCreateNestedManyWithoutCommentThreadInput } from '../comment/comment-unchecked-create-nested-many-without-comment-thread.input';
@InputType()
export class CommentThreadUncheckedCreateInput {
@Field(() => String, { nullable: false })
id!: string;
@Field(() => Date, { nullable: true })
createdAt?: Date | string;
@Field(() => Date, { nullable: true })
updatedAt?: Date | string;
@Field(() => Date, { nullable: true })
deletedAt?: Date | string;
@HideField()
workspaceId!: string;
@Field(
() => CommentThreadTargetUncheckedCreateNestedManyWithoutCommentThreadInput,
{ nullable: true },
)
commentThreadTargets?: CommentThreadTargetUncheckedCreateNestedManyWithoutCommentThreadInput;
@Field(() => CommentUncheckedCreateNestedManyWithoutCommentThreadInput, {
nullable: true,
})
comments?: CommentUncheckedCreateNestedManyWithoutCommentThreadInput;
}

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