resolve

createType

extendType

Type '(_parent: {}, args: { accountId?: number; }, context: Context) => PrismaPromise<Application[]>' is not assignable to type 'FieldResolver<"Query", "applicationsByAccountId">'

definition(t) {
		t.nonNull.list.nonNull.field("applicationsByAccountId", {
			type: "Application",
			args: {
				accountId: intArg()
			},
			resolve: (_parent, args, context: Context) => {
				return context.prisma.account
					.findUnique({
						where: { id: args.accountId }
					})
					.applications();
			}
		});
	}

const statusResults = await prisma.status.groupBy({
      by: ["url"],
      where: {
        AND: {
          userIdStr: {
            in: followIds,
          },
          createdAt: {
            gte: startDate,
          },
        },
      },
      count: {
        url: true,
      },
      // this orderBy doesn't seem to be working.
      orderBy: {
        count: {
          url: "desc",
        },
      },
      having: {
        url: {
          count: {
            gt: 1,
          },
        },
      },
    });

TSError: ⨯ Unable to compile TypeScript:
script.ts:88:9 - error TS2322: Type '{ count: { url: string; }; }' is not assignable to type 'Enumerable<StatusOrderByInput> | undefined'.
  Object literal may only specify known properties, and 'count' does not exist in type 'Enumerable<StatusOrderByInput>'.

_count

count

Can't resolve '_http_common' in 'C:\Users\ricky\projects\spectr\server\node_modules\@prisma\client\runtime'

externals: ["_http_common"],

node build/index.js

ReferenceError: _http_common is not defined

Enumerable

XOR

const leveling = await prisma.leveling.findMany({ orderBy: { totalXp: "desc" } })
const index = leveling.findIndex((l) => l.userId === user.id)

SELECT inviterId, count(*) as count FROM invites where serverId = ${member.guild.id} AND valid = 1 GROUP BY inviterId ORDER BY count DESC LIMIT 10

const users = await ctx.prisma.user.findMany({
      where: {
        profile: {
          firstName: {
            contains: args.where.firstName
          },
          DOB: {
            
          }
        }
      }})

createMany

create

SELECT ?

model User {
  id              String            @id @default(uuid())
  firstName       String
  lastName        String
  email           String            @unique
  /// @TypeGraphQL.omit(output: true)
  password        String
  accountType     accountType       @default(STUDENT)
  role            role              @default(LEARNER)
  profileStudent  ProfileStudent?
  profileTeacher  ProfileTeacher?
  ....
}

Typegraphql Prisma

@TypeGraphQL.ObjectType({
  isAbstract: true
})
export class User {
  @TypeGraphQL.Field(_type => String, {
    nullable: false
  })
  id!: string;

  @TypeGraphQL.Field(_type => String, {
    nullable: false
  })
  firstName!: string;

  @TypeGraphQL.Field(_type => String, {
    nullable: false
  })
  lastName!: string;

  @TypeGraphQL.Field(_type => String, {
    nullable: false
  })
  email!: string;

  password?: string;

  @TypeGraphQL.Field(_type => accountType, {
    nullable: false
  })
  accountType!: "STUDENT" | "TEACHER";

  @TypeGraphQL.Field(_type => role, {
    nullable: false
  })
  role!: "ADMIN" | "INSTRUCTOR" | "LEARNER";

  profileStudent?: ProfileStudent | null;

  profileTeacher?: ProfileTeacher | null;

profileStudent

profileTeacher

type User {
  UserCohort: [UserCohort!]
  UserSubject: [UserSubject!]
  _count: UserCount
  accountType: accountType!
  createdAt: DateTime!
  email: String!
  firstName: String!
  id: String!
  lastName: String!
  messagingId: String
  role: role!
  status: accountStatus!
  token: String
  updatedAt: DateTime!
}

skip

limit