prisma migrate

up

prisma seed

UNION

replica

master

model Item {
  id String @unique
}

model Set {
  additions Item[]
  removals Item[]
}

@default(crypt(genSaltSync(10), ""))

import { User } from '@prisma/client';
import { AppError } from '../shared/errors/AppError';
import prismaClient from '../prisma';
import { hash } from 'bcryptjs';
import { CreateUserDTO } from '../dtos/user/CreateUserDto';

class CreateUserService {
  async execute({
    _name_,
    _email_,
    _password_,
    _admin_,
  }: _CreateUserDTO_): _Promise_<_User_ | _undefined_> {
    const passwodHash = await hash(_password_, 8);

    const userAlreadyExists = await prismaClient.user.findUnique({
      where: {
        email,
      },
    });

    if (!userAlreadyExists) {
      try {
        const user = await prismaClient.user.create({
          data: {
            name,
            email,
            password: passwodHash,
            admin,
          },
        });
        return user;
      } catch (error) {
        throw *new* AppError('User already exists!');
      }
    }
  }
}

export { CreateUserService };

Killed

v2.27.0

v3.11.0

Prisma

delete

postgres

Jest

NodeEnvironment

prisma

--runInBand

class PrismaTestEnvironment extends NodeEnvironment {
  connectionString?: string;

  schema?: string;

  app?: ExpressType;

  constructor(config: Config.ProjectConfig) {
    //@ts-ignore
    super(config);

    // Generate a unique schema identifier for this test context
    this.schema = stringGenerator();
    //pseudo-code, set random schema on DB_URL ENV
      this.global.process.env.DB_URL = `{myConnectionString}/${this.schema}`
      process.env.DB_URL = `{myConnectionString}/${this.schema}`

  }

  public async setup(): Promise<void> {
    process.env.DB_URL = this.connectionString;
    this.global.process.env.DB_URL = this.connectionString;
    forceResetPrisma();

    // Run the migrations to ensure our schema has the required structure
    try {
      const out = await promisifiedExec(
        `${prismaBinary} db push --force-reset`
      );

      <http://this.app|this.app> = await initExpress();
      <http://this.global.APP|this.global.APP> = <http://this.app|this.app>;
      
    } catch (e) {
      console.error(e);
      throw e;
    }

    return super.setup();
  }

  public async teardown(): Promise<void> {
    const prismaClient = getPrisma();
    await prismaClient.$executeRawUnsafe(
      `drop schema if exists "${this.schema}" cascade`
    );
    await prismaClient.$disconnect();
    await super.teardown();
  }
}

export default PrismaTestEnvironment;

import { PrismaClient, Prisma } from '@prisma/client';

let db: PrismaClient;
const DefaultLogLevels: Prisma.LogLevel[] = ['info', 'warn', 'error'];

export const getPrisma = (log: Array<Prisma.LogLevel> = DefaultLogLevels) => {
  if (!db) {
    forceResetPrisma(log);
  }
  return db;
};

export const hasPrisma = () => !!db;

/**
 * Force reset the DB instance using the current @param DB_URL environment var
 * @param log
 * @returns
 */
export const forceResetPrisma = (
  log: Array<Prisma.LogLevel> = DefaultLogLevels
) => {
  console.log(`[PRISMA] Generating Client with log levels ${log.join(',')} `);
  try {
    db = new PrismaClient({
      log,
    });
  } catch (e) {
    console.error(e);
    throw e;
  }
  return db;
};

const allUsers = await prisma.user.findMany({
    include: { 
      posts: true,
      limit: 10 // <--- Something like this
    },
  })

@prisma/client

GenericFailure

export const GetReachForServiceIds = async (serviceIds: string[], startDate: Date, endDate: Date) => {
    try {
        const result = await PrismaService.reach_growth.findMany({
            where: { service_id: { in: serviceIds }, date: { gte: startDate, lte: endDate } },
        });

        return [result, null] as const;
    } catch (err) {
        Logger.error({ kind: "leaderboard_reach", method: "GetReachForServiceIds", error: err, stack_trace: err.stack });
        return [null, err] as const;
    }
};

Invalid `PrismaService.reach_growth.findMany()` invocation in
/home/kay/checkpoint/leaderboards/src/reach/reach.service.ts:19:57

  16 
  17 export const GetReachForServiceIds = async (serviceIds: string[], startDate: Date, endDate: Date) => {
  18     try {
→ 19         const result = await PrismaService.reach_growth.findMany(
  
    at Object.request (/home/kay/checkpoint/leaderboards/node_modules/@prisma/client/runtime/index.js:39818:15)
    at async PrismaClient._request (/home/kay/checkpoint/leaderboards/node_modules/@prisma/client/runtime/index.js:40646:18)
    at async GetReachForServiceIds (/home/kay/checkpoint/leaderboards/src/reach/reach.service.ts:19:24)
    at async LeaderboardReach (/home/kay/checkpoint/leaderboards/src/reach/leaderboard-reach.ts:23:37)
    at async Main (/home/kay/checkpoint/leaderboards/src/reach/main.ts:9:9) {
  code: 'GenericFailure',
  clientVersion: '3.11.0',
  meta: undefined

return ctx.prisma.dataProvider.update({

data: {

name: args.data?.name,

description: args.data?.description,

},

where: {

id: BigInt(args.data.id), // <===== I have to do this to every Prisma operation where I work with IDS

},

});

order

MultiSubnetFailover

findRaw

const rawUsers = await prisma.user.findRaw(); // empty array
  const users = await prisma.user.findMany(); // all users as expected