lib/utils.js

getServerSideProps

prisma

getServerSideProps

var thisPreventsThePrismaClientError = prisma

meta

Record<string, unknown>

error.meta.target

object

{}

export declare class PrismaClientKnownRequestError extends Error {
    code: string;
    meta?: object;
    clientVersion: string;
    constructor(message: string, code: string, clientVersion: string, meta?: any);
    get [Symbol.toStringTag](): string;
}

model App {
  id                  String               @id @default(cuid())
  createdAt           DateTime             @default(now())
  updatedAt           DateTime?            @updatedAt
  name                String

  redirects Redirects[]

  @@index([slug], map: "App.slug_index")
}

model Redirects {
  id String @id @default(cuid())

  global Boolean

  afterSignup   String?
  afterLogin    String?
  afterLogout   String?

  appId String
  app   App    @relation(fields: [appId], references: [id])
}

appId

global

true

upsert

id

where

prisma.redirects.upsert({
      where: {
        appId,
        global:true
      },
      create: {
        ...redirects,
        app: { connect: { id: appId } },
      },
      update: {
        ...redirects,
        app: { connect: { id: appId } },
      }
    })

aThing

bThing

aThing

bThing

const enquiry = await db.enquiry.findFirst({
    where: { id },
    include: {
      users: {
        include: {
          user: true,
        },
      },
    },
  })

  if (!enquiry) throw new NotFoundError()

  const partner = enquiry.users.filter((arr) => arr.user.role === "PARTNER")[0]
  const customer = enquiry.users.filter((arr) => arr.user.role === "USER")[0]

return { ...enquiry, partner, customer }

this.model.groupBy({
      by: ["id"], // <- what goes here?
      _avg: {}, // <- what goes here?
      orderBy: {_avg:{}},// <- what goes here? 
      where: {
        AND: [
          { CandidateVacancyMatch: { every: { isLatest: true } } }, // latest matches
          this.filterForUserRead(user),
        ],
      },
    })

const i = await this.prisma.transactions.groupBy({
      by: ['status'],
      where: {
        status: { in: ['APPROVED', 'COMPLETED', 'PENDING'] }
      },
      _count: {
        status: true
      }
    })
console.log(i) // []

// i need something like
// {approved: 0, pending: 0, completed: 0}

/Users/cyber/dev/platform/node_modules/@prisma/client/runtime/index.js:39054
        throw new PrismaClientUnknownRequestError(message, this.client._clientVersion);
              ^
PrismaClientUnknownRequestError: 
Invalid `prisma.candidate.findUnique()` invocation:


  Error occurred during query execution:
ConnectorError(ConnectorError { user_facing_error: None, kind: QueryError(Error { kind: FromSql(4), cause: Some(WasNull) }) })
    at Object.request (/Users/cyber/dev/platform/node_modules/@prisma/client/runtime/index.js:39054:15)
    at async CandidateRepository.getByIdOr404 (file:///Users/cyber/dev/platform/packages/service/src/repo/repository/base.ts:82:17)

@map

_OrgToUser

_org_to_user

// see <https://www.apollographql.com/docs/tutorial/data-source/>
import { RequestOptions, RESTDataSource, Request, Response } from "apollo-datasource-rest";
//...
export class ZenApi extends RESTDataSource<Request> {
  constructor() {
    super();     
  }
  baseURL = `https://${
      process.env.ZEN_SUBDOMAIN || ""
      }.<http://zendesk.com/api/v2/`;|zendesk.com/api/v2/`;> 
// do stuff -- get post etc
  async zenPostUserCreateTicket(ticketInput: ZenUserCreateTicketInput) {
    return await <http://this.post|this.post><ZenSyncUserTicketOutput>('tickets', { ticketInput }).then((ticket) => ticket)
  }
}

// IN THE SERVER FILE
	const server = new ApolloServer({
		schema,
        typeDefs,
		apollo as ApolloConfigInput,
		playground: isProdEnvironment() === false,
		dataSources: (): DataSources<object> => {
			return {
				zenApi: new ZenApi()
			}
		},
		async context({ req, res }): Promise<Context> { /*return prisma in context*/}

User

InternalUserProfile

User.type = INTERNAL

model User {
  id                  Int                  @id @default(autoincrement())
  type                UserType
  internalUserProfile InternalUserProfile?
}

model InternalUserProfile {
  user   User @relation(fields: [userId = User.id AND User.type = 'INTERNAL'], references: [id])
  userId Int
}

enum UserType {
  INTERNAL
  EXTERNAL
}

-W

--ignore-workspace-root-check

error Running this command will add the dependency to the workspace root rather than the workspace itself, which might not be what you want - if you really meant it, make it explicit by running this command again with the -W flag (or --ignore-workspace-root-check).

prisma migrate reset --force

--skip-generate