PrismaClient

import { PrismaClient } from '@prisma/client';
const prisma = new PrismaClient();

"the best practice is to create the prisma client once and import it - this way you're not recreating database connections if multiple files use prisma, etc"

CROSS JOIN

<http://railway.app|railway.app>

data proxy

error - InvalidDatasourceError: Datasource URL should use Prisma:// protocol. 
If you are not using the Data Proxy, remove the data proxy from the preview features in your 
schema and ensure that PRISMA_CLIENT_ENGINE_TYPE environment variable is not set to data proxy.

previewFeatures = ["dataProxy"]

prisma.schema

generator client {
      provider = "prisma-client-js"
}

datasource db {
      provider = "postgresql"
      url= env("DATABASE_URL")
}

prisma.findMany

error - Error: Error serializing `.categories[0].createdAt` returned from `getServerSideProps` in "/".
Reason: `object` ("[object Date]") cannot be serialized as JSON. Please only return JSON serializable data types.

yarn add @graphql-yoga/node

require("dotenv").config();
import { PrismaClient } from "@prisma/client";
import * as path from "path";
import { nexusSchemaPrisma } from "nexus-plugin-prisma/schema";
import { makeSchema } from "@nexus/schema";
import { createServer } from "@graphql-yoga/node";
import { checkEnv } from "./src/utils";
import { getClaims } from "./src/auth";
import config from "./config";
import { Query, Mutation } from "./src/types";

checkEnv(config.requieredEnvs);

const schema = makeSchema({
  types: [Query, Mutation],

  plugins: [
    nexusSchemaPrisma({
      experimentalCRUD: true,
    }),
  ],

  outputs: {
    schema: path.join(__dirname, "./src/generated/schema.graphql"),
    typegen: path.join(__dirname, "./src/generated/nexus.ts"),
  },
});

const serverOptions = {
  port: process.env.MAIL_PORT || 4000,
};

const server = createServer({
  schema,
  context: async (req) => {
    return {
      ...req,
      PrismaClient,
      claims: await getClaims(req),
      options: serverOptions,
    };
  },
});

server.start();
console.log(`🚀  Server is running on <http://localhost>:${serverOptions.port}`);

User model

siteUser

Moderators

prisma.schema

import { prisma } from "../prisma";


await prisma.$transaction(async (prisma) => {
    
    const booking = await prisma.bookingGroup.create(..)
    EmailService.sendEmail(booking) //If this function also has a prisma call, the transaction fails

});

return prisma.user.findUnique({

where: {

id: args.id,

},

select: {

posts: true

},

})

Expected Iterable, but did not find one for field \"Query.testQuery\"

const user = {
    id: 0102932023202,
    profile: {
        // This would be JSONB
    },
    inventory: [] // This is also JSONB
    badges: [] // This is also JSONB
}

model User {
  uid String @id @default(uuid())
  username String? @db.VarChar(24) @unique  
  favorites Post[]

model Post {
  id             Int     @id @default(autoincrement())
  title           String  @db.VarChar(255)
  favoritedBy User[]
}

connect

async function handler(req: NextApiRequest, res: NextApiResponse<Response>) {
  await verifyUserToken(req, res)

  const automobileQuery = req.query.automobile.toString().split(',')

  if (automobileQuery.length > 2) {
    throw new CustomError(
      400,
      'automobile URL parameter expects a maximum of two values'
    )
  }

  let values: VehicleType[] | undefined

  if (automobileQuery.includes('BIKE')) {
    if (values === undefined) values = []
    values.push(VehicleType.BIKE)
  }
  if (automobileQuery.includes('CAR')) {
    if (values === undefined) values = []
    values.push(VehicleType.CAR)
  }

  let vehicleType = undefined

  let orders = await prisma.order.findMany({
    where: {
      vendorId: null,
      trackingStatus: 'READY_FOR_PICKUP',
      vehicleType: { in: values },
    },
  })

  return res.json({
    status: true,
    data: { orders },
  })
}