tip schema (#580)

apps/protocol-api/src/prisma/generated/type-graphql/enums/SplitContractScalarFieldEnum.ts

@@ -0,0 +1,16 @@
+import * as TypeGraphQL from "type-graphql";
+
+export enum SplitContractScalarFieldEnum {
+  id = "id",
+  createdAt = "createdAt",
+  updatedAt = "updatedAt",
+  chain_id = "chain_id",
+  address = "address",
+  tx_hash = "tx_hash",
+  enabled = "enabled",
+  user_split_contract_id = "user_split_contract_id"
+}
+TypeGraphQL.registerEnumType(SplitContractScalarFieldEnum, {
+  name: "SplitContractScalarFieldEnum",
+  description: undefined,
+});

apps/protocol-api/src/prisma/generated/type-graphql/enums/SplitPaymentScalarFieldEnum.ts

@@ -0,0 +1,18 @@
+import * as TypeGraphQL from "type-graphql";
+
+export enum SplitPaymentScalarFieldEnum {
+  id = "id",
+  createdAt = "createdAt",
+  updatedAt = "updatedAt",
+  token_address = "token_address",
+  amount = "amount",
+  tx_hash = "tx_hash",
+  sender_address = "sender_address",
+  recipient_address = "recipient_address",
+  sender_user_id = "sender_user_id",
+  split_contract_id = "split_contract_id"
+}
+TypeGraphQL.registerEnumType(SplitPaymentScalarFieldEnum, {
+  name: "SplitPaymentScalarFieldEnum",
+  description: undefined,
+});

apps/protocol-api/src/prisma/generated/type-graphql/enums/UserSplitContractScalarFieldEnum.ts

@@ -0,0 +1,13 @@
+import * as TypeGraphQL from "type-graphql";
+
+export enum UserSplitContractScalarFieldEnum {
+  id = "id",
+  createdAt = "createdAt",
+  updatedAt = "updatedAt",
+  user_id = "user_id",
+  enabled = "enabled"
+}
+TypeGraphQL.registerEnumType(UserSplitContractScalarFieldEnum, {
+  name: "UserSplitContractScalarFieldEnum",
+  description: undefined,
+});

apps/protocol-api/src/prisma/generated/type-graphql/enums/index.ts

@@ -30,11 +30,14 @@ export { LinearUserScalarFieldEnum } from "./LinearUserScalarFieldEnum";
 export { PartnerScalarFieldEnum } from "./PartnerScalarFieldEnum";
 export { QueryMode } from "./QueryMode";
 export { SortOrder } from "./SortOrder";
+export { SplitContractScalarFieldEnum } from "./SplitContractScalarFieldEnum";
+export { SplitPaymentScalarFieldEnum } from "./SplitPaymentScalarFieldEnum";
 export { TransactionIsolationLevel } from "./TransactionIsolationLevel";
 export { TwitterAccountScalarFieldEnum } from "./TwitterAccountScalarFieldEnum";
 export { TwitterTweetContributionScalarFieldEnum } from "./TwitterTweetContributionScalarFieldEnum";
 export { TwitterTweetScalarFieldEnum } from "./TwitterTweetScalarFieldEnum";
 export { TwitterUserScalarFieldEnum } from "./TwitterUserScalarFieldEnum";
 export { UserActivityScalarFieldEnum } from "./UserActivityScalarFieldEnum";
 export { UserScalarFieldEnum } from "./UserScalarFieldEnum";
+export { UserSplitContractScalarFieldEnum } from "./UserSplitContractScalarFieldEnum";
 export { VerificationSettingScalarFieldEnum } from "./VerificationSettingScalarFieldEnum";

apps/protocol-api/src/prisma/generated/type-graphql/models/Chain.ts

@@ -3,6 +3,7 @@ import * as GraphQLScalars from "graphql-scalars";
 import { Prisma } from "@prisma/client";
 import { DecimalJSScalar } from "../scalars";
 import { Contribution } from "../models/Contribution";
+import { SplitContract } from "../models/SplitContract";
 import { ChainCount } from "../resolvers/outputs/ChainCount";
 
 @TypeGraphQL.ObjectType("Chain", {
@@ -36,6 +37,8 @@ export class Chain {
 
   contributions?: Contribution[];
 
+  split_contracts?: SplitContract[];
+
   @TypeGraphQL.Field(_type => ChainCount, {
     nullable: true
   })

apps/protocol-api/src/prisma/generated/type-graphql/models/SplitContract.ts

@@ -0,0 +1,64 @@
+import * as TypeGraphQL from "type-graphql";
+import * as GraphQLScalars from "graphql-scalars";
+import { Prisma } from "@prisma/client";
+import { DecimalJSScalar } from "../scalars";
+import { Chain } from "../models/Chain";
+import { SplitPayment } from "../models/SplitPayment";
+import { UserSplitContract } from "../models/UserSplitContract";
+import { SplitContractCount } from "../resolvers/outputs/SplitContractCount";
+
+@TypeGraphQL.ObjectType("SplitContract", {
+  isAbstract: true
+})
+export class SplitContract {
+  @TypeGraphQL.Field(_type => TypeGraphQL.Int, {
+    nullable: false
+  })
+  id!: number;
+
+  @TypeGraphQL.Field(_type => Date, {
+    nullable: false
+  })
+  createdAt!: Date;
+
+  @TypeGraphQL.Field(_type => Date, {
+    nullable: false
+  })
+  updatedAt!: Date;
+
+  @TypeGraphQL.Field(_type => TypeGraphQL.Int, {
+    nullable: false
+  })
+  chain_id!: number;
+
+  chain?: Chain;
+
+  @TypeGraphQL.Field(_type => String, {
+    nullable: false
+  })
+  address!: string;
+
+  @TypeGraphQL.Field(_type => String, {
+    nullable: false
+  })
+  tx_hash!: string;
+
+  @TypeGraphQL.Field(_type => Boolean, {
+    nullable: false
+  })
+  enabled!: boolean;
+
+  split_payments?: SplitPayment[];
+
+  @TypeGraphQL.Field(_type => TypeGraphQL.Int, {
+    nullable: true
+  })
+  user_split_contract_id?: number | null;
+
+  user_split_contract?: UserSplitContract | null;
+
+  @TypeGraphQL.Field(_type => SplitContractCount, {
+    nullable: true
+  })
+  _count?: SplitContractCount | null;
+}

apps/protocol-api/src/prisma/generated/type-graphql/models/SplitPayment.ts

@@ -0,0 +1,65 @@
+import * as TypeGraphQL from "type-graphql";
+import * as GraphQLScalars from "graphql-scalars";
+import { Prisma } from "@prisma/client";
+import { DecimalJSScalar } from "../scalars";
+import { SplitContract } from "../models/SplitContract";
+import { User } from "../models/User";
+
+@TypeGraphQL.ObjectType("SplitPayment", {
+  isAbstract: true
+})
+export class SplitPayment {
+  @TypeGraphQL.Field(_type => TypeGraphQL.Int, {
+    nullable: false
+  })
+  id!: number;
+
+  @TypeGraphQL.Field(_type => Date, {
+    nullable: false
+  })
+  createdAt!: Date;
+
+  @TypeGraphQL.Field(_type => Date, {
+    nullable: false
+  })
+  updatedAt!: Date;
+
+  @TypeGraphQL.Field(_type => String, {
+    nullable: false
+  })
+  token_address!: string;
+
+  @TypeGraphQL.Field(_type => GraphQLScalars.BigIntResolver, {
+    nullable: false
+  })
+  amount!: bigint;
+
+  @TypeGraphQL.Field(_type => String, {
+    nullable: false
+  })
+  tx_hash!: string;
+
+  @TypeGraphQL.Field(_type => String, {
+    nullable: false
+  })
+  sender_address!: string;
+
+  @TypeGraphQL.Field(_type => String, {
+    nullable: false
+  })
+  recipient_address!: string;
+
+  @TypeGraphQL.Field(_type => TypeGraphQL.Int, {
+    nullable: true
+  })
+  sender_user_id?: number | null;
+
+  sender_user?: User | null;
+
+  @TypeGraphQL.Field(_type => TypeGraphQL.Int, {
+    nullable: false
+  })
+  split_contract_id!: number;
+
+  split_contract?: SplitContract;
+}

apps/protocol-api/src/prisma/generated/type-graphql/models/User.ts

@@ -9,8 +9,10 @@ import { DiscordUser } from "../models/DiscordUser";
 import { GuildUser } from "../models/GuildUser";
 import { LinearUser } from "../models/LinearUser";
 import { Partner } from "../models/Partner";
+import { SplitPayment } from "../models/SplitPayment";
 import { TwitterUser } from "../models/TwitterUser";
 import { UserActivity } from "../models/UserActivity";
+import { UserSplitContract } from "../models/UserSplitContract";
 import { UserCount } from "../resolvers/outputs/UserCount";
 
 @TypeGraphQL.ObjectType("User", {
@@ -85,6 +87,10 @@ export class User {
 
   discord_users?: DiscordUser[];
 
+  split_contracts?: UserSplitContract[];
+
+  sent_split_payments?: SplitPayment[];
+
   @TypeGraphQL.Field(_type => UserCount, {
     nullable: true
   })

apps/protocol-api/src/prisma/generated/type-graphql/models/UserSplitContract.ts

@@ -0,0 +1,46 @@
+import * as TypeGraphQL from "type-graphql";
+import * as GraphQLScalars from "graphql-scalars";
+import { Prisma } from "@prisma/client";
+import { DecimalJSScalar } from "../scalars";
+import { SplitContract } from "../models/SplitContract";
+import { User } from "../models/User";
+import { UserSplitContractCount } from "../resolvers/outputs/UserSplitContractCount";
+
+@TypeGraphQL.ObjectType("UserSplitContract", {
+  isAbstract: true
+})
+export class UserSplitContract {
+  @TypeGraphQL.Field(_type => TypeGraphQL.Int, {
+    nullable: false
+  })
+  id!: number;
+
+  @TypeGraphQL.Field(_type => Date, {
+    nullable: false
+  })
+  createdAt!: Date;
+
+  @TypeGraphQL.Field(_type => Date, {
+    nullable: false
+  })
+  updatedAt!: Date;
+
+  @TypeGraphQL.Field(_type => TypeGraphQL.Int, {
+    nullable: false
+  })
+  user_id!: number;
+
+  user?: User;
+
+  @TypeGraphQL.Field(_type => Boolean, {
+    nullable: false
+  })
+  enabled!: boolean;
+
+  split_contract?: SplitContract[];
+
+  @TypeGraphQL.Field(_type => UserSplitContractCount, {
+    nullable: true
+  })
+  _count?: UserSplitContractCount | null;
+}

apps/protocol-api/src/prisma/generated/type-graphql/models/index.ts

@@ -27,10 +27,13 @@ export { LinearProject } from "./LinearProject";
 export { LinearTeam } from "./LinearTeam";
 export { LinearUser } from "./LinearUser";
 export { Partner } from "./Partner";
+export { SplitContract } from "./SplitContract";
+export { SplitPayment } from "./SplitPayment";
 export { TwitterAccount } from "./TwitterAccount";
 export { TwitterTweet } from "./TwitterTweet";
 export { TwitterTweetContribution } from "./TwitterTweetContribution";
 export { TwitterUser } from "./TwitterUser";
 export { User } from "./User";
 export { UserActivity } from "./UserActivity";
+export { UserSplitContract } from "./UserSplitContract";
 export { VerificationSetting } from "./VerificationSetting";

apps/protocol-api/src/prisma/generated/type-graphql/resolvers/crud/SplitContract/AggregateSplitContractResolver.ts

@@ -0,0 +1,19 @@
+import * as TypeGraphQL from "type-graphql";
+import { GraphQLResolveInfo } from "graphql";
+import { AggregateSplitContractArgs } from "./args/AggregateSplitContractArgs";
+import { SplitContract } from "../../../models/SplitContract";
+import { AggregateSplitContract } from "../../outputs/AggregateSplitContract";
+import { transformInfoIntoPrismaArgs, getPrismaFromContext, transformCountFieldIntoSelectRelationsCount } from "../../../helpers";
+
+@TypeGraphQL.Resolver(_of => SplitContract)
+export class AggregateSplitContractResolver {
+  @TypeGraphQL.Query(_returns => AggregateSplitContract, {
+    nullable: false
+  })
+  async aggregateSplitContract(@TypeGraphQL.Ctx() ctx: any, @TypeGraphQL.Info() info: GraphQLResolveInfo, @TypeGraphQL.Args() args: AggregateSplitContractArgs): Promise<AggregateSplitContract> {
+    return getPrismaFromContext(ctx).splitContract.aggregate({
+      ...args,
+      ...transformInfoIntoPrismaArgs(info),
+    });
+  }
+}

apps/protocol-api/src/prisma/generated/type-graphql/resolvers/crud/SplitContract/CreateManySplitContractResolver.ts

@@ -0,0 +1,20 @@
+import * as TypeGraphQL from "type-graphql";
+import { GraphQLResolveInfo } from "graphql";
+import { CreateManySplitContractArgs } from "./args/CreateManySplitContractArgs";
+import { SplitContract } from "../../../models/SplitContract";
+import { AffectedRowsOutput } from "../../outputs/AffectedRowsOutput";
+import { transformInfoIntoPrismaArgs, getPrismaFromContext, transformCountFieldIntoSelectRelationsCount } from "../../../helpers";
+
+@TypeGraphQL.Resolver(_of => SplitContract)
+export class CreateManySplitContractResolver {
+  @TypeGraphQL.Mutation(_returns => AffectedRowsOutput, {
+    nullable: false
+  })
+  async createManySplitContract(@TypeGraphQL.Ctx() ctx: any, @TypeGraphQL.Info() info: GraphQLResolveInfo, @TypeGraphQL.Args() args: CreateManySplitContractArgs): Promise<AffectedRowsOutput> {
+    const { _count } = transformInfoIntoPrismaArgs(info);
+    return getPrismaFromContext(ctx).splitContract.createMany({
+      ...args,
+      ...(_count && transformCountFieldIntoSelectRelationsCount(_count)),
+    });
+  }
+}

apps/protocol-api/src/prisma/generated/type-graphql/resolvers/crud/SplitContract/CreateOneSplitContractResolver.ts

@@ -0,0 +1,19 @@
+import * as TypeGraphQL from "type-graphql";
+import { GraphQLResolveInfo } from "graphql";
+import { CreateOneSplitContractArgs } from "./args/CreateOneSplitContractArgs";
+import { SplitContract } from "../../../models/SplitContract";
+import { transformInfoIntoPrismaArgs, getPrismaFromContext, transformCountFieldIntoSelectRelationsCount } from "../../../helpers";
+
+@TypeGraphQL.Resolver(_of => SplitContract)
+export class CreateOneSplitContractResolver {
+  @TypeGraphQL.Mutation(_returns => SplitContract, {
+    nullable: false
+  })
+  async createOneSplitContract(@TypeGraphQL.Ctx() ctx: any, @TypeGraphQL.Info() info: GraphQLResolveInfo, @TypeGraphQL.Args() args: CreateOneSplitContractArgs): Promise<SplitContract> {
+    const { _count } = transformInfoIntoPrismaArgs(info);
+    return getPrismaFromContext(ctx).splitContract.create({
+      ...args,
+      ...(_count && transformCountFieldIntoSelectRelationsCount(_count)),
+    });
+  }
+}

apps/protocol-api/src/prisma/generated/type-graphql/resolvers/crud/SplitContract/DeleteManySplitContractResolver.ts

@@ -0,0 +1,20 @@
+import * as TypeGraphQL from "type-graphql";
+import { GraphQLResolveInfo } from "graphql";
+import { DeleteManySplitContractArgs } from "./args/DeleteManySplitContractArgs";
+import { SplitContract } from "../../../models/SplitContract";
+import { AffectedRowsOutput } from "../../outputs/AffectedRowsOutput";
+import { transformInfoIntoPrismaArgs, getPrismaFromContext, transformCountFieldIntoSelectRelationsCount } from "../../../helpers";
+
+@TypeGraphQL.Resolver(_of => SplitContract)
+export class DeleteManySplitContractResolver {
+  @TypeGraphQL.Mutation(_returns => AffectedRowsOutput, {
+    nullable: false
+  })
+  async deleteManySplitContract(@TypeGraphQL.Ctx() ctx: any, @TypeGraphQL.Info() info: GraphQLResolveInfo, @TypeGraphQL.Args() args: DeleteManySplitContractArgs): Promise<AffectedRowsOutput> {
+    const { _count } = transformInfoIntoPrismaArgs(info);
+    return getPrismaFromContext(ctx).splitContract.deleteMany({
+      ...args,
+      ...(_count && transformCountFieldIntoSelectRelationsCount(_count)),
+    });
+  }
+}

apps/protocol-api/src/prisma/generated/type-graphql/resolvers/crud/SplitContract/DeleteOneSplitContractResolver.ts

@@ -0,0 +1,19 @@
+import * as TypeGraphQL from "type-graphql";
+import { GraphQLResolveInfo } from "graphql";
+import { DeleteOneSplitContractArgs } from "./args/DeleteOneSplitContractArgs";
+import { SplitContract } from "../../../models/SplitContract";
+import { transformInfoIntoPrismaArgs, getPrismaFromContext, transformCountFieldIntoSelectRelationsCount } from "../../../helpers";
+
+@TypeGraphQL.Resolver(_of => SplitContract)
+export class DeleteOneSplitContractResolver {
+  @TypeGraphQL.Mutation(_returns => SplitContract, {
+    nullable: true
+  })
+  async deleteOneSplitContract(@TypeGraphQL.Ctx() ctx: any, @TypeGraphQL.Info() info: GraphQLResolveInfo, @TypeGraphQL.Args() args: DeleteOneSplitContractArgs): Promise<SplitContract | null> {
+    const { _count } = transformInfoIntoPrismaArgs(info);
+    return getPrismaFromContext(ctx).splitContract.delete({
+      ...args,
+      ...(_count && transformCountFieldIntoSelectRelationsCount(_count)),
+    });
+  }
+}